From 60693a6078a9255a97267621e76ef43a71d0320b Mon Sep 17 00:00:00 2001
From: Dev Nirwal <devnirwal@Newtons-MacBook-Pro-2.local>
Date: Mon, 27 Oct 2025 11:27:06 +0530
Subject: [PATCH 1/2] Added 500+ leetcode solutions

---
 .DS_Store                                     | Bin 0 -> 6148 bytes
 .../leetcode/0001-two-sum/0001-two-sum.cpp    |  14 +
 .../leetcode/0001-two-sum/0001-two-sum.java   |  17 +
 leetcode/leetcode/0001-two-sum/NOTES.md       |   1 +
 leetcode/leetcode/0001-two-sum/README.md      |  41 +
 ...ubstring-without-repeating-characters.java |  20 +
 .../README.md                                 |  35 +
 .../0005-longest-palindromic-substring.java   |  34 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  24 +
 .../0009-palindrome-number.java               |  23 +
 .../leetcode/0009-palindrome-number/NOTES.md  |   1 +
 .../0011-container-with-most-water.java       |  28 +
 .../0011-container-with-most-water/NOTES.md   |   1 +
 .../0011-container-with-most-water/README.md  |  32 +
 .../0013-roman-to-integer.java                |  77 ++
 .../leetcode/0013-roman-to-integer/NOTES.md   |   1 +
 .../leetcode/0013-roman-to-integer/README.md  |  57 ++
 .../0014-longest-common-prefix.java           |  21 +
 .../0014-longest-common-prefix/NOTES.md       |   1 +
 .../0014-longest-common-prefix/README.md      |  27 +
 leetcode/leetcode/0015-3sum/0015-3sum.java    |  32 +
 leetcode/leetcode/0015-3sum/README.md         |  41 +
 .../0016-3sum-closest/0016-3sum-closest.java  |  24 +
 leetcode/leetcode/0016-3sum-closest/README.md |  31 +
 .../0020-valid-parentheses.java               |  22 +
 .../leetcode/0020-valid-parentheses/README.md |  50 ++
 .../0021-merge-two-sorted-lists.java          |  37 +
 .../0021-merge-two-sorted-lists/README.md     |  36 +
 .../0023-merge-k-sorted-lists.java            |  45 +
 .../0023-merge-k-sorted-lists/README.md       |  45 +
 .../0024-swap-nodes-in-pairs.java             |  20 +
 .../0024-swap-nodes-in-pairs/NOTES.md         |   1 +
 .../0024-swap-nodes-in-pairs/README.md        |  29 +
 .../0025-reverse-nodes-in-k-group.java        |  46 +
 .../0025-reverse-nodes-in-k-group/README.md   |  32 +
 ...x-of-the-first-occurrence-in-a-string.java |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  26 +
 .../0029-divide-two-integers.java             |  33 +
 .../0029-divide-two-integers/README.md        |  32 +
 .../0032-longest-valid-parentheses.java       |  17 +
 .../0032-longest-valid-parentheses/NOTES.md   |   1 +
 .../0032-longest-valid-parentheses/README.md  |  31 +
 .../0033-search-in-rotated-sorted-array.java  |  27 +
 .../README.md                                 |  29 +
 ...t-position-of-element-in-sorted-array.java |  38 +
 .../README.md                                 |  26 +
 .../0038-count-and-say.java                   |  20 +
 .../leetcode/0038-count-and-say/README.md     |  50 ++
 .../0039-combination-sum.java                 |  29 +
 .../0039-combination-sum.py                   |  19 +
 .../leetcode/0039-combination-sum/README.md   |  41 +
 .../0040-combination-sum-ii.py                |  20 +
 .../0040-combination-sum-ii/README.md         |  39 +
 .../0045-jump-game-ii/0045-jump-game-ii.java  |  18 +
 leetcode/leetcode/0045-jump-game-ii/README.md |  35 +
 .../0046-permutations/0046-permutations.java  |  29 +
 leetcode/leetcode/0046-permutations/README.md |  21 +
 .../0048-rotate-image/0048-rotate-image.java  |  34 +
 leetcode/leetcode/0048-rotate-image/README.md |  27 +
 .../0049-group-anagrams.java                  |  23 +
 .../leetcode/0049-group-anagrams/README.md    |  43 +
 .../leetcode/0050-powx-n/0050-powx-n.java     |  16 +
 leetcode/leetcode/0050-powx-n/NOTES.md        |   1 +
 leetcode/leetcode/0050-powx-n/README.md       |  35 +
 .../0053-maximum-subarray.java                |  13 +
 .../leetcode/0053-maximum-subarray/README.md  |  37 +
 .../0055-jump-game/0055-jump-game.java        |  21 +
 leetcode/leetcode/0055-jump-game/README.md    |  28 +
 .../0056-merge-intervals.java                 |  34 +
 .../leetcode/0056-merge-intervals/README.md   |  27 +
 .../0057-insert-interval.java                 |  71 ++
 .../leetcode/0057-insert-interval/README.md   |  32 +
 .../0058-length-of-last-word.java             |  14 +
 .../0058-length-of-last-word/NOTES.md         |   1 +
 .../0058-length-of-last-word/README.md        |  35 +
 .../0061-rotate-list/0061-rotate-list.java    |  40 +
 leetcode/leetcode/0061-rotate-list/NOTES.md   |   1 +
 leetcode/leetcode/0061-rotate-list/README.md  |  25 +
 .../0062-unique-paths/0062-unique-paths.java  |  77 ++
 leetcode/leetcode/0062-unique-paths/README.md |  31 +
 .../0063-unique-paths-ii.java                 |  61 ++
 .../leetcode/0063-unique-paths-ii/README.md   |  36 +
 .../0064-minimum-path-sum.java                |  41 +
 .../leetcode/0064-minimum-path-sum/README.md  |  29 +
 leetcode/leetcode/0069-sqrtx/0069-sqrtx.java  |  18 +
 leetcode/leetcode/0069-sqrtx/README.md        |  31 +
 .../0070-climbing-stairs.java                 |  50 ++
 .../leetcode/0070-climbing-stairs/README.md   |  32 +
 .../0073-set-matrix-zeroes.java               |  68 ++
 .../leetcode/0073-set-matrix-zeroes/NOTES.md  |   1 +
 .../leetcode/0073-set-matrix-zeroes/README.md |  37 +
 .../0075-sort-colors/0075-sort-colors.java    |  24 +
 leetcode/leetcode/0075-sort-colors/README.md  |  32 +
 .../0076-minimum-window-substring.java        |  37 +
 .../0076-minimum-window-substring/README.md   |  42 +
 .../leetcode/0078-subsets/0078-subsets.java   |  26 +
 .../leetcode/0078-subsets/0078-subsets.py     |  16 +
 leetcode/leetcode/0078-subsets/README.md      |  27 +
 ...-remove-duplicates-from-sorted-list-ii.cpp |  41 +
 .../README.md                                 |  25 +
 ...83-remove-duplicates-from-sorted-list.java |  26 +
 .../README.md                                 |  25 +
 .../0088-merge-sorted-array.java              |  44 +
 .../leetcode/0088-merge-sorted-array/NOTES.md |   1 +
 .../0088-merge-sorted-array/README.md         |  48 +
 .../0092-reverse-linked-list-ii.java          |  61 ++
 .../0092-reverse-linked-list-ii/README.md     |  29 +
 .../0094-binary-tree-inorder-traversal.java   |  31 +
 .../0094-binary-tree-inorder-traversal.py     |  15 +
 .../README.md                                 |  53 ++
 .../0098-validate-binary-search-tree.java     |  34 +
 .../0098-validate-binary-search-tree.py       |  17 +
 .../README.md                                 |  33 +
 .../0100-same-tree/0100-same-tree.java        |  22 +
 leetcode/leetcode/0100-same-tree/NOTES.md     |   1 +
 leetcode/leetcode/0100-same-tree/README.md    |  33 +
 ...102-binary-tree-level-order-traversal.java |  45 +
 .../README.md                                 |  31 +
 ...ary-tree-zigzag-level-order-traversal.java |  48 +
 .../README.md                                 |  31 +
 .../0104-maximum-depth-of-binary-tree.java    |  25 +
 .../README.md                                 |  26 +
 ...e-from-inorder-and-postorder-traversal.cpp |  50 ++
 .../README.md                                 |  29 +
 ...rt-sorted-array-to-binary-search-tree.java |  33 +
 .../README.md                                 |  28 +
 .../0110-balanced-binary-tree.java            |  43 +
 .../0110-balanced-binary-tree/README.md       |  31 +
 .../leetcode/0112-path-sum/0112-path-sum.java |  24 +
 leetcode/leetcode/0112-path-sum/README.md     |  40 +
 ...14-flatten-binary-tree-to-linked-list.java |  38 +
 .../README.md                                 |  39 +
 ...ting-next-right-pointers-in-each-node.java |  51 ++
 .../README.md                                 |  46 +
 .../0118-pascals-triangle.java                |  31 +
 .../leetcode/0118-pascals-triangle/README.md  |  18 +
 .../0119-pascals-triangle-ii.java             |  23 +
 .../0119-pascals-triangle-ii/NOTES.md         |   1 +
 .../0119-pascals-triangle-ii/README.md        |  25 +
 .../leetcode/0120-triangle/0120-triangle.java |  54 ++
 leetcode/leetcode/0120-triangle/README.md     |  37 +
 .../0121-best-time-to-buy-and-sell-stock.java |  12 +
 .../0121-best-time-to-buy-and-sell-stock.py   |   8 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  31 +
 .../0124-binary-tree-maximum-path-sum.java    |  37 +
 .../README.md                                 |  30 +
 .../0125-valid-palindrome.java                |  22 +
 .../leetcode/0125-valid-palindrome/NOTES.md   |   1 +
 .../leetcode/0125-valid-palindrome/README.md  |  35 +
 .../0128-longest-consecutive-sequence.java    |  22 +
 .../README.md                                 |  34 +
 .../0129-sum-root-to-leaf-numbers.java        |  26 +
 .../0129-sum-root-to-leaf-numbers/README.md   |  43 +
 .../0131-palindrome-partitioning.py           |  18 +
 .../0131-palindrome-partitioning/README.md    |  17 +
 .../0133-clone-graph/0133-clone-graph.java    |  37 +
 leetcode/leetcode/0133-clone-graph/README.md  |  62 ++
 .../0134-gas-station/0134-gas-station.java    |  20 +
 leetcode/leetcode/0134-gas-station/README.md  |  43 +
 .../0138-copy-list-with-random-pointer.java   |  40 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  49 +
 .../0141-linked-list-cycle.java               |  25 +
 .../leetcode/0141-linked-list-cycle/NOTES.md  |   1 +
 .../leetcode/0141-linked-list-cycle/README.md |  42 +
 .../0142-linked-list-cycle-ii.java            |  30 +
 .../0142-linked-list-cycle-ii/README.md       |  42 +
 .../0143-reorder-list/0143-reorder-list.java  |  54 ++
 leetcode/leetcode/0143-reorder-list/README.md |  36 +
 .../0144-binary-tree-preorder-traversal.java  |  36 +
 .../0144-binary-tree-preorder-traversal.py    |  13 +
 .../README.md                                 |  53 ++
 .../0145-binary-tree-postorder-traversal.java |  27 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  53 ++
 .../0146-lru-cache/0146-lru-cache.java        | 100 +++
 leetcode/leetcode/0146-lru-cache/README.md    |  44 +
 .../0149-max-points-on-a-line.java            |  23 +
 .../0149-max-points-on-a-line/NOTES.md        |   1 +
 .../0149-max-points-on-a-line/README.md       |  26 +
 ...0150-evaluate-reverse-polish-notation.java |  29 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  51 ++
 .../0151-reverse-words-in-a-string.java       |  22 +
 .../0151-reverse-words-in-a-string/NOTES.md   |   1 +
 .../0151-reverse-words-in-a-string/README.md  |  41 +
 .../0152-maximum-product-subarray.java        |  16 +
 .../0152-maximum-product-subarray/README.md   |  29 +
 ...-find-minimum-in-rotated-sorted-array.java |  17 +
 ...53-find-minimum-in-rotated-sorted-array.py |  13 +
 .../README.md                                 |  48 +
 .../0155-min-stack/0155-min-stack.java        |  51 ++
 leetcode/leetcode/0155-min-stack/NOTES.md     |   1 +
 leetcode/leetcode/0155-min-stack/README.md    |  44 +
 ...0160-intersection-of-two-linked-lists.java |  59 ++
 .../README.md                                 |  67 ++
 .../0162-find-peak-element.java               |  22 +
 .../leetcode/0162-find-peak-element/README.md |  31 +
 ...0167-two-sum-ii-input-array-is-sorted.java |  18 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  43 +
 .../0169-majority-element.java                |  14 +
 .../leetcode/0169-majority-element/NOTES.md   |   1 +
 .../leetcode/0169-majority-element/README.md  |  23 +
 .../0175-combine-two-tables.sql               |   3 +
 .../leetcode/0175-combine-two-tables/NOTES.md |   1 +
 .../0176-second-highest-salary.sql            |   3 +
 .../0176-second-highest-salary/README.md      |  55 ++
 .../0177-nth-highest-salary/README.md         |  57 ++
 .../0179-largest-number.java                  |  19 +
 .../leetcode/0179-largest-number/NOTES.md     |   1 +
 .../leetcode/0179-largest-number/README.md    |  25 +
 .../0187-repeated-dna-sequences.java          |  31 +
 .../0187-repeated-dna-sequences/README.md     |  25 +
 .../0189-rotate-array/0189-rotate-array.java  |  19 +
 leetcode/leetcode/0189-rotate-array/NOTES.md  |   1 +
 leetcode/leetcode/0189-rotate-array/README.md |  39 +
 .../0191-number-of-1-bits.java                |  12 +
 .../leetcode/0191-number-of-1-bits/README.md  |  48 +
 .../0196-delete-duplicate-emails.sql          |   2 +
 .../0196-delete-duplicate-emails/NOTES.md     |   1 +
 .../0198-house-robber/0198-house-robber.java  |  66 ++
 .../0198-house-robber/0198-house-robber.py    |  19 +
 leetcode/leetcode/0198-house-robber/README.md |  30 +
 .../0199-binary-tree-right-side-view.java     |  35 +
 .../README.md                                 |  50 ++
 .../0200-number-of-islands.java               |  31 +
 .../leetcode/0200-number-of-islands/README.md |  38 +
 .../0201-bitwise-and-of-numbers-range.java    |  11 +
 .../README.md                                 |  30 +
 .../0205-isomorphic-strings.java              |  21 +
 .../leetcode/0205-isomorphic-strings/NOTES.md |   1 +
 .../0205-isomorphic-strings/README.md         |  26 +
 .../0206-reverse-linked-list.java             |  50 ++
 .../0206-reverse-linked-list.py               |  19 +
 .../0206-reverse-linked-list/README.md        |  34 +
 .../0209-minimum-size-subarray-sum.java       |  19 +
 .../0209-minimum-size-subarray-sum/README.md  |  36 +
 .../0213-house-robber-ii.java                 |  30 +
 .../leetcode/0213-house-robber-ii/README.md   |  36 +
 .../0214-shortest-palindrome.java             |  18 +
 .../0214-shortest-palindrome/NOTES.md         |   1 +
 .../0214-shortest-palindrome/README.md        |  20 +
 .../0215-kth-largest-element-in-an-array.java |  11 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  21 +
 .../0217-contains-duplicate.java              |  10 +
 .../0217-contains-duplicate/README.md         |  42 +
 .../0225-implement-stack-using-queues.java    |  45 +
 .../README.md                                 |  48 +
 .../0226-invert-binary-tree.java              |  40 +
 .../0226-invert-binary-tree/README.md         |  31 +
 .../0229-majority-element-ii.java             |  43 +
 .../0229-majority-element-ii/README.md        |  34 +
 .../0230-kth-smallest-element-in-a-bst.java   |  74 ++
 .../README.md                                 |  28 +
 .../0232-implement-queue-using-stacks.java    |  44 +
 .../README.md                                 |  48 +
 .../0234-palindrome-linked-list.java          |  52 ++
 .../0234-palindrome-linked-list/README.md     |  27 +
 ...mmon-ancestor-of-a-binary-search-tree.java |  36 +
 .../README.md                                 |  38 +
 ...west-common-ancestor-of-a-binary-tree.java |  30 +
 .../README.md                                 |  38 +
 .../0237-delete-node-in-a-linked-list.java    |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  48 +
 .../0238-product-of-array-except-self.java    |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  25 +
 .../0239-sliding-window-maximum.java          |  15 +
 .../0239-sliding-window-maximum/README.md     |  36 +
 ...241-different-ways-to-add-parentheses.java |  49 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  35 +
 .../0242-valid-anagram.java                   |  17 +
 leetcode/leetcode/0242-valid-anagram/NOTES.md |   1 +
 .../leetcode/0242-valid-anagram/README.md     |  23 +
 .../0257-binary-tree-paths.py                 |  34 +
 .../leetcode/0257-binary-tree-paths/README.md |  26 +
 .../0268-missing-number.java                  |   8 +
 .../leetcode/0268-missing-number/README.md    |  69 ++
 .../0283-move-zeroes/0283-move-zeroes.java    |  21 +
 leetcode/leetcode/0283-move-zeroes/NOTES.md   |   1 +
 leetcode/leetcode/0283-move-zeroes/README.md  |  22 +
 .../0287-find-the-duplicate-number.java       |  10 +
 .../0287-find-the-duplicate-number/README.md  |  44 +
 .../0300-longest-increasing-subsequence.java  |  20 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  35 +
 .../0303-range-sum-query-immutable.java       |  22 +
 .../0303-range-sum-query-immutable/README.md  |  39 +
 .../0322-coin-change/0322-coin-change.java    |  38 +
 leetcode/leetcode/0322-coin-change/README.md  |  37 +
 .../0326-power-of-three.java                  |  11 +
 .../leetcode/0326-power-of-three/README.md    |  38 +
 .../0328-odd-even-linked-list.cpp             |  29 +
 .../0328-odd-even-linked-list/README.md       |  30 +
 .../0334-increasing-triplet-subsequence.java  |  24 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  34 +
 .../0337-house-robber-iii.java                |  34 +
 .../leetcode/0337-house-robber-iii/README.md  |  30 +
 .../0338-counting-bits.java                   |  10 +
 .../leetcode/0338-counting-bits/README.md     |  42 +
 .../0342-power-of-four.java                   |  11 +
 .../leetcode/0342-power-of-four/README.md     |  24 +
 .../0345-reverse-vowels-of-a-string.java      |  31 +
 .../0345-reverse-vowels-of-a-string/README.md |  20 +
 .../0347-top-k-frequent-elements.java         |  36 +
 .../0347-top-k-frequent-elements/README.md    |  22 +
 .../0350-intersection-of-two-arrays-ii.java   |  18 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  33 +
 .../0374-guess-number-higher-or-lower.java    |  26 +
 .../README.md                                 |  45 +
 .../0380-insert-delete-getrandom-o1/README.md |  40 +
 .../0386-lexicographical-numbers.java         |  21 +
 .../0386-lexicographical-numbers/README.md    |  19 +
 .../0392-is-subsequence.java                  |  18 +
 .../leetcode/0392-is-subsequence/NOTES.md     |   1 +
 .../leetcode/0392-is-subsequence/README.md    |  23 +
 .../0402-remove-k-digits.java                 |  36 +
 .../leetcode/0402-remove-k-digits/README.md   |  35 +
 .../0404-sum-of-left-leaves.java              |  32 +
 .../0404-sum-of-left-leaves/README.md         |  27 +
 .../0416-partition-equal-subset-sum.java      |  76 ++
 .../0416-partition-equal-subset-sum/README.md |  26 +
 ...ngest-repeating-character-replacement.java |  23 +
 .../README.md                                 |  30 +
 .../0435-non-overlapping-intervals.java       |  16 +
 .../0435-non-overlapping-intervals/README.md  |  37 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  23 +
 .../0443-string-compression.java              |  29 +
 .../leetcode/0443-string-compression/NOTES.md |   1 +
 .../0443-string-compression/README.md         |  44 +
 .../0451-sort-characters-by-frequency.java    |  28 +
 .../README.md                                 |  39 +
 ...um-number-of-arrows-to-burst-balloons.java |  14 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  41 +
 .../0480-sliding-window-median.java           | 141 +++
 .../0480-sliding-window-median/README.md      |  42 +
 .../0485-max-consecutive-ones.java            |  17 +
 .../0485-max-consecutive-ones/README.md       |  25 +
 .../0503-next-greater-element-ii.java         |  47 +
 .../0503-next-greater-element-ii/README.md    |  29 +
 .../leetcode/0509-fibonacci-number/NOTES.md   |   1 +
 .../leetcode/0509-fibonacci-number/README.md  |  37 +
 .../0513-find-bottom-left-tree-value.java     |  35 +
 .../README.md                                 |  24 +
 .../README.md                                 |  23 +
 .../0516-longest-palindromic-subsequence.java |  57 ++
 .../README.md                                 |  28 +
 .../0525-contiguous-array.java                |  23 +
 .../leetcode/0525-contiguous-array/README.md  |  34 +
 .../0539-minimum-time-difference.java         |  40 +
 .../0539-minimum-time-difference/NOTES.md     |   1 +
 .../0539-minimum-time-difference/README.md    |  17 +
 ...0540-single-element-in-a-sorted-array.java |  30 +
 .../README.md                                 |  21 +
 .../0543-diameter-of-binary-tree.java         |  42 +
 .../0543-diameter-of-binary-tree/README.md    |  29 +
 .../0560-subarray-sum-equals-k.java           |  18 +
 .../0560-subarray-sum-equals-k/README.md      |  20 +
 .../0584-find-customer-referee.sql            |   2 +
 .../0584-find-customer-referee/README.md      |  48 +
 .../0605-can-place-flowers.java               |  28 +
 .../leetcode/0605-can-place-flowers/NOTES.md  |   1 +
 .../leetcode/0605-can-place-flowers/README.md |  22 +
 .../0621-task-scheduler.java                  |  24 +
 .../leetcode/0621-task-scheduler/NOTES.md     |   1 +
 .../leetcode/0621-task-scheduler/README.md    |  95 ++
 ...0637-average-of-levels-in-binary-tree.java |  40 +
 .../README.md                                 |  25 +
 .../0643-maximum-average-subarray-i.java      |  17 +
 .../0643-maximum-average-subarray-i/NOTES.md  |   1 +
 .../0643-maximum-average-subarray-i/README.md |  27 +
 .../0713-subarray-product-less-than-k.java    |  20 +
 .../README.md                                 |  28 +
 .../0724-find-pivot-index.java                |  19 +
 .../leetcode/0724-find-pivot-index/NOTES.md   |   1 +
 .../leetcode/0724-find-pivot-index/README.md  |  47 +
 .../0725-split-linked-list-in-parts.java      |  48 +
 .../0725-split-linked-list-in-parts/README.md |  36 +
 .../0735-asteroid-collision.java              |  37 +
 .../0735-asteroid-collision/README.md         |  39 +
 .../0739-daily-temperatures.java              |  14 +
 .../0739-daily-temperatures/README.md         |  20 +
 .../0763-partition-labels.java                |  28 +
 .../leetcode/0763-partition-labels/NOTES.md   |   1 +
 .../leetcode/0763-partition-labels/README.md  |  31 +
 .../0768-partition-labels.java                |  30 +
 .../leetcode/0768-partition-labels/README.md  |  32 +
 .../0783-search-in-a-binary-search-tree.py    |  13 +
 .../README.md                                 |  28 +
 ...0784-insert-into-a-binary-search-tree.java |  27 +
 .../0784-insert-into-a-binary-search-tree.py  |  15 +
 .../README.md                                 |  38 +
 .../0820-find-eventual-safe-states.java       |  34 +
 .../0820-find-eventual-safe-states/README.md  |  37 +
 .../0838-design-linked-list.java              | 135 +++
 .../0838-design-linked-list/README.md         |  43 +
 .../0844-backspace-string-compare.java        |  22 +
 .../0844-backspace-string-compare/NOTES.md    |   1 +
 .../0844-backspace-string-compare/README.md   |  37 +
 .../0872-leaf-similar-trees.java              |  41 +
 .../leetcode/0872-leaf-similar-trees/NOTES.md |   1 +
 .../0872-leaf-similar-trees/README.md         |  31 +
 ...884-uncommon-words-from-two-sentences.java |  34 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  37 +
 .../0894-all-possible-full-binary-trees.java  |  57 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  26 +
 .../0907-koko-eating-bananas.java             |  34 +
 .../0907-koko-eating-bananas/README.md        |  38 +
 .../0908-middle-of-the-linked-list.java       |  58 ++
 .../0908-middle-of-the-linked-list/README.md  |  28 +
 ...from-preorder-and-postorder-traversal.java |  41 +
 .../README.md                                 |  31 +
 ...26-flip-string-to-monotone-increasing.java |  21 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  36 +
 .../0937-online-stock-span.java               |  26 +
 .../leetcode/0937-online-stock-span/README.md |  44 +
 .../0944-delete-columns-to-make-sorted.java   |  19 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  56 ++
 .../0954-maximum-sum-circular-subarray.java   |  23 +
 .../README.md                                 |  39 +
 .../0966-binary-subarrays-with-sum.java       |  20 +
 .../0966-binary-subarrays-with-sum/README.md  |  32 +
 .../0967-minimum-falling-path-sum.java        |  91 ++
 .../0967-minimum-falling-path-sum/README.md   |  29 +
 .../0988-flip-equivalent-binary-trees.java    |  26 +
 .../README.md                                 |  36 +
 .../0997-find-the-town-judge/NOTES.md         |   1 +
 .../0997-find-the-town-judge/README.md        |  45 +
 leetcode/leetcode/1-two-sum/1-two-sum.java    |  15 +
 leetcode/leetcode/1-two-sum/NOTES.md          |   1 +
 leetcode/leetcode/1-two-sum/README.md         |  38 +
 .../1004-max-consecutive-ones-iii.java        |  48 +
 .../1004-max-consecutive-ones-iii/NOTES.md    |   1 +
 .../1004-max-consecutive-ones-iii/README.md   |  27 +
 ...y-search-tree-from-preorder-traversal.java |  32 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +
 .../1009-complement-of-base-10-integer.java   |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  40 +
 .../101-symmetric-tree.java                   |  28 +
 leetcode/leetcode/101-symmetric-tree/NOTES.md |   1 +
 .../leetcode/101-symmetric-tree/README.md     |  25 +
 .../1014-k-closest-points-to-origin.java      |  53 ++
 .../1014-k-closest-points-to-origin/README.md |  34 +
 ...1019-next-greater-node-in-linked-list.java |  46 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  28 +
 ...102-binary-tree-level-order-traversal.java |  34 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +
 ...22-sum-of-root-to-leaf-binary-numbers.java |  51 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  32 +
 ...-difference-between-node-and-ancestor.java |  28 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +
 ...ical-order-traversal-of-a-binary-tree.java |  74 ++
 .../README.md                                 |  52 ++
 ...ary-tree-zigzag-level-order-traversal.java |  40 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +
 ...30-smallest-string-starting-from-leaf.java |  36 +
 .../README.md                                 |  41 +
 .../README.md                                 |  34 +
 ...inary-search-tree-to-greater-sum-tree.java |  24 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  35 +
 .../104-maximum-depth-of-binary-tree.java     |  21 +
 .../104-maximum-depth-of-binary-tree/NOTES.md |   1 +
 .../README.md                                 |  25 +
 ...e-from-preorder-and-inorder-traversal.java |  31 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  28 +
 ...y-search-tree-from-preorder-traversal.java |  30 +
 .../README.md                                 |  31 +
 ...pacity-to-ship-packages-within-d-days.java |  36 +
 .../README.md                                 |  52 ++
 ...-from-inorder-and-postorder-traversal.java |  35 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  28 +
 ...raphically-smallest-equivalent-string.java |  27 +
 .../README.md                                 |  54 ++
 ...-binary-tree-level-order-traversal-ii.java |  37 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +
 ...71-greatest-common-divisor-of-strings.java |  17 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  31 +
 ...st-subsequence-of-distinct-characters.java |  51 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  25 +
 .../1089-duplicate-zeros.java                 |  23 +
 .../leetcode/1089-duplicate-zeros/README.md   |  27 +
 ...ecover-a-tree-from-preorder-traversal.java |  45 +
 .../README.md                                 |  37 +
 .../11-container-with-most-water.java         |  17 +
 .../11-container-with-most-water/NOTES.md     |   1 +
 .../11-container-with-most-water/README.md    |  31 +
 .../1110-delete-nodes-and-return-forest.java  |  60 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +
 .../1122-relative-sort-array.java             |  21 +
 .../1122-relative-sort-array/NOTES.md         |   1 +
 .../1122-relative-sort-array/README.md        |  27 +
 .../1137-n-th-tribonacci-number.java          |  17 +
 .../1137-n-th-tribonacci-number/NOTES.md      |   1 +
 .../1137-n-th-tribonacci-number/README.md     |  29 +
 .../1143-longest-common-subsequence.java      |  22 +
 .../1143-longest-common-subsequence/NOTES.md  |   1 +
 .../1143-longest-common-subsequence/README.md |  40 +
 .../1153-product-sales-analysis-i/README.md   |  75 ++
 ...ting-next-right-pointers-in-each-node.java |  42 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  44 +
 ...ords-that-can-be-formed-by-characters.java |  26 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +
 ...61-maximum-level-sum-of-a-binary-tree.java |  43 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +
 ...g-next-right-pointers-in-each-node-ii.java |  42 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  44 +
 .../1170-shortest-common-supersequence.java   |  42 +
 .../README.md                                 |  30 +
 ...um-consecutive-nodes-from-linked-list.java |  36 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  34 +
 .../118-pascals-triangle.java                 |  23 +
 .../leetcode/118-pascals-triangle/NOTES.md    |   1 +
 .../leetcode/118-pascals-triangle/README.md   |  19 +
 ...ings-between-each-pair-of-parentheses.java |  24 +
 .../1207-unique-number-of-occurrences.java    |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +
 .../121-best-time-to-buy-and-sell-stock.java  |  12 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +
 .../1224-minimum-falling-path-sum-ii.java     |  27 +
 .../README.md                                 |  33 +
 ...imum-remove-to-make-valid-parentheses.java |  24 +
 .../README.md                                 |  41 +
 .../1250-longest-common-subsequence.java      |  25 +
 .../1250-longest-common-subsequence/README.md |  42 +
 .../1258-article-views-i.sql                  |   2 +
 .../leetcode/1258-article-views-i/README.md   |  49 +
 ...lements-in-a-contaminated-binary-tree.java |  39 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  69 ++
 ...1266-minimum-time-visiting-all-points.java |  14 +
 .../README.md                                 |  43 +
 .../128-longest-consecutive-sequence.java     |  21 +
 .../128-longest-consecutive-sequence/NOTES.md |   1 +
 ...ppearing-more-than-25-in-sorted-array.java |  10 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  23 +
 .../129-sum-root-to-leaf-numbers.java         |  26 +
 .../129-sum-root-to-leaf-numbers/NOTES.md     |   1 +
 .../129-sum-root-to-leaf-numbers/README.md    |  43 +
 .../1291-sequential-digits.java               |  22 +
 .../leetcode/1291-sequential-digits/NOTES.md  |   1 +
 .../leetcode/1291-sequential-digits/README.md |  19 +
 ...rray-in-sets-of-k-consecutive-numbers.java |  33 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  36 +
 ...s-with-greatest-element-on-right-side.java |  14 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  33 +
 .../1302-deepest-leaves-sum.java              |  17 +
 .../leetcode/1302-deepest-leaves-sum/NOTES.md |   1 +
 .../1302-deepest-leaves-sum/README.md         |  22 +
 ...l-elements-in-two-binary-search-trees.java |  46 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  23 +
 .../1310-xor-queries-of-a-subarray.java       |  19 +
 .../1310-xor-queries-of-a-subarray/README.md  |  40 +
 ...of-nodes-with-even-valued-grandparent.java |  41 +
 .../NOTES.md                                  |   1 +
 .../1331-rank-transform-of-an-array.java      |  15 +
 .../1331-rank-transform-of-an-array/NOTES.md  |   1 +
 .../1331-rank-transform-of-an-array/README.md |  38 +
 ...ximum-candies-allocated-to-k-children.java |  47 +
 .../README.md                                 |  31 +
 .../134-gas-station/134-gas-station.java      |  19 +
 leetcode/leetcode/134-gas-station/NOTES.md    |   1 +
 leetcode/leetcode/134-gas-station/README.md   |  44 +
 .../136-single-number/136-single-number.java  |   9 +
 leetcode/leetcode/136-single-number/NOTES.md  |   1 +
 leetcode/leetcode/136-single-number/README.md |  24 +
 .../1367-linked-list-in-binary-tree.java      |  38 +
 .../1367-linked-list-in-binary-tree/NOTES.md  |   1 +
 .../1367-linked-list-in-binary-tree/README.md |  40 +
 ...ring-containing-vowels-in-even-counts.java |  20 +
 .../README.md                                 |  32 +
 .../1373-maximum-sum-bst-in-binary-tree.java  |  53 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  44 +
 ...53-find-minimum-in-rotated-sorted-array.py |  13 +
 .../README.md                                 |  47 +
 .../138-copy-list-with-random-pointer.java    |  32 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  47 +
 ...lements-in-a-contaminated-binary-tree.java |  39 +
 .../README.md                                 |  75 ++
 .../1390-four-divisors.java                   |  28 +
 leetcode/leetcode/1390-four-divisors/NOTES.md |   1 +
 .../leetcode/1390-four-divisors/README.md     |  34 +
 .../14-longest-common-prefix.java             |  18 +
 .../14-longest-common-prefix/NOTES.md         |   1 +
 .../14-longest-common-prefix/README.md        |  27 +
 .../141-linked-list-cycle.java                |  22 +
 .../leetcode/141-linked-list-cycle/NOTES.md   |   1 +
 ...r-of-fibonacci-numbers-whose-sum-is-k.java |  32 +
 .../NOTES.md                                  |   1 +
 .../142-linked-list-cycle-ii.java             |  30 +
 .../142-linked-list-cycle-ii/NOTES.md         |   1 +
 .../142-linked-list-cycle-ii/README.md        |  40 +
 ...nd-numbers-with-even-number-of-digits.java |  18 +
 .../README.md                                 |  33 +
 ...s-with-the-greatest-number-of-candies.java |  17 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  43 +
 ...-build-an-array-with-stack-operations.java |  17 +
 .../NOTES.md                                  |   1 +
 ...-time-to-collect-all-apples-in-a-tree.java |  27 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  37 +
 .../1448-count-good-nodes-in-binary-tree.java |  29 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  38 +
 .../1451-rearrange-words-in-a-sentence.java   |  14 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  46 +
 ...vowels-in-a-substring-of-given-length.java |  23 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  35 +
 ...rings-containing-all-three-characters.java |  24 +
 .../README.md                                 |  35 +
 .../147-insertion-sort-list.java              |  29 +
 .../leetcode/147-insertion-sort-list/NOTES.md |   1 +
 .../147-insertion-sort-list/README.md         |  33 +
 .../1476-subrectangle-queries.java            |  26 +
 .../1476-subrectangle-queries/NOTES.md        |   1 +
 .../1476-subrectangle-queries/README.md       |  80 ++
 .../leetcode/148-sort-list/148-sort-list.java |  91 ++
 leetcode/leetcode/148-sort-list/NOTES.md      |   1 +
 leetcode/leetcode/148-sort-list/README.md     |  32 +
 .../1480-running-sum-of-1d-array.java         |   8 +
 .../1480-running-sum-of-1d-array/NOTES.md     |   1 +
 .../1480-running-sum-of-1d-array/README.md    |  30 +
 ...luding-the-minimum-and-maximum-salary.java |  20 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +
 ...rray-of-1s-after-deleting-one-element.java |  29 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  34 +
 ...eck-if-array-pairs-are-divisible-by-k.java |  19 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  39 +
 .../150-evaluate-reverse-polish-notation.java |  23 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  44 +
 ...508-range-sum-of-sorted-subarray-sums.java |  26 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  35 +
 ...est-and-smallest-value-in-three-moves.java |  12 +
 .../NOTES.md                                  |   1 +
 ...employee-id-with-the-unique-identifier.sql |   2 +
 .../README.md                                 |  75 ++
 .../1518-water-bottles.java                   |  12 +
 leetcode/leetcode/1518-water-bottles/NOTES.md |   1 +
 .../leetcode/1518-water-bottles/README.md     |  31 +
 ...s-in-the-sub-tree-with-the-same-label.java |  37 +
 .../NOTES.md                                  |   1 +
 .../leetcode/155-min-stack/155-min-stack.java |  47 +
 leetcode/leetcode/155-min-stack/NOTES.md      |   1 +
 leetcode/leetcode/155-min-stack/README.md     |  42 +
 .../1550-three-consecutive-odds.java          |  17 +
 .../1550-three-consecutive-odds/NOTES.md      |   1 +
 .../1550-three-consecutive-odds/README.md     |  24 +
 ...-special-positions-in-a-binary-matrix.java |  25 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +
 .../1598-crawler-log-folder.java              |  17 +
 .../leetcode/1598-crawler-log-folder/NOTES.md |   1 +
 .../1598-crawler-log-folder/README.md         |  51 ++
 .../160-intersection-of-two-linked-lists.java |  42 +
 .../NOTES.md                                  |   1 +
 .../1609-even-odd-tree.java                   |  48 +
 leetcode/leetcode/1609-even-odd-tree/NOTES.md |   1 +
 .../leetcode/1609-even-odd-tree/README.md     |  49 +
 .../162-find-peak-element.java                |  15 +
 .../leetcode/162-find-peak-element/NOTES.md   |   1 +
 .../leetcode/162-find-peak-element/README.md  |  30 +
 ...631-number-of-sub-arrays-with-odd-sum.java |  22 +
 .../README.md                                 |  39 +
 .../1642-water-bottles.java                   |  12 +
 .../leetcode/1642-water-bottles/README.md     |  32 +
 .../1652-minimum-suffix-flips.py              |  22 +
 .../1652-minimum-suffix-flips/README.md       |  47 +
 ...k-if-two-string-arrays-are-equivalent.java |  23 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  36 +
 .../167-two-sum-ii-input-array-is-sorted.java |  19 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  41 +
 .../1672-richest-customer-wealth.java         |  11 +
 .../1672-richest-customer-wealth/NOTES.md     |   1 +
 .../1672-richest-customer-wealth/README.md    |  41 +
 .../1679-max-number-of-k-sum-pairs.java       |  21 +
 .../1679-max-number-of-k-sum-pairs/NOTES.md   |   1 +
 .../1679-max-number-of-k-sum-pairs/README.md  |  33 +
 ...ount-the-number-of-consistent-strings.java |  20 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  37 +
 ...minimum-number-of-deci-binary-numbers.java |  10 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  33 +
 .../169-majority-element.java                 |  12 +
 .../leetcode/169-majority-element/NOTES.md    |   1 +
 .../leetcode/169-majority-element/README.md   |  23 +
 ...letter-combinations-of-a-phone-number.java |  34 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  33 +
 .../1701-average-waiting-time.java            |  15 +
 .../1701-average-waiting-time/NOTES.md        |   1 +
 .../1701-average-waiting-time/README.md       |  44 +
 .../1710-maximum-units-on-a-truck.java        |  16 +
 .../1710-maximum-units-on-a-truck/NOTES.md    |   1 +
 .../1710-maximum-units-on-a-truck/README.md   |  39 +
 ...aximum-score-from-removing-substrings.java |  30 +
 .../README.md                                 |  45 +
 .../172-factorial-trailing-zeroes.java        |  13 +
 .../172-factorial-trailing-zeroes/NOTES.md    |   1 +
 .../172-factorial-trailing-zeroes/README.md   |  35 +
 .../1721-swapping-nodes-in-a-linked-list.java |  41 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  26 +
 ...ited-but-did-not-make-any-transactions.sql |   3 +
 .../README.md                                 |  80 ++
 .../173-binary-search-tree-iterator.java      |  50 ++
 .../173-binary-search-tree-iterator/NOTES.md  |   1 +
 .../1732-find-the-highest-altitude.java       |  11 +
 .../1732-find-the-highest-altitude/NOTES.md   |   1 +
 .../1732-find-the-highest-altitude/README.md  |  28 +
 .../1768-merge-strings-alternately.java       |  21 +
 .../1768-merge-strings-alternately/NOTES.md   |   1 +
 .../1768-merge-strings-alternately/README.md  |  42 +
 .../1791-find-center-of-star-graph.java       |  10 +
 .../1791-find-center-of-star-graph/README.md  |  30 +
 ...1817-finding-the-users-active-minutes.java |  19 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  42 +
 .../182-duplicate-emails.sql                  |   2 +
 .../leetcode/182-duplicate-emails/NOTES.md    |   1 +
 .../leetcode/182-duplicate-emails/README.md   |  41 +
 .../1822-sign-of-the-product-of-an-array.java |  11 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  42 +
 ...-find-the-winner-of-the-circular-game.java |  16 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  49 +
 .../1827-invalid-tweets.sql                   |   2 +
 .../leetcode/1827-invalid-tweets/README.md    |  44 +
 .../1833-maximum-ice-cream-bars.java          |  14 +
 .../1833-maximum-ice-cream-bars/NOTES.md      |   1 +
 .../1833-maximum-ice-cream-bars/README.md     |  39 +
 .../1845-seat-reservation-manager.java        |  27 +
 .../1845-seat-reservation-manager/NOTES.md    |   1 +
 .../1845-seat-reservation-manager/README.md   |  42 +
 ...ment-after-decreasing-and-rearranging.java |  20 +
 .../README.md                                 |  54 ++
 ...-maximum-absolute-sum-of-any-subarray.java |  17 +
 .../README.md                                 |  35 +
 ...if-number-is-a-sum-of-powers-of-three.java |  32 +
 .../README.md                                 |  34 +
 .../19-remove-nth-node-from-end-of-list.java  |  29 +
 .../NOTES.md                                  |   1 +
 .../1908-recyclable-and-low-fat-products.sql  |   2 +
 .../README.md                                 |  46 +
 .../1920-build-array-from-permutation.py      |   6 +
 .../README.md                                 |  35 +
 ...sum-of-digits-of-string-after-convert.java |  23 +
 .../README.md                                 |  51 ++
 ...find-greatest-common-divisor-of-array.java |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  43 +
 .../198-house-robber/198-house-robber.java    |  13 +
 leetcode/leetcode/198-house-robber/NOTES.md   |   1 +
 leetcode/leetcode/198-house-robber/README.md  |  29 +
 .../1983-maximum-population-year.java         |  21 +
 .../1983-maximum-population-year/README.md    |  31 +
 .../199-binary-tree-right-side-view.java      |  32 +
 .../199-binary-tree-right-side-view/NOTES.md  |   1 +
 .../199-binary-tree-right-side-view/README.md |  29 +
 .../1991-find-the-middle-index-in-array.java  |  19 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  43 +
 .../2-add-two-numbers/2-add-two-numbers.java  |  42 +
 leetcode/leetcode/2-add-two-numbers/NOTES.md  |   1 +
 .../20-valid-parentheses.java                 |  20 +
 .../leetcode/20-valid-parentheses/NOTES.md    |   1 +
 .../leetcode/20-valid-parentheses/README.md   |  36 +
 .../2000-reverse-prefix-of-word.java          |  16 +
 .../2000-reverse-prefix-of-word/NOTES.md      |   1 +
 .../2000-reverse-prefix-of-word/README.md     |  42 +
 .../202-happy-number/202-happy-number.java    |  21 +
 leetcode/leetcode/202-happy-number/NOTES.md   |   1 +
 ...remove-all-occurrences-of-a-substring.java |  88 ++
 .../README.md                                 |  44 +
 .../2048-build-array-from-permutation.java    |  11 +
 .../README.md                                 |  36 +
 ...mber-of-nodes-between-critical-points.java |  48 +
 .../README.md                                 |  50 ++
 ...ount-common-words-with-one-occurrence.java |  29 +
 .../README.md                                 |  38 +
 ...nd-target-indices-after-sorting-array.java |  19 +
 .../NOTES.md                                  |   1 +
 ...mber-of-ways-to-arrive-at-destination.java |  71 ++
 .../README.md                                 |  41 +
 ...moving-minimum-and-maximum-from-array.java |  18 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  49 +
 .../21-merge-two-sorted-lists.java            |  44 +
 .../21-merge-two-sorted-lists/NOTES.md        |   1 +
 .../2107-find-unique-binary-string.java       |  47 +
 .../2107-find-unique-binary-string/README.md  |  37 +
 ...ome-by-concatenating-two-letter-words.java |  29 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  42 +
 ...y-row-and-column-contains-all-numbers.java |  19 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +
 ...divide-a-string-into-groups-of-size-k.java |  20 +
 .../README.md                                 |  44 +
 ...9-minimum-moves-to-reach-target-score.java |  16 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  52 ++
 ...strictly-smaller-and-greater-elements.java |  23 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  28 +
 ...2149-rearrange-array-elements-by-sign.java |  29 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  42 +
 .../215-kth-largest-element-in-an-array.java  |  10 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  20 +
 ...-find-all-lonely-numbers-in-the-array.java |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  37 +
 ...-keep-multiplying-found-values-by-two.java |  10 +
 .../README.md                                 |  40 +
 ...m-operations-to-make-a-uni-value-grid.java |  25 +
 .../README.md                                 |  45 +
 ...r-digit-number-after-splitting-digits.java |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  32 +
 ...tition-array-according-to-given-pivot.java |  25 +
 .../README.md                                 |  44 +
 ...rt-even-and-odd-indices-independently.java |  16 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  48 +
 ...allest-value-of-the-rearranged-number.java |  44 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +
 .../2166-design-bitset.java                   |  91 ++
 leetcode/leetcode/2166-design-bitset/NOTES.md |   1 +
 .../leetcode/2166-design-bitset/README.md     |  49 +
 ...t-greater-numerically-balanced-number.java |  21 +
 .../README.md                                 |  47 +
 ...e-integers-that-sum-to-a-given-number.java |  12 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  25 +
 ...80-count-integers-with-even-digit-sum.java |  11 +
 .../README.md                                 |  29 +
 .../2181-merge-nodes-in-between-zeros.java    |  27 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  38 +
 ...2183-count-array-pairs-divisible-by-k.java |  21 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  34 +
 ...uent-number-following-key-in-an-array.java |  20 +
 .../README.md                                 |  39 +
 ...215-find-the-difference-of-two-arrays.java |  29 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  35 +
 ...lete-the-middle-node-of-a-linked-list.java |  25 +
 .../README.md                                 |  47 +
 ...-possible-recipes-from-given-supplies.java |  98 ++
 .../README.md                                 |  51 ++
 ...0-minimum-bit-flips-to-convert-number.java |  11 +
 .../README.md                                 |  37 +
 ...-minimum-rounds-to-complete-all-tasks.java |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  32 +
 ...th-with-different-adjacent-characters.java |  34 +
 .../README.md                                 |  34 +
 .../225-implement-stack-using-queues.java     |  39 +
 .../225-implement-stack-using-queues/NOTES.md |   1 +
 .../README.md                                 |  48 +
 ...mum-swaps-to-group-all-1s-together-ii.java |  28 +
 .../README.md                                 |  48 +
 ...divide-a-string-into-groups-of-size-k.java |  20 +
 .../README.md                                 |  45 +
 ...largest-3-same-digit-number-in-string.java |  20 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  47 +
 ...tition-array-according-to-given-pivot.java |  25 +
 .../README.md                                 |  45 +
 .../228-summary-ranges.java                   |  27 +
 leetcode/leetcode/228-summary-ranges/NOTES.md |   1 +
 .../leetcode/228-summary-ranges/README.md     |  43 +
 .../23-merge-k-sorted-lists.java              |  46 +
 .../leetcode/23-merge-k-sorted-lists/NOTES.md |   1 +
 .../23-merge-k-sorted-lists/README.md         |  43 +
 .../230-kth-smallest-element-in-a-bst.java    |  33 +
 .../NOTES.md                                  |   1 +
 ...07-replace-non-coprime-numbers-in-array.py |  10 +
 .../README.md                                 |  53 ++
 .../2308-divide-array-into-equal-pairs.java   |  61 ++
 .../README.md                                 |  39 +
 .../232-implement-queue-using-stacks.java     |  39 +
 .../232-implement-queue-using-stacks/NOTES.md |   1 +
 .../README.md                                 |  48 +
 .../2324-find-triangular-sum-of-an-array.java |  11 +
 .../README.md                                 |  37 +
 .../234-palindrome-linked-list/README.md      |  25 +
 .../2352-equal-row-and-column-pairs.java      |  23 +
 .../2352-equal-row-and-column-pairs/NOTES.md  |   1 +
 ...west-common-ancestor-of-a-binary-tree.java |  20 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  36 +
 .../238-product-of-array-except-self.java     |  22 +
 .../238-product-of-array-except-self/NOTES.md |   1 +
 .../README.md                                 |  26 +
 .../2390-removing-stars-from-a-string.java    |  24 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  45 +
 ...ount-subarrays-with-score-less-than-k.java |  17 +
 .../README.md                                 |  45 +
 .../24-swap-nodes-in-pairs.java               |  21 +
 .../leetcode/24-swap-nodes-in-pairs/README.md |  29 +
 .../240-search-a-2d-matrix-ii.java            |  61 ++
 .../240-search-a-2d-matrix-ii/NOTES.md        |   1 +
 .../240-search-a-2d-matrix-ii/README.md       |  33 +
 .../2405-optimal-partition-of-string.java     |  14 +
 .../2405-optimal-partition-of-string/NOTES.md |   1 +
 .../README.md                                 |  32 +
 ...est-subarray-with-maximum-bitwise-and.java |  20 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  41 +
 .../2421-number-of-good-paths.java            |  85 ++
 .../2421-number-of-good-paths/README.md       |  55 ++
 .../2427-first-letter-to-appear-twice.java    |  37 +
 .../README.md                                 |  40 +
 .../2429-design-a-food-rating-system.java     |  61 ++
 .../README.md                                 |  63 ++
 .../2448-count-number-of-bad-pairs.java       |  14 +
 .../2448-count-number-of-bad-pairs/README.md  |  33 +
 ...f-time-for-binary-tree-to-be-infected.java |  67 ++
 .../README.md                                 |  43 +
 ...ors-to-get-k-consecutive-black-blocks.java |  27 +
 .../README.md                                 |  40 +
 ...ations-to-sort-a-binary-tree-by-level.java |  68 ++
 .../README.md                                 |  49 +
 .../2478-longest-nice-subarray.java           |  27 +
 .../2478-longest-nice-subarray/README.md      |  37 +
 ...ween-ones-and-zeros-in-row-and-column.java |  28 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  55 ++
 .../2487-remove-nodes-from-linked-list.java   |  51 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  32 +
 ...493-reverse-odd-levels-of-binary-tree.java |  51 ++
 .../README.md                                 |  51 ++
 .../2551-apply-operations-to-an-array.java    |  28 +
 .../README.md                                 |  48 +
 .../2564-most-profitable-path-in-a-tree.java  |  68 ++
 .../README.md                                 |  69 ++
 .../258-add-digits/258-add-digits.java        |  11 +
 leetcode/leetcode/258-add-digits/README.md    |  29 +
 .../2582-pass-the-pillow.java                 |   8 +
 .../leetcode/2582-pass-the-pillow/NOTES.md    |   1 +
 .../leetcode/2582-pass-the-pillow/README.md   |  32 +
 ...um-number-of-points-from-grid-queries.java | 126 +++
 .../README.md                                 |  41 +
 .../2610-closest-prime-numbers-in-range.java  |  40 +
 .../README.md                                 |  44 +
 ...positive-integer-and-negative-integer.java |  40 +
 .../README.md                                 |  44 +
 .../263-ugly-number/263-ugly-number.java      |   9 +
 leetcode/leetcode/263-ugly-number/NOTES.md    |   1 +
 leetcode/leetcode/263-ugly-number/README.md   |  33 +
 ...9-count-total-number-of-colored-cells.java |  19 +
 .../README.md                                 |  34 +
 .../2665-minimum-time-to-repair-cars.java     |  42 +
 .../README.md                                 |  42 +
 .../2681-put-marbles-in-bags.java             |  16 +
 .../2681-put-marbles-in-bags/README.md        |  42 +
 .../2690-house-robber-iv.java                 |  28 +
 .../leetcode/2690-house-robber-iv/README.md   |  40 +
 .../2707-extra-characters-in-a-string.java    |  29 +
 .../README.md                                 |  31 +
 ...merge-two-2d-arrays-by-summing-values.java |  43 +
 .../README.md                                 |  49 +
 .../2751-robot-collisions.java                |  55 ++
 .../leetcode/2751-robot-collisions/NOTES.md   |   1 +
 .../279-perfect-squares.java                  |  34 +
 .../leetcode/279-perfect-squares/NOTES.md     |   1 +
 ...unt-the-number-of-complete-components.java |  53 ++
 .../README.md                                 |  40 +
 ...eatest-common-divisors-in-linked-list.java |  35 +
 .../README.md                                 |  36 +
 .../284-peeking-iterator.java                 |  29 +
 .../leetcode/284-peeking-iterator/NOTES.md    |   1 +
 .../leetcode/284-peeking-iterator/README.md   |  43 +
 ...inimum-operations-to-collect-elements.java |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  38 +
 .../287-find-the-duplicate-number.java        |  10 +
 .../287-find-the-duplicate-number/NOTES.md    |   1 +
 .../287-find-the-duplicate-number/README.md   |  37 +
 .../2887-sort-vowels-in-a-string.py           |  15 +
 .../2887-sort-vowels-in-a-string/README.md    |  35 +
 .../2888-minimum-index-of-a-valid-split.java  |  41 +
 .../README.md                                 |  54 ++
 .../290-word-pattern/290-word-pattern.java    |  19 +
 leetcode/leetcode/290-word-pattern/NOTES.md   |   1 +
 leetcode/leetcode/290-word-pattern/README.md  |  35 +
 .../295-find-median-from-data-stream.java     |  37 +
 .../295-find-median-from-data-stream/NOTES.md |   1 +
 ...serialize-and-deserialize-binary-tree.java |  54 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  27 +
 .../300-longest-increasing-subsequence.java   |  17 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  35 +
 ...01-apply-operations-to-maximize-score.java | 133 +++
 .../README.md                                 |  49 +
 ...ximize-happiness-of-selected-children.java |  13 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  47 +
 .../316-remove-duplicate-letters.java         |  51 ++
 .../316-remove-duplicate-letters/NOTES.md     |   1 +
 .../316-remove-duplicate-letters/README.md    |  26 +
 ...ble-and-non-divisible-sums-difference.java |  13 +
 .../README.md                                 |  51 ++
 ...-distribute-candies-among-children-ii.java |  18 +
 .../README.md                                 |  28 +
 ...-max-element-appears-at-least-k-times.java |  19 +
 .../README.md                                 |  31 +
 ...3227-find-missing-and-repeated-values.java |  23 +
 .../README.md                                 |  31 +
 ...count-elements-with-maximum-frequency.java |  19 +
 .../README.md                                 |  32 +
 .../328-odd-even-linked-list.java             |  27 +
 .../328-odd-even-linked-list/NOTES.md         |   1 +
 .../33-search-in-rotated-sorted-array.java    |  43 +
 ...erations-to-exceed-threshold-value-ii.java |  16 +
 .../README.md                                 |  64 ++
 ...8-minimum-cost-walk-in-weighted-graph.java |  97 ++
 .../README.md                                 |  54 ++
 ...asing-or-strictly-decreasing-subarray.java |  29 +
 .../README.md                                 |  58 ++
 .../338-counting-bits/338-counting-bits.java  |  11 +
 leetcode/leetcode/338-counting-bits/NOTES.md  |   1 +
 leetcode/leetcode/338-counting-bits/README.md |  41 +
 ...398-make-a-square-with-the-same-color.java |  66 ++
 .../README.md                                 | 129 +++
 ...t-position-of-element-in-sorted-array.java |  39 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  27 +
 .../3430-count-days-without-meetings.java     |  18 +
 .../README.md                                 |  52 ++
 .../344-reverse-string.java                   |  13 +
 .../leetcode/344-reverse-string/README.md     |  20 +
 .../3447-clear-digits/3447-clear-digits.java  |  13 +
 leetcode/leetcode/3447-clear-digits/README.md |  45 +
 .../347-top-k-frequent-elements.java          |  27 +
 .../347-top-k-frequent-elements/NOTES.md      |   1 +
 .../347-top-k-frequent-elements/README.md     |  22 +
 ...-binary-array-elements-equal-to-one-i.java |  18 +
 .../README.md                                 |  48 +
 .../3483-alternating-groups-ii.java           |  35 +
 .../3483-alternating-groups-ii/README.md      |  66 ++
 .../350-intersection-of-two-arrays-ii.java    |  18 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  33 +
 ...des-from-linked-list-present-in-array.java |  30 +
 .../README.md                                 |  56 ++
 .../3541-report-spam-message.java             |  13 +
 .../3541-report-spam-message/README.md        |  39 +
 ...ining-every-vowel-and-k-consonants-ii.java |  57 ++
 .../README.md                                 |  55 ++
 .../36-valid-sudoku/36-valid-sudoku.java      |  14 +
 leetcode/leetcode/36-valid-sudoku/NOTES.md    |   1 +
 leetcode/leetcode/36-valid-sudoku/README.md   |  56 ++
 .../3643-zero-array-transformation-ii.java    |  31 +
 .../README.md                                 |  77 ++
 ...heck-if-grid-can-be-cut-into-sections.java |  34 +
 .../README.md                                 |  67 ++
 .../README.md                                 |  34 +
 .../371-sum-of-two-integers.java              |   7 +
 .../leetcode/371-sum-of-two-integers/NOTES.md |   1 +
 .../371-sum-of-two-integers/README.md         |  17 +
 .../380-insert-delete-getrandom-o1.java       |  47 +
 .../380-insert-delete-getrandom-o1/NOTES.md   |   1 +
 .../380-insert-delete-getrandom-o1/README.md  |  40 +
 .../382-linked-list-random-node.java          |  30 +
 .../382-linked-list-random-node/NOTES.md      |   1 +
 .../382-linked-list-random-node/README.md     |  45 +
 ...87-first-unique-character-in-a-string.java |  12 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  21 +
 .../389-find-the-difference.java              |  15 +
 .../leetcode/389-find-the-difference/NOTES.md |   1 +
 .../389-find-the-difference/README.md         |  29 +
 .../39-combination-sum.java                   |  36 +
 leetcode/leetcode/39-combination-sum/NOTES.md |   1 +
 .../leetcode/39-combination-sum/README.md     |  39 +
 .../392-is-subsequence.java                   |  18 +
 leetcode/leetcode/392-is-subsequence/NOTES.md |   1 +
 .../leetcode/392-is-subsequence/README.md     |  23 +
 .../397-integer-replacement.java              |   9 +
 .../leetcode/397-integer-replacement/NOTES.md |   1 +
 .../397-integer-replacement/README.md         |  38 +
 .../398-random-pick-index.java                |  21 +
 .../leetcode/398-random-pick-index/NOTES.md   |   1 +
 .../leetcode/398-random-pick-index/README.md  |  35 +
 .../leetcode/400-nth-digit/400-nth-digit.java |  23 +
 leetcode/leetcode/400-nth-digit/NOTES.md      |   1 +
 leetcode/leetcode/400-nth-digit/README.md     |  23 +
 .../413-arithmetic-slices.java                |  28 +
 .../leetcode/413-arithmetic-slices/NOTES.md   |   1 +
 .../leetcode/413-arithmetic-slices/README.md  |  32 +
 .../416-partition-equal-subset-sum.java       |  22 +
 .../416-partition-equal-subset-sum/NOTES.md   |   1 +
 .../416-partition-equal-subset-sum/README.md  |  25 +
 .../42-trapping-rain-water.java               |  20 +
 .../leetcode/42-trapping-rain-water/NOTES.md  |   1 +
 .../leetcode/42-trapping-rain-water/README.md |  25 +
 .../429-n-ary-tree-level-order-traversal.java |  43 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +
 .../438-find-all-anagrams-in-a-string.java    |  32 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  32 +
 .../449-serialize-and-deserialize-bst.java    |  57 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  23 +
 .../45-jump-game-ii/45-jump-game-ii.java      |  17 +
 leetcode/leetcode/45-jump-game-ii/NOTES.md    |   1 +
 leetcode/leetcode/45-jump-game-ii/README.md   |  30 +
 .../450-delete-node-in-a-bst.java             |  43 +
 .../450-delete-node-in-a-bst/NOTES.md         |   1 +
 .../450-delete-node-in-a-bst/README.md        |  47 +
 .../451-sort-characters-by-frequency.java     |  22 +
 .../451-sort-characters-by-frequency/NOTES.md |   1 +
 ...um-number-of-arrows-to-burst-balloons.java |  14 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  41 +
 .../46-permutations/46-permutations.java      |  26 +
 leetcode/leetcode/46-permutations/NOTES.md    |   1 +
 leetcode/leetcode/46-permutations/README.md   |  22 +
 ...imum-moves-to-equal-array-elements-ii.java |  13 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  31 +
 .../470-implement-rand10-using-rand7.java     |  10 +
 .../470-implement-rand10-using-rand7/NOTES.md |   1 +
 .../README.md                                 |  30 +
 .../48-rotate-image/48-rotate-image.java      |  31 +
 leetcode/leetcode/48-rotate-image/NOTES.md    |   1 +
 leetcode/leetcode/48-rotate-image/README.md   |  26 +
 .../494-target-sum/494-target-sum.java        |  13 +
 leetcode/leetcode/494-target-sum/NOTES.md     |   1 +
 leetcode/leetcode/494-target-sum/README.md    |  39 +
 .../496-next-greater-element-i.java           |  16 +
 .../496-next-greater-element-i/NOTES.md       |   1 +
 .../496-next-greater-element-i/README.md      |  40 +
 .../509-fibonacci-number.java                 |  16 +
 .../leetcode/509-fibonacci-number/NOTES.md    |   1 +
 .../leetcode/509-fibonacci-number/README.md   |  37 +
 .../511-game-play-analysis-i.sql              |   2 +
 .../511-game-play-analysis-i/NOTES.md         |   1 +
 .../511-game-play-analysis-i/README.md        |  47 +
 ...5-find-largest-value-in-each-tree-row.java |  34 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  23 +
 .../520-detect-capital.java                   |  24 +
 leetcode/leetcode/520-detect-capital/NOTES.md |   1 +
 .../525-contiguous-array.java                 |  22 +
 .../leetcode/525-contiguous-array/NOTES.md    |   1 +
 .../leetcode/525-contiguous-array/README.md   |  25 +
 .../532-k-diff-pairs-in-an-array.java         |  28 +
 .../532-k-diff-pairs-in-an-array/NOTES.md     |   1 +
 .../532-k-diff-pairs-in-an-array/README.md    |  44 +
 .../538-convert-bst-to-greater-tree.java      |  25 +
 .../538-convert-bst-to-greater-tree/NOTES.md  |   1 +
 .../538-convert-bst-to-greater-tree/README.md |  36 +
 .../54-spiral-matrix/54-spiral-matrix.java    |  27 +
 leetcode/leetcode/54-spiral-matrix/NOTES.md   |   1 +
 leetcode/leetcode/54-spiral-matrix/README.md  |  25 +
 .../540-single-element-in-a-sorted-array.java |  29 +
 .../NOTES.md                                  |   1 +
 .../leetcode/55-jump-game/55-jump-game.java   |  16 +
 leetcode/leetcode/55-jump-game/NOTES.md       |   1 +
 leetcode/leetcode/55-jump-game/README.md      |  27 +
 .../560-subarray-sum-equals-k.java            |  14 +
 .../560-subarray-sum-equals-k/NOTES.md        |   1 +
 .../560-subarray-sum-equals-k/README.md       |  19 +
 .../567-permutation-in-string.java            |  30 +
 .../567-permutation-in-string/NOTES.md        |   1 +
 .../567-permutation-in-string/README.md       |  26 +
 .../575-distribute-candies.java               |   9 +
 .../leetcode/575-distribute-candies/NOTES.md  |   1 +
 .../leetcode/575-distribute-candies/README.md |  38 +
 .../59-spiral-matrix-ii.java                  |  33 +
 .../leetcode/59-spiral-matrix-ii/NOTES.md     |   1 +
 .../leetcode/59-spiral-matrix-ii/README.md    |  22 +
 .../595-big-countries/595-big-countries.sql   |   2 +
 leetcode/leetcode/595-big-countries/NOTES.md  |   1 +
 leetcode/leetcode/595-big-countries/README.md |  53 ++
 .../596-classes-more-than-5-students.sql      |   2 +
 .../596-classes-more-than-5-students/NOTES.md |   1 +
 .../README.md                                 |  51 ++
 .../605-can-place-flowers.java                |  26 +
 .../leetcode/605-can-place-flowers/NOTES.md   |   1 +
 .../leetcode/605-can-place-flowers/README.md  |  22 +
 ...606-construct-string-from-binary-tree.java |  42 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  27 +
 .../61-rotate-list/61-rotate-list.java        |  39 +
 leetcode/leetcode/61-rotate-list/NOTES.md     |   1 +
 .../62-unique-paths/62-unique-paths.java      |  27 +
 leetcode/leetcode/62-unique-paths/NOTES.md    |   1 +
 leetcode/leetcode/62-unique-paths/README.md   |  30 +
 .../623-add-one-row-to-tree.java              |  38 +
 .../leetcode/623-add-one-row-to-tree/NOTES.md |   1 +
 .../623-add-one-row-to-tree/README.md         |  37 +
 .../63-unique-paths-ii.java                   |  33 +
 leetcode/leetcode/63-unique-paths-ii/NOTES.md |   1 +
 .../leetcode/63-unique-paths-ii/README.md     |  35 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  24 +
 .../64-minimum-path-sum.java                  |  30 +
 .../leetcode/64-minimum-path-sum/NOTES.md     |   1 +
 .../leetcode/64-minimum-path-sum/README.md    |  28 +
 .../645-set-mismatch/645-set-mismatch.java    |  22 +
 leetcode/leetcode/645-set-mismatch/README.md  |  22 +
 .../662-maximum-width-of-binary-tree.java     |  49 +
 .../662-maximum-width-of-binary-tree/NOTES.md |   1 +
 .../README.md                                 |  38 +
 .../669-trim-a-binary-search-tree.java        |  27 +
 .../669-trim-a-binary-search-tree/NOTES.md    |   1 +
 .../669-trim-a-binary-search-tree/README.md   |  28 +
 .../leetcode/67-add-binary/67-add-binary.java |  17 +
 leetcode/leetcode/67-add-binary/README.md     |  19 +
 ...-second-minimum-node-in-a-binary-tree.java |  33 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  32 +
 .../695-max-area-of-island.java               |  17 +
 .../leetcode/695-max-area-of-island/NOTES.md  |   1 +
 .../leetcode/695-max-area-of-island/README.md |  30 +
 .../70-climbing-stairs.java                   |  15 +
 .../leetcode/70-climbing-stairs/README.md     |  31 +
 .../700-search-in-a-binary-search-tree.java   |  23 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  27 +
 .../701-insert-into-a-binary-search-tree.java |  26 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  36 +
 .../704-binary-search/704-binary-search.java  |  17 +
 leetcode/leetcode/704-binary-search/NOTES.md  |   1 +
 leetcode/leetcode/704-binary-search/README.md |  29 +
 .../709-to-lower-case/709-to-lower-case.java  |   5 +
 leetcode/leetcode/709-to-lower-case/NOTES.md  |   1 +
 leetcode/leetcode/709-to-lower-case/README.md |  29 +
 .../72-edit-distance/72-edit-distance.java    |  30 +
 leetcode/leetcode/72-edit-distance/NOTES.md   |   1 +
 leetcode/leetcode/72-edit-distance/README.md  |  41 +
 .../73-set-matrix-zeroes.java                 |  53 ++
 .../leetcode/73-set-matrix-zeroes/NOTES.md    |   1 +
 .../leetcode/73-set-matrix-zeroes/README.md   |  36 +
 .../735-asteroid-collision.java               |  39 +
 .../leetcode/735-asteroid-collision/NOTES.md  |   1 +
 .../739-daily-temperatures.java               |  22 +
 .../leetcode/739-daily-temperatures/NOTES.md  |   1 +
 .../leetcode/739-daily-temperatures/README.md |  21 +
 .../74-search-a-2d-matrix.java                |  20 +
 .../leetcode/74-search-a-2d-matrix/NOTES.md   |   1 +
 .../leetcode/74-search-a-2d-matrix/README.md  |  30 +
 .../740-delete-and-earn.java                  |  17 +
 .../leetcode/740-delete-and-earn/README.md    |  37 +
 .../746-min-cost-climbing-stairs.java         |  19 +
 .../746-min-cost-climbing-stairs/NOTES.md     |   1 +
 .../746-min-cost-climbing-stairs/README.md    |  38 +
 ...rgest-number-at-least-twice-of-others.java |  16 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  36 +
 .../75-sort-colors/75-sort-colors.java        |  24 +
 leetcode/leetcode/75-sort-colors/NOTES.md     |   1 +
 leetcode/leetcode/75-sort-colors/README.md    |  31 +
 leetcode/leetcode/78-subsets/78-subsets.java  |  26 +
 leetcode/leetcode/78-subsets/NOTES.md         |   1 +
 leetcode/leetcode/78-subsets/README.md        |  26 +
 .../79-word-search/79-word-search.java        |  26 +
 leetcode/leetcode/79-word-search/NOTES.md     |   1 +
 leetcode/leetcode/79-word-search/README.md    |  37 +
 .../799-champagne-tower.java                  |  17 +
 .../leetcode/799-champagne-tower/NOTES.md     |   1 +
 .../leetcode/799-champagne-tower/README.md    |  38 +
 .../8-string-to-integer-atoi.java             |  29 +
 .../8-string-to-integer-atoi/NOTES.md         |   1 +
 .../8-string-to-integer-atoi/README.md        |  74 ++
 ...807-max-increase-to-keep-city-skyline.java |  20 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  39 +
 .../814-binary-tree-pruning.c                 |  18 +
 .../814-binary-tree-pruning.java              |  26 +
 .../leetcode/814-binary-tree-pruning/NOTES.md |   1 +
 .../814-binary-tree-pruning/README.md         |  34 +
 ...remove-duplicates-from-sorted-list-ii.java |  31 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  24 +
 .../846-hand-of-straights.java                |  34 +
 .../leetcode/846-hand-of-straights/NOTES.md   |   1 +
 .../leetcode/846-hand-of-straights/README.md  |  32 +
 ...9-maximize-distance-to-closest-person.java |  23 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  44 +
 .../852-peak-index-in-a-mountain-array.java   |  15 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  44 +
 .../867-transpose-matrix.java                 |  13 +
 .../leetcode/867-transpose-matrix/NOTES.md    |   1 +
 .../leetcode/867-transpose-matrix/README.md   |  30 +
 .../875-koko-eating-bananas.java              |  25 +
 .../leetcode/875-koko-eating-bananas/NOTES.md |   1 +
 .../875-koko-eating-bananas/README.md         |  36 +
 .../88-merge-sorted-array.java                |  17 +
 .../leetcode/88-merge-sorted-array/NOTES.md   |   1 +
 .../leetcode/88-merge-sorted-array/README.md  |  46 +
 ...from-preorder-and-postorder-traversal.java |  34 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +
 .../890-find-and-replace-pattern.java         |  21 +
 .../890-find-and-replace-pattern/NOTES.md     |   1 +
 .../890-find-and-replace-pattern/README.md    |  31 +
 .../9-palindrome-number.cpp                   |  12 +
 .../9-palindrome-number.java                  |  11 +
 .../leetcode/9-palindrome-number/NOTES.md     |   1 +
 .../leetcode/9-palindrome-number/README.md    |  39 +
 .../931-minimum-falling-path-sum.java         |  28 +
 .../94-binary-tree-inorder-traversal.java     |  27 +
 .../94-binary-tree-inorder-traversal/NOTES.md |   1 +
 .../README.md                                 |  31 +
 .../941-valid-mountain-array.java             |  18 +
 .../941-valid-mountain-array/NOTES.md         |   1 +
 .../941-valid-mountain-array/README.md        |  33 +
 .../946-validate-stack-sequences.java         |  26 +
 .../946-validate-stack-sequences/NOTES.md     |   1 +
 .../946-validate-stack-sequences/README.md    |  32 +
 .../96-unique-binary-search-trees.java        |  15 +
 .../96-unique-binary-search-trees/NOTES.md    |   1 +
 .../96-unique-binary-search-trees/README.md   |  22 +
 .../969-pancake-sorting.java                  |  33 +
 .../leetcode/969-pancake-sorting/NOTES.md     |   1 +
 .../leetcode/969-pancake-sorting/README.md    |  44 +
 .../973-k-closest-points-to-origin.java       |  30 +
 .../973-k-closest-points-to-origin/NOTES.md   |   1 +
 .../973-k-closest-points-to-origin/README.md  |  33 +
 .../991-broken-calculator.java                |  14 +
 .../leetcode/991-broken-calculator/NOTES.md   |   1 +
 .../leetcode/991-broken-calculator/README.md  |  38 +
 .../leetcode/Binary Search - GFG/README.md    |  42 +
 .../Binary Search - GFG/binary-search.java    |  42 +
 .../README.md                                 |  68 ++
 .../bottom-view-of-binary-tree.java           | 150 ++++
 .../README.md                                 |  58 ++
 .../buildings-receiving-sunlight.java         |  53 ++
 .../leetcode/Check for BST - GFG/README.md    |  68 ++
 .../Check for BST - GFG/check-for-bst.java    | 143 +++
 .../README.md                                 |  36 +
 .../check-if-linked-list-is-palindrome.java   | 136 +++
 .../README.md                                 |  60 ++
 .../connect-nodes-at-same-level.java          | 173 ++++
 .../README.md                                 |  40 +
 ...unt-distinct-elements-in-every-window.java |  53 ++
 .../README.md                                 |  47 +
 .../count-pairs-in-array-divisible-by-k.java  |  47 +
 .../README.md                                 |  42 +
 .../detect-loop-in-linked-list.java           |  92 ++
 .../Diameter of a Binary Tree - GFG/README.md |  40 +
 .../diameter-of-a-binary-tree.java            | 143 +++
 .../Find Transition Point - GFG/README.md     |  39 +
 .../find-transition-point.java                |  39 +
 .../README.md                                 |  38 +
 .../find-duplicates-in-an-array.java          |  41 +
 .../README.md                                 |  37 +
 ...nding-middle-element-in-a-linked-list.java |  68 ++
 .../GCD of two numbers - GFG/README.md        |  32 +
 .../gcd-of-two-numbers.java                   |  32 +
 .../README.md                                 |  37 +
 .../get-minimum-element-from-stack.java       |  88 ++
 .../README.md                                 |  37 +
 ...-linked-list-of-0s-1s-and-2s-sort-it..java | 106 +++
 .../Height of Binary Tree - GFG/README.md     |  39 +
 .../height-of-binary-tree.java                | 128 +++
 .../Inorder Successor in BST - GFG/README.md  |  50 ++
 .../inorder-successor-in-bst.java             | 148 ++++
 .../README.md                                 |  57 ++
 ...ction-point-in-y-shapped-linked-lists.java | 163 ++++
 .../Kadane's Algorithm - GFG/README.md        |  44 +
 .../kadanes-algorithm.java                    |  50 ++
 .../README.md                                 |  51 ++
 .../largest-value-in-each-level.java          | 137 +++
 .../Left View of Binary Tree - GFG/README.md  |  42 +
 .../left-view-of-binary-tree.java             | 141 +++
 .../README.md                                 |  40 +
 .../level-order-traversal-in-spiral-form.java | 163 ++++
 .../README.md                                 |  40 +
 ...west-common-ancestor-in-a-binary-tree.java | 135 +++
 .../README.md                                 |  51 ++
 .../max-sum-subarray-of-size-k.java           |  53 ++
 .../Maximum no of 1's row - GFG/README.md     |  43 +
 .../maximum-no-of-1s-row.java                 |  59 ++
 .../Minimum Operations - GFG/README.md        |  43 +
 .../minimum-operations.java                   |  40 +
 .../Missing number in array - GFG/README.md   |  34 +
 .../missing-number-in-array.java              |  35 +
 .../README.md                                 |  41 +
 .../move-all-zeroes-to-end-of-array.java      |  49 +
 .../leetcode/Peak element - GFG/README.md     |  48 +
 .../Peak element - GFG/peak-element.java      |  63 ++
 leetcode/leetcode/README.md                   | 836 ++++++++++++++++++
 .../Rearrange a linked list - GFG/README.md   |  40 +
 .../rearrange-a-linked-list.java              |  81 ++
 .../README.md                                 |  67 ++
 .../remove-loop-in-linked-list.java           | 131 +++
 .../leetcode/Rotate Array - GFG/README.md     |  43 +
 .../Rotate Array - GFG/rotate-array.c         |  58 ++
 .../Rotate a Linked List - GFG/README.md      |  39 +
 .../rotate-a-linked-list.java                 |  92 ++
 .../subset-sum-problem.java                   |  55 ++
 leetcode/leetcode/Sum Tree - GFG/README.md    |  55 ++
 .../leetcode/Sum Tree - GFG/sum-tree.java     | 146 +++
 .../Top View of Binary Tree - GFG/README.md   |  48 +
 .../top-view-of-binary-tree.java              | 163 ++++
 .../README.md                                 |  33 +
 .../trailing-zeroes-in-factorial.java         |  38 +
 .../Transform to Sum Tree - GFG/README.md     |  45 +
 .../README.md                                 |  43 +
 .../vertical-traversal-of-binary-tree.java    | 147 +++
 .../README.md                                 |  38 +
 .../a-number-after-a-double-reversal.java     |   7 +
 leetcode/leetcode/add-digits/README.md        |  29 +
 leetcode/leetcode/add-digits/add-digits.java  |   6 +
 .../leetcode/add-two-numbers-ii/README.md     |  35 +
 .../add-two-numbers-ii.java                   |  63 ++
 leetcode/leetcode/add-two-numbers/README.md   |  33 +
 .../add-two-numbers/add-two-numbers.java      |  42 +
 .../adding-spaces-to-a-string/README.md       |  46 +
 .../adding-spaces-to-a-string.java            |  17 +
 .../apply-discount-every-n-orders/README.md   |  58 ++
 .../apply-discount-every-n-orders.java        |  35 +
 leetcode/leetcode/arranging-coins/README.md   |  26 +
 .../arranging-coins/arranging-coins.java      |   5 +
 leetcode/leetcode/array-partition-i/README.md |  29 +
 .../array-partition-i/array-partition-i.java  |  10 +
 .../README.md                                 |  24 +
 .../average-of-levels-in-binary-tree.java     |  48 +
 .../leetcode/balanced-binary-tree/README.md   |  35 +
 .../balanced-binary-tree.java                 |  25 +
 leetcode/leetcode/binary-search/README.md     |  29 +
 .../leetcode/binary-search/binary-search.java |  19 +
 .../binary-tree-inorder-traversal/README.md   |  43 +
 .../binary-tree-inorder-traversal.java        |  27 +
 .../binary-tree-postorder-traversal/README.md |  43 +
 .../binary-tree-postorder-traversal.java      |  28 +
 .../binary-tree-preorder-traversal/README.md  |  44 +
 .../binary-tree-preorder-traversal.java       |  27 +
 leetcode/leetcode/binary-tree-tilt/README.md  |  44 +
 .../binary-tree-tilt/binary-tree-tilt.java    |  31 +
 .../bitwise-and-of-numbers-range/README.md    |  30 +
 .../bitwise-and-of-numbers-range.cpp          |  12 +
 .../bitwise-and-of-numbers-range.java         |  16 +
 .../build-array-from-permutation/README.md    |  35 +
 .../build-array-from-permutation.java         |  11 +
 .../README.md                                 |  35 +
 .../calculate-money-in-leetcode-bank.java     |  14 +
 .../README.md                                 |  50 ++
 ...as-a-prefix-of-any-word-in-a-sentence.java |  13 +
 .../README.md                                 |  37 +
 ...check-if-all-as-appears-before-all-bs.java |   9 +
 .../README.md                                 |  41 +
 ...ne-string-swap-can-make-strings-equal.java |  32 +
 .../README.md                                 |  26 +
 .../check-if-the-sentence-is-pangram.java     |  13 +
 .../README.md                                 |  36 +
 ...k-if-two-string-arrays-are-equivalent.java |   5 +
 leetcode/leetcode/climbing-stairs/README.md   |  31 +
 .../climbing-stairs/climbing-stairs.cpp       |  17 +
 .../climbing-stairs/climbing-stairs.java      |  16 +
 .../complement-of-base-10-integer/README.md   |  40 +
 .../complement-of-base-10-integer.java        |  13 +
 .../complex-number-multiplication/README.md   |  32 +
 .../complex-number-multiplication.java        |   9 +
 .../leetcode/concatenation-of-array/README.md |  33 +
 .../concatenation-of-array.java               |  18 +
 .../leetcode/consecutive-characters/README.md |  45 +
 .../consecutive-characters.java               |  16 +
 .../leetcode/contains-duplicate/README.md     |  21 +
 .../contains-duplicate.java                   |  10 +
 .../convert-1d-array-into-2d-array/README.md  |  53 ++
 .../convert-1d-array-into-2d-array.java       |  10 +
 .../README.md                                 |  44 +
 ...ry-number-in-a-linked-list-to-integer.java |  28 +
 .../README.md                                 |  29 +
 ...rt-sorted-array-to-binary-search-tree.java |  28 +
 .../README.md                                 |  26 +
 ...ert-sorted-list-to-binary-search-tree.java |  46 +
 .../count-complete-tree-nodes/README.md       |  34 +
 .../count-complete-tree-nodes.java            |  44 +
 .../count-items-matching-a-rule/README.md     |  36 +
 .../count-items-matching-a-rule.java          |  12 +
 .../README.md                                 |  40 +
 ...t-negative-numbers-in-a-sorted-matrix.java |  13 +
 .../README.md                                 |  47 +
 ...r-of-pairs-with-absolute-difference-k.java |   9 +
 .../README.md                                 |  21 +
 ...ount-odd-numbers-in-an-interval-range.java |  10 +
 leetcode/leetcode/count-primes/README.md      |  29 +
 .../leetcode/count-primes/count-primes.java   |  19 +
 .../README.md                                 |  55 ++
 ...reate-target-array-in-the-given-order.java |  17 +
 .../README.md                                 |  53 ++
 .../delete-leaves-with-a-given-value.java     |  24 +
 .../delete-node-in-a-linked-list/README.md    |  47 +
 .../delete-node-in-a-linked-list.java         |  14 +
 .../README.md                                 |  45 +
 ...lete-the-middle-node-of-a-linked-list.java |  25 +
 .../README.md                                 |  46 +
 ...sign-a-stack-with-increment-operation.java |  41 +
 .../leetcode/design-browser-history/README.md |  45 +
 .../design-browser-history.java               |  44 +
 .../leetcode/design-circular-queue/README.md  |  50 ++
 .../design-circular-queue.java                |  66 ++
 .../leetcode/design-linked-list/README.md     |  43 +
 .../design-linked-list.java                   | 105 +++
 .../leetcode/destroying-asteroids/README.md   |  38 +
 .../destroying-asteroids.java                 |  11 +
 leetcode/leetcode/detect-capital/README.md    |  26 +
 .../detect-capital/detect-capital.java        |  25 +
 .../diameter-of-binary-tree/README.md         |  28 +
 .../diameter-of-binary-tree.java              |  35 +
 .../encode-and-decode-tinyurl/README.md       |  35 +
 .../encode-and-decode-tinyurl.java            |  31 +
 leetcode/leetcode/fibonacci-number/README.md  |  37 +
 .../fibonacci-number/fibonacci-number.java    |  16 +
 .../README.md                                 |  54 ++
 ...-variable-after-performing-operations.java |   9 +
 .../find-all-duplicates-in-an-array/README.md |  25 +
 .../find-all-duplicates-in-an-array.java      |  21 +
 .../README.md                                 |  28 +
 ...t-position-of-element-in-sorted-array.java |  36 +
 .../README.md                                 |  37 +
 ...first-palindromic-string-in-the-array.java |  18 +
 .../README.md                                 |  46 +
 .../find-minimum-in-rotated-sorted-array.java |  21 +
 leetcode/leetcode/find-pivot-index/README.md  |  47 +
 .../find-pivot-index/find-pivot-index.java    |  16 +
 .../find-the-duplicate-number/README.md       |  38 +
 .../find-the-duplicate-number.java            |  11 +
 .../README.md                                 |  47 +
 ...e-student-that-will-replace-the-chalk.java |  14 +
 .../leetcode/find-the-town-judge/README.md    |  45 +
 .../find-the-town-judge.java                  |  13 +
 .../README.md                                 |  49 +
 .../finding-pairs-with-a-certain-sum.java     |  33 +
 leetcode/leetcode/first-bad-version/README.md |  31 +
 .../first-bad-version/first-bad-version.java  |  14 +
 .../leetcode/first-missing-positive/README.md |  23 +
 .../first-missing-positive.java               |  19 +
 .../README.md                                 |  21 +
 .../first-unique-character-in-a-string.java   |  14 +
 .../README.md                                 |  72 ++
 ...atten-a-multilevel-doubly-linked-list.java |  32 +
 .../README.md                                 |  37 +
 .../flatten-binary-tree-to-linked-list.java   |  37 +
 .../guess-number-higher-or-lower/README.md    |  38 +
 .../guess-number-higher-or-lower.java         |  25 +
 leetcode/leetcode/implement-strstr/README.md  |  29 +
 .../implement-strstr/implement-strstr.java    |  11 +
 .../README.md                                 |  36 +
 .../insert-into-a-binary-search-tree.java     |  29 +
 .../intersection-of-two-arrays/README.md      |  24 +
 .../intersection-of-two-arrays.java           |  18 +
 .../leetcode/invert-binary-tree/README.md     |  29 +
 .../invert-binary-tree.java                   |  28 +
 .../kth-largest-element-in-an-array/README.md |  20 +
 .../kth-largest-element-in-an-array.java      |  13 +
 .../largest-perimeter-triangle/README.md      |  24 +
 .../largest-perimeter-triangle.java           |   9 +
 .../leetcode/length-of-last-word/README.md    |  35 +
 .../length-of-last-word.java                  |  19 +
 leetcode/leetcode/linked-list-cycle/README.md |  40 +
 .../linked-list-cycle/linked-list-cycle.java  |  23 +
 .../linked-list-random-node/README.md         |  45 +
 .../linked-list-random-node.java              |  39 +
 .../longest-increasing-subsequence/README.md  |  35 +
 .../longest-increasing-subsequence.java       |  15 +
 .../README.md                                 |  33 +
 ...ubstring-without-repeating-characters.java |  22 +
 leetcode/leetcode/majority-element/README.md  |  23 +
 .../majority-element/majority-element.java    |  15 +
 .../README.md                                 |  40 +
 ...-arrays-equal-by-reversing-sub-arrays.java |  11 +
 .../leetcode/matrix-diagonal-sum/README.md    |  39 +
 .../matrix-diagonal-sum.java                  |  14 +
 .../leetcode/max-consecutive-ones/README.md   |  24 +
 .../max-consecutive-ones.java                 |  15 +
 .../leetcode/maximum-binary-tree/README.md    |  42 +
 .../maximum-binary-tree.java                  |  36 +
 .../maximum-depth-of-binary-tree/README.md    |  37 +
 .../maximum-depth-of-binary-tree.java         |  21 +
 .../maximum-depth-of-n-ary-tree/README.md     |  31 +
 .../maximum-depth-of-n-ary-tree.java          |  35 +
 .../leetcode/maximum-ice-cream-bars/README.md |  39 +
 .../maximum-ice-cream-bars.java               |  25 +
 .../README.md                                 |  46 +
 .../maximum-number-of-coins-you-can-get.java  |  16 +
 .../README.md                                 |  34 +
 ...-product-difference-between-two-pairs.java |  47 +
 .../README.md                                 |  21 +
 .../maximum-product-of-three-numbers.java     |  11 +
 .../README.md                                 |  30 +
 ...m-product-of-two-elements-in-an-array.java |  15 +
 .../maximum-product-subarray/README.md        |  30 +
 .../maximum-product-subarray.java             |  18 +
 leetcode/leetcode/maximum-subarray/README.md  |  35 +
 .../maximum-subarray/maximum-subarray.java    |  12 +
 .../median-of-two-sorted-arrays/README.md     |  49 +
 .../median-of-two-sorted-arrays.java          |  33 +
 .../merge-in-between-linked-lists/README.md   |  32 +
 .../merge-in-between-linked-lists.java        |  32 +
 .../leetcode/merge-two-sorted-lists/README.md |  30 +
 .../merge-two-sorted-lists.java               |  36 +
 .../middle-of-the-linked-list/README.md       |  27 +
 .../middle-of-the-linked-list.java            |  21 +
 .../README.md                                 |  41 +
 .../minimize-maximum-pair-sum-in-array.java   |  18 +
 .../minimum-absolute-difference/README.md     |  37 +
 .../minimum-absolute-difference.java          |  18 +
 .../README.md                                 |  31 +
 ...imum-moves-to-equal-array-elements-ii.java |  14 +
 .../README.md                                 |  33 +
 ...rations-to-move-all-balls-to-each-box.java |  26 +
 .../README.md                                 |  49 +
 ...-of-steps-to-make-two-strings-anagram.java |  21 +
 .../README.md                                 |  29 +
 ...inimum-operations-to-make-array-equal.java |  17 +
 leetcode/leetcode/missing-number/README.md    |  43 +
 .../missing-number/missing-number.java        |  10 +
 leetcode/leetcode/move-zeroes/README.md       |  23 +
 .../leetcode/move-zeroes/move-zeroes.java     |  14 +
 .../n-ary-tree-postorder-traversal/README.md  |  29 +
 .../n-ary-tree-postorder-traversal.java       |  32 +
 .../n-ary-tree-preorder-traversal/README.md   |  33 +
 .../n-ary-tree-preorder-traversal.java        |  32 +
 .../README.md                                 |  31 +
 .../n-repeated-element-in-size-2n-array.java  |  11 +
 leetcode/leetcode/number-complement/README.md |  33 +
 .../number-complement/number-complement.java  |  13 +
 .../number-of-laser-beams-in-a-bank/README.md |  48 +
 .../number-of-laser-beams-in-a-bank.java      |  20 +
 .../number-of-segments-in-a-string/README.md  |  39 +
 .../number-of-segments-in-a-string.java       |  14 +
 .../README.md                                 |  42 +
 ...r-of-steps-to-reduce-a-number-to-zero.java |  14 +
 .../leetcode/odd-even-linked-list/README.md   |  30 +
 .../odd-even-linked-list.java                 |  35 +
 .../leetcode/palindrome-linked-list/README.md |  25 +
 .../palindrome-linked-list.java               |  47 +
 leetcode/leetcode/palindrome-number/README.md |  40 +
 .../palindrome-number/palindrome-number.java  |  14 +
 leetcode/leetcode/partition-list/README.md    |  26 +
 .../partition-list/partition-list.java        |  33 +
 .../README.md                                 |  33 +
 ...minimum-number-of-deci-binary-numbers.java |  14 +
 .../leetcode/pascals-triangle-ii/README.md    |  25 +
 .../pascals-triangle-ii.java                  |  22 +
 leetcode/leetcode/pascals-triangle/README.md  |  19 +
 .../pascals-triangle/pascals-triangle.java    |  23 +
 leetcode/leetcode/path-sum/README.md          |  38 +
 leetcode/leetcode/plus-one/README.md          |  50 ++
 leetcode/leetcode/plus-one/plus-one.java      |  26 +
 leetcode/leetcode/power-of-two/README.md      |  46 +
 .../leetcode/power-of-two/power-of-two.java   |  12 +
 .../leetcode/power-of-two/power-of-two.py     |   7 +
 leetcode/leetcode/range-sum-of-bst/README.md  |  27 +
 .../range-sum-of-bst/range-sum-of-bst.java    |  29 +
 .../reduce-array-size-to-the-half/README.md   |  30 +
 .../reduce-array-size-to-the-half.java        |  20 +
 .../README.md                                 |  30 +
 ...ove-all-adjacent-duplicates-in-string.java |  17 +
 .../README.md                                 |  43 +
 ...remove-all-occurrences-of-a-substring.java |   9 +
 .../README.md                                 |  51 ++
 .../remove-duplicates-from-sorted-array.java  |  21 +
 .../README.md                                 |  24 +
 ...remove-duplicates-from-sorted-list-ii.java |  31 +
 leetcode/leetcode/remove-element/README.md    |  55 ++
 .../remove-element/remove-element.java        |  16 +
 .../remove-linked-list-elements/README.md     |  30 +
 .../remove-linked-list-elements.java          |  25 +
 .../README.md                                 |  34 +
 .../remove-nth-node-from-end-of-list.java     |  29 +
 leetcode/leetcode/reorder-list/README.md      |  33 +
 .../leetcode/reorder-list/reorder-list.java   |  51 ++
 .../leetcode/reordered-power-of-2/README.md   |  42 +
 .../reordered-power-of-2.java                 |  21 +
 leetcode/leetcode/reverse-integer/README.md   |  25 +
 .../reverse-integer/reverse-integer.java      |  11 +
 .../leetcode/reverse-linked-list-ii/README.md |  28 +
 .../reverse-linked-list-ii.java               |  55 ++
 .../leetcode/reverse-linked-list/README.md    |  32 +
 .../reverse-linked-list.java                  |  26 +
 .../reverse-nodes-in-k-group/README.md        |  31 +
 .../reverse-nodes-in-k-group.java             |  43 +
 leetcode/leetcode/reverse-string/README.md    |  20 +
 .../reverse-string/reverse-string.java        |  13 +
 .../reverse-words-in-a-string/README.md       |  54 ++
 .../reverse-words-in-a-string.java            |  22 +
 leetcode/leetcode/rotate-array/README.md      |  39 +
 .../leetcode/rotate-array/rotate-array.java   |  21 +
 leetcode/leetcode/rotate-list/README.md       |  24 +
 .../leetcode/rotate-list/rotate-list.java     |  39 +
 .../running-sum-of-1d-array/README.md         |  30 +
 .../running-sum-of-1d-array.java              |  10 +
 leetcode/leetcode/same-tree/README.md         |  31 +
 leetcode/leetcode/same-tree/same-tree.java    |  25 +
 .../leetcode/search-insert-position/README.md |  33 +
 .../search-insert-position.java               |  13 +
 .../README.md                                 |  28 +
 .../second-largest-digit-in-a-string.java     |  22 +
 leetcode/leetcode/shuffle-an-array/README.md  |  39 +
 .../shuffle-an-array/shuffle-an-array.java    |  33 +
 .../sign-of-the-product-of-an-array/README.md |  42 +
 .../sign-of-the-product-of-an-array.java      |  10 +
 .../leetcode/simple-bank-system/README.md     |  50 ++
 .../simple-bank-system.java                   |  43 +
 .../README.md                                 |  20 +
 .../single-element-in-a-sorted-array.java     |  16 +
 leetcode/leetcode/single-number-ii/README.md  |  21 +
 .../single-number-ii/single-number-ii.java    |  19 +
 leetcode/leetcode/single-number/README.md     |  24 +
 .../leetcode/single-number/single-number.java |   9 +
 leetcode/leetcode/sort-an-array/README.md     |  18 +
 .../leetcode/sort-an-array/sort-an-array.java |  54 ++
 .../sort-array-by-parity.java                 |  27 +
 leetcode/leetcode/sort-colors/README.md       |  33 +
 .../leetcode/sort-colors/sort-colors.java     |  45 +
 leetcode/leetcode/sort-list/README.md         |  33 +
 leetcode/leetcode/sort-list/sort-list.java    |  56 ++
 .../leetcode/subdomain-visit-count/README.md  |  38 +
 .../subdomain-visit-count.java                |  21 +
 .../README.md                                 |  51 ++
 ...sum-of-digits-of-string-after-convert.java |  35 +
 .../leetcode/sum-of-left-leaves/README.md     |  24 +
 .../sum-of-left-leaves.java                   |  25 +
 .../README.md                                 |  26 +
 ...of-nodes-with-even-valued-grandparent.java |  41 +
 .../leetcode/sum-of-unique-elements/README.md |  34 +
 .../sum-of-unique-elements.java               |  17 +
 .../leetcode/swap-nodes-in-pairs/README.md    |  29 +
 .../swap-nodes-in-pairs.java                  |  30 +
 .../swapping-nodes-in-a-linked-list/README.md |  44 +
 .../swapping-nodes-in-a-linked-list.java      |  41 +
 .../leetcode/the-kth-factor-of-n/README.md    |  48 +
 .../the-kth-factor-of-n.java                  |  10 +
 .../time-needed-to-buy-tickets/README.md      |  39 +
 .../time-needed-to-buy-tickets.java           |  16 +
 leetcode/leetcode/truncate-sentence/README.md |  45 +
 .../truncate-sentence/truncate-sentence.java  |   9 +
 .../README.md                                 |  39 +
 .../two-sum-ii-input-array-is-sorted.java     |  26 +
 leetcode/leetcode/two-sum/README.md           |  38 +
 leetcode/leetcode/two-sum/two-sum.java        |  15 +
 .../unique-number-of-occurrences/README.md    |  29 +
 .../unique-number-of-occurrences.java         |  13 +
 leetcode/leetcode/valid-parentheses/README.md |  48 +
 .../valid-parentheses/valid-parentheses.java  |  21 +
 .../leetcode/valid-perfect-square/README.md   |  19 +
 .../valid-perfect-square.cpp                  |  18 +
 .../leetcode/valid-triangle-number/README.md  |  27 +
 .../valid-triangle-number.java                |  21 +
 .../validate-binary-search-tree/README.md     |  32 +
 .../validate-binary-search-tree.java          |  29 +
 leetcode/leetcode/water-bottles/README.md     |  46 +
 .../leetcode/water-bottles/water-bottles.java |  12 +
 leetcode/leetcode/watering-plants/README.md   |  59 ++
 .../watering-plants/watering-plants.java      |  19 +
 1818 files changed, 52176 insertions(+)
 create mode 100644 .DS_Store
 create mode 100644 leetcode/leetcode/0001-two-sum/0001-two-sum.cpp
 create mode 100644 leetcode/leetcode/0001-two-sum/0001-two-sum.java
 create mode 100644 leetcode/leetcode/0001-two-sum/NOTES.md
 create mode 100644 leetcode/leetcode/0001-two-sum/README.md
 create mode 100644 leetcode/leetcode/0003-longest-substring-without-repeating-characters/0003-longest-substring-without-repeating-characters.java
 create mode 100644 leetcode/leetcode/0003-longest-substring-without-repeating-characters/README.md
 create mode 100644 leetcode/leetcode/0005-longest-palindromic-substring/0005-longest-palindromic-substring.java
 create mode 100644 leetcode/leetcode/0005-longest-palindromic-substring/NOTES.md
 create mode 100644 leetcode/leetcode/0005-longest-palindromic-substring/README.md
 create mode 100644 leetcode/leetcode/0009-palindrome-number/0009-palindrome-number.java
 create mode 100644 leetcode/leetcode/0009-palindrome-number/NOTES.md
 create mode 100644 leetcode/leetcode/0011-container-with-most-water/0011-container-with-most-water.java
 create mode 100644 leetcode/leetcode/0011-container-with-most-water/NOTES.md
 create mode 100644 leetcode/leetcode/0011-container-with-most-water/README.md
 create mode 100644 leetcode/leetcode/0013-roman-to-integer/0013-roman-to-integer.java
 create mode 100644 leetcode/leetcode/0013-roman-to-integer/NOTES.md
 create mode 100644 leetcode/leetcode/0013-roman-to-integer/README.md
 create mode 100644 leetcode/leetcode/0014-longest-common-prefix/0014-longest-common-prefix.java
 create mode 100644 leetcode/leetcode/0014-longest-common-prefix/NOTES.md
 create mode 100644 leetcode/leetcode/0014-longest-common-prefix/README.md
 create mode 100644 leetcode/leetcode/0015-3sum/0015-3sum.java
 create mode 100644 leetcode/leetcode/0015-3sum/README.md
 create mode 100644 leetcode/leetcode/0016-3sum-closest/0016-3sum-closest.java
 create mode 100644 leetcode/leetcode/0016-3sum-closest/README.md
 create mode 100644 leetcode/leetcode/0020-valid-parentheses/0020-valid-parentheses.java
 create mode 100644 leetcode/leetcode/0020-valid-parentheses/README.md
 create mode 100644 leetcode/leetcode/0021-merge-two-sorted-lists/0021-merge-two-sorted-lists.java
 create mode 100644 leetcode/leetcode/0021-merge-two-sorted-lists/README.md
 create mode 100644 leetcode/leetcode/0023-merge-k-sorted-lists/0023-merge-k-sorted-lists.java
 create mode 100644 leetcode/leetcode/0023-merge-k-sorted-lists/README.md
 create mode 100644 leetcode/leetcode/0024-swap-nodes-in-pairs/0024-swap-nodes-in-pairs.java
 create mode 100644 leetcode/leetcode/0024-swap-nodes-in-pairs/NOTES.md
 create mode 100644 leetcode/leetcode/0024-swap-nodes-in-pairs/README.md
 create mode 100644 leetcode/leetcode/0025-reverse-nodes-in-k-group/0025-reverse-nodes-in-k-group.java
 create mode 100644 leetcode/leetcode/0025-reverse-nodes-in-k-group/README.md
 create mode 100644 leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/0028-find-the-index-of-the-first-occurrence-in-a-string.java
 create mode 100644 leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/NOTES.md
 create mode 100644 leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/README.md
 create mode 100644 leetcode/leetcode/0029-divide-two-integers/0029-divide-two-integers.java
 create mode 100644 leetcode/leetcode/0029-divide-two-integers/README.md
 create mode 100644 leetcode/leetcode/0032-longest-valid-parentheses/0032-longest-valid-parentheses.java
 create mode 100644 leetcode/leetcode/0032-longest-valid-parentheses/NOTES.md
 create mode 100644 leetcode/leetcode/0032-longest-valid-parentheses/README.md
 create mode 100644 leetcode/leetcode/0033-search-in-rotated-sorted-array/0033-search-in-rotated-sorted-array.java
 create mode 100644 leetcode/leetcode/0033-search-in-rotated-sorted-array/README.md
 create mode 100644 leetcode/leetcode/0034-find-first-and-last-position-of-element-in-sorted-array/0034-find-first-and-last-position-of-element-in-sorted-array.java
 create mode 100644 leetcode/leetcode/0034-find-first-and-last-position-of-element-in-sorted-array/README.md
 create mode 100644 leetcode/leetcode/0038-count-and-say/0038-count-and-say.java
 create mode 100644 leetcode/leetcode/0038-count-and-say/README.md
 create mode 100644 leetcode/leetcode/0039-combination-sum/0039-combination-sum.java
 create mode 100644 leetcode/leetcode/0039-combination-sum/0039-combination-sum.py
 create mode 100644 leetcode/leetcode/0039-combination-sum/README.md
 create mode 100644 leetcode/leetcode/0040-combination-sum-ii/0040-combination-sum-ii.py
 create mode 100644 leetcode/leetcode/0040-combination-sum-ii/README.md
 create mode 100644 leetcode/leetcode/0045-jump-game-ii/0045-jump-game-ii.java
 create mode 100644 leetcode/leetcode/0045-jump-game-ii/README.md
 create mode 100644 leetcode/leetcode/0046-permutations/0046-permutations.java
 create mode 100644 leetcode/leetcode/0046-permutations/README.md
 create mode 100644 leetcode/leetcode/0048-rotate-image/0048-rotate-image.java
 create mode 100644 leetcode/leetcode/0048-rotate-image/README.md
 create mode 100644 leetcode/leetcode/0049-group-anagrams/0049-group-anagrams.java
 create mode 100644 leetcode/leetcode/0049-group-anagrams/README.md
 create mode 100644 leetcode/leetcode/0050-powx-n/0050-powx-n.java
 create mode 100644 leetcode/leetcode/0050-powx-n/NOTES.md
 create mode 100644 leetcode/leetcode/0050-powx-n/README.md
 create mode 100644 leetcode/leetcode/0053-maximum-subarray/0053-maximum-subarray.java
 create mode 100644 leetcode/leetcode/0053-maximum-subarray/README.md
 create mode 100644 leetcode/leetcode/0055-jump-game/0055-jump-game.java
 create mode 100644 leetcode/leetcode/0055-jump-game/README.md
 create mode 100644 leetcode/leetcode/0056-merge-intervals/0056-merge-intervals.java
 create mode 100644 leetcode/leetcode/0056-merge-intervals/README.md
 create mode 100644 leetcode/leetcode/0057-insert-interval/0057-insert-interval.java
 create mode 100644 leetcode/leetcode/0057-insert-interval/README.md
 create mode 100644 leetcode/leetcode/0058-length-of-last-word/0058-length-of-last-word.java
 create mode 100644 leetcode/leetcode/0058-length-of-last-word/NOTES.md
 create mode 100644 leetcode/leetcode/0058-length-of-last-word/README.md
 create mode 100644 leetcode/leetcode/0061-rotate-list/0061-rotate-list.java
 create mode 100644 leetcode/leetcode/0061-rotate-list/NOTES.md
 create mode 100644 leetcode/leetcode/0061-rotate-list/README.md
 create mode 100644 leetcode/leetcode/0062-unique-paths/0062-unique-paths.java
 create mode 100644 leetcode/leetcode/0062-unique-paths/README.md
 create mode 100644 leetcode/leetcode/0063-unique-paths-ii/0063-unique-paths-ii.java
 create mode 100644 leetcode/leetcode/0063-unique-paths-ii/README.md
 create mode 100644 leetcode/leetcode/0064-minimum-path-sum/0064-minimum-path-sum.java
 create mode 100644 leetcode/leetcode/0064-minimum-path-sum/README.md
 create mode 100644 leetcode/leetcode/0069-sqrtx/0069-sqrtx.java
 create mode 100644 leetcode/leetcode/0069-sqrtx/README.md
 create mode 100644 leetcode/leetcode/0070-climbing-stairs/0070-climbing-stairs.java
 create mode 100644 leetcode/leetcode/0070-climbing-stairs/README.md
 create mode 100644 leetcode/leetcode/0073-set-matrix-zeroes/0073-set-matrix-zeroes.java
 create mode 100644 leetcode/leetcode/0073-set-matrix-zeroes/NOTES.md
 create mode 100644 leetcode/leetcode/0073-set-matrix-zeroes/README.md
 create mode 100644 leetcode/leetcode/0075-sort-colors/0075-sort-colors.java
 create mode 100644 leetcode/leetcode/0075-sort-colors/README.md
 create mode 100644 leetcode/leetcode/0076-minimum-window-substring/0076-minimum-window-substring.java
 create mode 100644 leetcode/leetcode/0076-minimum-window-substring/README.md
 create mode 100644 leetcode/leetcode/0078-subsets/0078-subsets.java
 create mode 100644 leetcode/leetcode/0078-subsets/0078-subsets.py
 create mode 100644 leetcode/leetcode/0078-subsets/README.md
 create mode 100644 leetcode/leetcode/0082-remove-duplicates-from-sorted-list-ii/0082-remove-duplicates-from-sorted-list-ii.cpp
 create mode 100644 leetcode/leetcode/0082-remove-duplicates-from-sorted-list-ii/README.md
 create mode 100644 leetcode/leetcode/0083-remove-duplicates-from-sorted-list/0083-remove-duplicates-from-sorted-list.java
 create mode 100644 leetcode/leetcode/0083-remove-duplicates-from-sorted-list/README.md
 create mode 100644 leetcode/leetcode/0088-merge-sorted-array/0088-merge-sorted-array.java
 create mode 100644 leetcode/leetcode/0088-merge-sorted-array/NOTES.md
 create mode 100644 leetcode/leetcode/0088-merge-sorted-array/README.md
 create mode 100644 leetcode/leetcode/0092-reverse-linked-list-ii/0092-reverse-linked-list-ii.java
 create mode 100644 leetcode/leetcode/0092-reverse-linked-list-ii/README.md
 create mode 100644 leetcode/leetcode/0094-binary-tree-inorder-traversal/0094-binary-tree-inorder-traversal.java
 create mode 100644 leetcode/leetcode/0094-binary-tree-inorder-traversal/0094-binary-tree-inorder-traversal.py
 create mode 100644 leetcode/leetcode/0094-binary-tree-inorder-traversal/README.md
 create mode 100644 leetcode/leetcode/0098-validate-binary-search-tree/0098-validate-binary-search-tree.java
 create mode 100644 leetcode/leetcode/0098-validate-binary-search-tree/0098-validate-binary-search-tree.py
 create mode 100644 leetcode/leetcode/0098-validate-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/0100-same-tree/0100-same-tree.java
 create mode 100644 leetcode/leetcode/0100-same-tree/NOTES.md
 create mode 100644 leetcode/leetcode/0100-same-tree/README.md
 create mode 100644 leetcode/leetcode/0102-binary-tree-level-order-traversal/0102-binary-tree-level-order-traversal.java
 create mode 100644 leetcode/leetcode/0102-binary-tree-level-order-traversal/README.md
 create mode 100644 leetcode/leetcode/0103-binary-tree-zigzag-level-order-traversal/0103-binary-tree-zigzag-level-order-traversal.java
 create mode 100644 leetcode/leetcode/0103-binary-tree-zigzag-level-order-traversal/README.md
 create mode 100644 leetcode/leetcode/0104-maximum-depth-of-binary-tree/0104-maximum-depth-of-binary-tree.java
 create mode 100644 leetcode/leetcode/0104-maximum-depth-of-binary-tree/README.md
 create mode 100644 leetcode/leetcode/0106-construct-binary-tree-from-inorder-and-postorder-traversal/0106-construct-binary-tree-from-inorder-and-postorder-traversal.cpp
 create mode 100644 leetcode/leetcode/0106-construct-binary-tree-from-inorder-and-postorder-traversal/README.md
 create mode 100644 leetcode/leetcode/0108-convert-sorted-array-to-binary-search-tree/0108-convert-sorted-array-to-binary-search-tree.java
 create mode 100644 leetcode/leetcode/0108-convert-sorted-array-to-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/0110-balanced-binary-tree/0110-balanced-binary-tree.java
 create mode 100644 leetcode/leetcode/0110-balanced-binary-tree/README.md
 create mode 100644 leetcode/leetcode/0112-path-sum/0112-path-sum.java
 create mode 100644 leetcode/leetcode/0112-path-sum/README.md
 create mode 100644 leetcode/leetcode/0114-flatten-binary-tree-to-linked-list/0114-flatten-binary-tree-to-linked-list.java
 create mode 100644 leetcode/leetcode/0114-flatten-binary-tree-to-linked-list/README.md
 create mode 100644 leetcode/leetcode/0116-populating-next-right-pointers-in-each-node/0116-populating-next-right-pointers-in-each-node.java
 create mode 100644 leetcode/leetcode/0116-populating-next-right-pointers-in-each-node/README.md
 create mode 100644 leetcode/leetcode/0118-pascals-triangle/0118-pascals-triangle.java
 create mode 100644 leetcode/leetcode/0118-pascals-triangle/README.md
 create mode 100644 leetcode/leetcode/0119-pascals-triangle-ii/0119-pascals-triangle-ii.java
 create mode 100644 leetcode/leetcode/0119-pascals-triangle-ii/NOTES.md
 create mode 100644 leetcode/leetcode/0119-pascals-triangle-ii/README.md
 create mode 100644 leetcode/leetcode/0120-triangle/0120-triangle.java
 create mode 100644 leetcode/leetcode/0120-triangle/README.md
 create mode 100644 leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/0121-best-time-to-buy-and-sell-stock.java
 create mode 100644 leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/0121-best-time-to-buy-and-sell-stock.py
 create mode 100644 leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/NOTES.md
 create mode 100644 leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/README.md
 create mode 100644 leetcode/leetcode/0124-binary-tree-maximum-path-sum/0124-binary-tree-maximum-path-sum.java
 create mode 100644 leetcode/leetcode/0124-binary-tree-maximum-path-sum/README.md
 create mode 100644 leetcode/leetcode/0125-valid-palindrome/0125-valid-palindrome.java
 create mode 100644 leetcode/leetcode/0125-valid-palindrome/NOTES.md
 create mode 100644 leetcode/leetcode/0125-valid-palindrome/README.md
 create mode 100644 leetcode/leetcode/0128-longest-consecutive-sequence/0128-longest-consecutive-sequence.java
 create mode 100644 leetcode/leetcode/0128-longest-consecutive-sequence/README.md
 create mode 100644 leetcode/leetcode/0129-sum-root-to-leaf-numbers/0129-sum-root-to-leaf-numbers.java
 create mode 100644 leetcode/leetcode/0129-sum-root-to-leaf-numbers/README.md
 create mode 100644 leetcode/leetcode/0131-palindrome-partitioning/0131-palindrome-partitioning.py
 create mode 100644 leetcode/leetcode/0131-palindrome-partitioning/README.md
 create mode 100644 leetcode/leetcode/0133-clone-graph/0133-clone-graph.java
 create mode 100644 leetcode/leetcode/0133-clone-graph/README.md
 create mode 100644 leetcode/leetcode/0134-gas-station/0134-gas-station.java
 create mode 100644 leetcode/leetcode/0134-gas-station/README.md
 create mode 100644 leetcode/leetcode/0138-copy-list-with-random-pointer/0138-copy-list-with-random-pointer.java
 create mode 100644 leetcode/leetcode/0138-copy-list-with-random-pointer/NOTES.md
 create mode 100644 leetcode/leetcode/0138-copy-list-with-random-pointer/README.md
 create mode 100644 leetcode/leetcode/0141-linked-list-cycle/0141-linked-list-cycle.java
 create mode 100644 leetcode/leetcode/0141-linked-list-cycle/NOTES.md
 create mode 100644 leetcode/leetcode/0141-linked-list-cycle/README.md
 create mode 100644 leetcode/leetcode/0142-linked-list-cycle-ii/0142-linked-list-cycle-ii.java
 create mode 100644 leetcode/leetcode/0142-linked-list-cycle-ii/README.md
 create mode 100644 leetcode/leetcode/0143-reorder-list/0143-reorder-list.java
 create mode 100644 leetcode/leetcode/0143-reorder-list/README.md
 create mode 100644 leetcode/leetcode/0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.java
 create mode 100644 leetcode/leetcode/0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.py
 create mode 100644 leetcode/leetcode/0144-binary-tree-preorder-traversal/README.md
 create mode 100644 leetcode/leetcode/0145-binary-tree-postorder-traversal/0145-binary-tree-postorder-traversal.java
 create mode 100644 leetcode/leetcode/0145-binary-tree-postorder-traversal/NOTES.md
 create mode 100644 leetcode/leetcode/0145-binary-tree-postorder-traversal/README.md
 create mode 100644 leetcode/leetcode/0146-lru-cache/0146-lru-cache.java
 create mode 100644 leetcode/leetcode/0146-lru-cache/README.md
 create mode 100644 leetcode/leetcode/0149-max-points-on-a-line/0149-max-points-on-a-line.java
 create mode 100644 leetcode/leetcode/0149-max-points-on-a-line/NOTES.md
 create mode 100644 leetcode/leetcode/0149-max-points-on-a-line/README.md
 create mode 100644 leetcode/leetcode/0150-evaluate-reverse-polish-notation/0150-evaluate-reverse-polish-notation.java
 create mode 100644 leetcode/leetcode/0150-evaluate-reverse-polish-notation/NOTES.md
 create mode 100644 leetcode/leetcode/0150-evaluate-reverse-polish-notation/README.md
 create mode 100644 leetcode/leetcode/0151-reverse-words-in-a-string/0151-reverse-words-in-a-string.java
 create mode 100644 leetcode/leetcode/0151-reverse-words-in-a-string/NOTES.md
 create mode 100644 leetcode/leetcode/0151-reverse-words-in-a-string/README.md
 create mode 100644 leetcode/leetcode/0152-maximum-product-subarray/0152-maximum-product-subarray.java
 create mode 100644 leetcode/leetcode/0152-maximum-product-subarray/README.md
 create mode 100644 leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/0153-find-minimum-in-rotated-sorted-array.java
 create mode 100644 leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/0153-find-minimum-in-rotated-sorted-array.py
 create mode 100644 leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/README.md
 create mode 100644 leetcode/leetcode/0155-min-stack/0155-min-stack.java
 create mode 100644 leetcode/leetcode/0155-min-stack/NOTES.md
 create mode 100644 leetcode/leetcode/0155-min-stack/README.md
 create mode 100644 leetcode/leetcode/0160-intersection-of-two-linked-lists/0160-intersection-of-two-linked-lists.java
 create mode 100644 leetcode/leetcode/0160-intersection-of-two-linked-lists/README.md
 create mode 100644 leetcode/leetcode/0162-find-peak-element/0162-find-peak-element.java
 create mode 100644 leetcode/leetcode/0162-find-peak-element/README.md
 create mode 100644 leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/0167-two-sum-ii-input-array-is-sorted.java
 create mode 100644 leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/NOTES.md
 create mode 100644 leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/README.md
 create mode 100644 leetcode/leetcode/0169-majority-element/0169-majority-element.java
 create mode 100644 leetcode/leetcode/0169-majority-element/NOTES.md
 create mode 100644 leetcode/leetcode/0169-majority-element/README.md
 create mode 100644 leetcode/leetcode/0175-combine-two-tables/0175-combine-two-tables.sql
 create mode 100644 leetcode/leetcode/0175-combine-two-tables/NOTES.md
 create mode 100644 leetcode/leetcode/0176-second-highest-salary/0176-second-highest-salary.sql
 create mode 100644 leetcode/leetcode/0176-second-highest-salary/README.md
 create mode 100644 leetcode/leetcode/0177-nth-highest-salary/README.md
 create mode 100644 leetcode/leetcode/0179-largest-number/0179-largest-number.java
 create mode 100644 leetcode/leetcode/0179-largest-number/NOTES.md
 create mode 100644 leetcode/leetcode/0179-largest-number/README.md
 create mode 100644 leetcode/leetcode/0187-repeated-dna-sequences/0187-repeated-dna-sequences.java
 create mode 100644 leetcode/leetcode/0187-repeated-dna-sequences/README.md
 create mode 100644 leetcode/leetcode/0189-rotate-array/0189-rotate-array.java
 create mode 100644 leetcode/leetcode/0189-rotate-array/NOTES.md
 create mode 100644 leetcode/leetcode/0189-rotate-array/README.md
 create mode 100644 leetcode/leetcode/0191-number-of-1-bits/0191-number-of-1-bits.java
 create mode 100644 leetcode/leetcode/0191-number-of-1-bits/README.md
 create mode 100644 leetcode/leetcode/0196-delete-duplicate-emails/0196-delete-duplicate-emails.sql
 create mode 100644 leetcode/leetcode/0196-delete-duplicate-emails/NOTES.md
 create mode 100644 leetcode/leetcode/0198-house-robber/0198-house-robber.java
 create mode 100644 leetcode/leetcode/0198-house-robber/0198-house-robber.py
 create mode 100644 leetcode/leetcode/0198-house-robber/README.md
 create mode 100644 leetcode/leetcode/0199-binary-tree-right-side-view/0199-binary-tree-right-side-view.java
 create mode 100644 leetcode/leetcode/0199-binary-tree-right-side-view/README.md
 create mode 100644 leetcode/leetcode/0200-number-of-islands/0200-number-of-islands.java
 create mode 100644 leetcode/leetcode/0200-number-of-islands/README.md
 create mode 100644 leetcode/leetcode/0201-bitwise-and-of-numbers-range/0201-bitwise-and-of-numbers-range.java
 create mode 100644 leetcode/leetcode/0201-bitwise-and-of-numbers-range/README.md
 create mode 100644 leetcode/leetcode/0205-isomorphic-strings/0205-isomorphic-strings.java
 create mode 100644 leetcode/leetcode/0205-isomorphic-strings/NOTES.md
 create mode 100644 leetcode/leetcode/0205-isomorphic-strings/README.md
 create mode 100644 leetcode/leetcode/0206-reverse-linked-list/0206-reverse-linked-list.java
 create mode 100644 leetcode/leetcode/0206-reverse-linked-list/0206-reverse-linked-list.py
 create mode 100644 leetcode/leetcode/0206-reverse-linked-list/README.md
 create mode 100644 leetcode/leetcode/0209-minimum-size-subarray-sum/0209-minimum-size-subarray-sum.java
 create mode 100644 leetcode/leetcode/0209-minimum-size-subarray-sum/README.md
 create mode 100644 leetcode/leetcode/0213-house-robber-ii/0213-house-robber-ii.java
 create mode 100644 leetcode/leetcode/0213-house-robber-ii/README.md
 create mode 100644 leetcode/leetcode/0214-shortest-palindrome/0214-shortest-palindrome.java
 create mode 100644 leetcode/leetcode/0214-shortest-palindrome/NOTES.md
 create mode 100644 leetcode/leetcode/0214-shortest-palindrome/README.md
 create mode 100644 leetcode/leetcode/0215-kth-largest-element-in-an-array/0215-kth-largest-element-in-an-array.java
 create mode 100644 leetcode/leetcode/0215-kth-largest-element-in-an-array/NOTES.md
 create mode 100644 leetcode/leetcode/0215-kth-largest-element-in-an-array/README.md
 create mode 100644 leetcode/leetcode/0217-contains-duplicate/0217-contains-duplicate.java
 create mode 100644 leetcode/leetcode/0217-contains-duplicate/README.md
 create mode 100644 leetcode/leetcode/0225-implement-stack-using-queues/0225-implement-stack-using-queues.java
 create mode 100644 leetcode/leetcode/0225-implement-stack-using-queues/README.md
 create mode 100644 leetcode/leetcode/0226-invert-binary-tree/0226-invert-binary-tree.java
 create mode 100644 leetcode/leetcode/0226-invert-binary-tree/README.md
 create mode 100644 leetcode/leetcode/0229-majority-element-ii/0229-majority-element-ii.java
 create mode 100644 leetcode/leetcode/0229-majority-element-ii/README.md
 create mode 100644 leetcode/leetcode/0230-kth-smallest-element-in-a-bst/0230-kth-smallest-element-in-a-bst.java
 create mode 100644 leetcode/leetcode/0230-kth-smallest-element-in-a-bst/README.md
 create mode 100644 leetcode/leetcode/0232-implement-queue-using-stacks/0232-implement-queue-using-stacks.java
 create mode 100644 leetcode/leetcode/0232-implement-queue-using-stacks/README.md
 create mode 100644 leetcode/leetcode/0234-palindrome-linked-list/0234-palindrome-linked-list.java
 create mode 100644 leetcode/leetcode/0234-palindrome-linked-list/README.md
 create mode 100644 leetcode/leetcode/0235-lowest-common-ancestor-of-a-binary-search-tree/0235-lowest-common-ancestor-of-a-binary-search-tree.java
 create mode 100644 leetcode/leetcode/0235-lowest-common-ancestor-of-a-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/0236-lowest-common-ancestor-of-a-binary-tree/0236-lowest-common-ancestor-of-a-binary-tree.java
 create mode 100644 leetcode/leetcode/0236-lowest-common-ancestor-of-a-binary-tree/README.md
 create mode 100644 leetcode/leetcode/0237-delete-node-in-a-linked-list/0237-delete-node-in-a-linked-list.java
 create mode 100644 leetcode/leetcode/0237-delete-node-in-a-linked-list/NOTES.md
 create mode 100644 leetcode/leetcode/0237-delete-node-in-a-linked-list/README.md
 create mode 100644 leetcode/leetcode/0238-product-of-array-except-self/0238-product-of-array-except-self.java
 create mode 100644 leetcode/leetcode/0238-product-of-array-except-self/NOTES.md
 create mode 100644 leetcode/leetcode/0238-product-of-array-except-self/README.md
 create mode 100644 leetcode/leetcode/0239-sliding-window-maximum/0239-sliding-window-maximum.java
 create mode 100644 leetcode/leetcode/0239-sliding-window-maximum/README.md
 create mode 100644 leetcode/leetcode/0241-different-ways-to-add-parentheses/0241-different-ways-to-add-parentheses.java
 create mode 100644 leetcode/leetcode/0241-different-ways-to-add-parentheses/NOTES.md
 create mode 100644 leetcode/leetcode/0241-different-ways-to-add-parentheses/README.md
 create mode 100644 leetcode/leetcode/0242-valid-anagram/0242-valid-anagram.java
 create mode 100644 leetcode/leetcode/0242-valid-anagram/NOTES.md
 create mode 100644 leetcode/leetcode/0242-valid-anagram/README.md
 create mode 100644 leetcode/leetcode/0257-binary-tree-paths/0257-binary-tree-paths.py
 create mode 100644 leetcode/leetcode/0257-binary-tree-paths/README.md
 create mode 100644 leetcode/leetcode/0268-missing-number/0268-missing-number.java
 create mode 100644 leetcode/leetcode/0268-missing-number/README.md
 create mode 100644 leetcode/leetcode/0283-move-zeroes/0283-move-zeroes.java
 create mode 100644 leetcode/leetcode/0283-move-zeroes/NOTES.md
 create mode 100644 leetcode/leetcode/0283-move-zeroes/README.md
 create mode 100644 leetcode/leetcode/0287-find-the-duplicate-number/0287-find-the-duplicate-number.java
 create mode 100644 leetcode/leetcode/0287-find-the-duplicate-number/README.md
 create mode 100644 leetcode/leetcode/0300-longest-increasing-subsequence/0300-longest-increasing-subsequence.java
 create mode 100644 leetcode/leetcode/0300-longest-increasing-subsequence/NOTES.md
 create mode 100644 leetcode/leetcode/0300-longest-increasing-subsequence/README.md
 create mode 100644 leetcode/leetcode/0303-range-sum-query-immutable/0303-range-sum-query-immutable.java
 create mode 100644 leetcode/leetcode/0303-range-sum-query-immutable/README.md
 create mode 100644 leetcode/leetcode/0322-coin-change/0322-coin-change.java
 create mode 100644 leetcode/leetcode/0322-coin-change/README.md
 create mode 100644 leetcode/leetcode/0326-power-of-three/0326-power-of-three.java
 create mode 100644 leetcode/leetcode/0326-power-of-three/README.md
 create mode 100644 leetcode/leetcode/0328-odd-even-linked-list/0328-odd-even-linked-list.cpp
 create mode 100644 leetcode/leetcode/0328-odd-even-linked-list/README.md
 create mode 100644 leetcode/leetcode/0334-increasing-triplet-subsequence/0334-increasing-triplet-subsequence.java
 create mode 100644 leetcode/leetcode/0334-increasing-triplet-subsequence/NOTES.md
 create mode 100644 leetcode/leetcode/0334-increasing-triplet-subsequence/README.md
 create mode 100644 leetcode/leetcode/0337-house-robber-iii/0337-house-robber-iii.java
 create mode 100644 leetcode/leetcode/0337-house-robber-iii/README.md
 create mode 100644 leetcode/leetcode/0338-counting-bits/0338-counting-bits.java
 create mode 100644 leetcode/leetcode/0338-counting-bits/README.md
 create mode 100644 leetcode/leetcode/0342-power-of-four/0342-power-of-four.java
 create mode 100644 leetcode/leetcode/0342-power-of-four/README.md
 create mode 100644 leetcode/leetcode/0345-reverse-vowels-of-a-string/0345-reverse-vowels-of-a-string.java
 create mode 100644 leetcode/leetcode/0345-reverse-vowels-of-a-string/README.md
 create mode 100644 leetcode/leetcode/0347-top-k-frequent-elements/0347-top-k-frequent-elements.java
 create mode 100644 leetcode/leetcode/0347-top-k-frequent-elements/README.md
 create mode 100644 leetcode/leetcode/0350-intersection-of-two-arrays-ii/0350-intersection-of-two-arrays-ii.java
 create mode 100644 leetcode/leetcode/0350-intersection-of-two-arrays-ii/NOTES.md
 create mode 100644 leetcode/leetcode/0350-intersection-of-two-arrays-ii/README.md
 create mode 100644 leetcode/leetcode/0374-guess-number-higher-or-lower/0374-guess-number-higher-or-lower.java
 create mode 100644 leetcode/leetcode/0374-guess-number-higher-or-lower/README.md
 create mode 100644 leetcode/leetcode/0380-insert-delete-getrandom-o1/README.md
 create mode 100644 leetcode/leetcode/0386-lexicographical-numbers/0386-lexicographical-numbers.java
 create mode 100644 leetcode/leetcode/0386-lexicographical-numbers/README.md
 create mode 100644 leetcode/leetcode/0392-is-subsequence/0392-is-subsequence.java
 create mode 100644 leetcode/leetcode/0392-is-subsequence/NOTES.md
 create mode 100644 leetcode/leetcode/0392-is-subsequence/README.md
 create mode 100644 leetcode/leetcode/0402-remove-k-digits/0402-remove-k-digits.java
 create mode 100644 leetcode/leetcode/0402-remove-k-digits/README.md
 create mode 100644 leetcode/leetcode/0404-sum-of-left-leaves/0404-sum-of-left-leaves.java
 create mode 100644 leetcode/leetcode/0404-sum-of-left-leaves/README.md
 create mode 100644 leetcode/leetcode/0416-partition-equal-subset-sum/0416-partition-equal-subset-sum.java
 create mode 100644 leetcode/leetcode/0416-partition-equal-subset-sum/README.md
 create mode 100644 leetcode/leetcode/0424-longest-repeating-character-replacement/0424-longest-repeating-character-replacement.java
 create mode 100644 leetcode/leetcode/0424-longest-repeating-character-replacement/README.md
 create mode 100644 leetcode/leetcode/0435-non-overlapping-intervals/0435-non-overlapping-intervals.java
 create mode 100644 leetcode/leetcode/0435-non-overlapping-intervals/README.md
 create mode 100644 leetcode/leetcode/0440-k-th-smallest-in-lexicographical-order/NOTES.md
 create mode 100644 leetcode/leetcode/0440-k-th-smallest-in-lexicographical-order/README.md
 create mode 100644 leetcode/leetcode/0443-string-compression/0443-string-compression.java
 create mode 100644 leetcode/leetcode/0443-string-compression/NOTES.md
 create mode 100644 leetcode/leetcode/0443-string-compression/README.md
 create mode 100644 leetcode/leetcode/0451-sort-characters-by-frequency/0451-sort-characters-by-frequency.java
 create mode 100644 leetcode/leetcode/0451-sort-characters-by-frequency/README.md
 create mode 100644 leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/0452-minimum-number-of-arrows-to-burst-balloons.java
 create mode 100644 leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/NOTES.md
 create mode 100644 leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/README.md
 create mode 100644 leetcode/leetcode/0480-sliding-window-median/0480-sliding-window-median.java
 create mode 100644 leetcode/leetcode/0480-sliding-window-median/README.md
 create mode 100644 leetcode/leetcode/0485-max-consecutive-ones/0485-max-consecutive-ones.java
 create mode 100644 leetcode/leetcode/0485-max-consecutive-ones/README.md
 create mode 100644 leetcode/leetcode/0503-next-greater-element-ii/0503-next-greater-element-ii.java
 create mode 100644 leetcode/leetcode/0503-next-greater-element-ii/README.md
 create mode 100644 leetcode/leetcode/0509-fibonacci-number/NOTES.md
 create mode 100644 leetcode/leetcode/0509-fibonacci-number/README.md
 create mode 100644 leetcode/leetcode/0513-find-bottom-left-tree-value/0513-find-bottom-left-tree-value.java
 create mode 100644 leetcode/leetcode/0513-find-bottom-left-tree-value/README.md
 create mode 100644 leetcode/leetcode/0515-find-largest-value-in-each-tree-row/README.md
 create mode 100644 leetcode/leetcode/0516-longest-palindromic-subsequence/0516-longest-palindromic-subsequence.java
 create mode 100644 leetcode/leetcode/0516-longest-palindromic-subsequence/README.md
 create mode 100644 leetcode/leetcode/0525-contiguous-array/0525-contiguous-array.java
 create mode 100644 leetcode/leetcode/0525-contiguous-array/README.md
 create mode 100644 leetcode/leetcode/0539-minimum-time-difference/0539-minimum-time-difference.java
 create mode 100644 leetcode/leetcode/0539-minimum-time-difference/NOTES.md
 create mode 100644 leetcode/leetcode/0539-minimum-time-difference/README.md
 create mode 100644 leetcode/leetcode/0540-single-element-in-a-sorted-array/0540-single-element-in-a-sorted-array.java
 create mode 100644 leetcode/leetcode/0540-single-element-in-a-sorted-array/README.md
 create mode 100644 leetcode/leetcode/0543-diameter-of-binary-tree/0543-diameter-of-binary-tree.java
 create mode 100644 leetcode/leetcode/0543-diameter-of-binary-tree/README.md
 create mode 100644 leetcode/leetcode/0560-subarray-sum-equals-k/0560-subarray-sum-equals-k.java
 create mode 100644 leetcode/leetcode/0560-subarray-sum-equals-k/README.md
 create mode 100644 leetcode/leetcode/0584-find-customer-referee/0584-find-customer-referee.sql
 create mode 100644 leetcode/leetcode/0584-find-customer-referee/README.md
 create mode 100644 leetcode/leetcode/0605-can-place-flowers/0605-can-place-flowers.java
 create mode 100644 leetcode/leetcode/0605-can-place-flowers/NOTES.md
 create mode 100644 leetcode/leetcode/0605-can-place-flowers/README.md
 create mode 100644 leetcode/leetcode/0621-task-scheduler/0621-task-scheduler.java
 create mode 100644 leetcode/leetcode/0621-task-scheduler/NOTES.md
 create mode 100644 leetcode/leetcode/0621-task-scheduler/README.md
 create mode 100644 leetcode/leetcode/0637-average-of-levels-in-binary-tree/0637-average-of-levels-in-binary-tree.java
 create mode 100644 leetcode/leetcode/0637-average-of-levels-in-binary-tree/README.md
 create mode 100644 leetcode/leetcode/0643-maximum-average-subarray-i/0643-maximum-average-subarray-i.java
 create mode 100644 leetcode/leetcode/0643-maximum-average-subarray-i/NOTES.md
 create mode 100644 leetcode/leetcode/0643-maximum-average-subarray-i/README.md
 create mode 100644 leetcode/leetcode/0713-subarray-product-less-than-k/0713-subarray-product-less-than-k.java
 create mode 100644 leetcode/leetcode/0713-subarray-product-less-than-k/README.md
 create mode 100644 leetcode/leetcode/0724-find-pivot-index/0724-find-pivot-index.java
 create mode 100644 leetcode/leetcode/0724-find-pivot-index/NOTES.md
 create mode 100644 leetcode/leetcode/0724-find-pivot-index/README.md
 create mode 100644 leetcode/leetcode/0725-split-linked-list-in-parts/0725-split-linked-list-in-parts.java
 create mode 100644 leetcode/leetcode/0725-split-linked-list-in-parts/README.md
 create mode 100644 leetcode/leetcode/0735-asteroid-collision/0735-asteroid-collision.java
 create mode 100644 leetcode/leetcode/0735-asteroid-collision/README.md
 create mode 100644 leetcode/leetcode/0739-daily-temperatures/0739-daily-temperatures.java
 create mode 100644 leetcode/leetcode/0739-daily-temperatures/README.md
 create mode 100644 leetcode/leetcode/0763-partition-labels/0763-partition-labels.java
 create mode 100644 leetcode/leetcode/0763-partition-labels/NOTES.md
 create mode 100644 leetcode/leetcode/0763-partition-labels/README.md
 create mode 100644 leetcode/leetcode/0768-partition-labels/0768-partition-labels.java
 create mode 100644 leetcode/leetcode/0768-partition-labels/README.md
 create mode 100644 leetcode/leetcode/0783-search-in-a-binary-search-tree/0783-search-in-a-binary-search-tree.py
 create mode 100644 leetcode/leetcode/0783-search-in-a-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/0784-insert-into-a-binary-search-tree/0784-insert-into-a-binary-search-tree.java
 create mode 100644 leetcode/leetcode/0784-insert-into-a-binary-search-tree/0784-insert-into-a-binary-search-tree.py
 create mode 100644 leetcode/leetcode/0784-insert-into-a-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/0820-find-eventual-safe-states/0820-find-eventual-safe-states.java
 create mode 100644 leetcode/leetcode/0820-find-eventual-safe-states/README.md
 create mode 100644 leetcode/leetcode/0838-design-linked-list/0838-design-linked-list.java
 create mode 100644 leetcode/leetcode/0838-design-linked-list/README.md
 create mode 100644 leetcode/leetcode/0844-backspace-string-compare/0844-backspace-string-compare.java
 create mode 100644 leetcode/leetcode/0844-backspace-string-compare/NOTES.md
 create mode 100644 leetcode/leetcode/0844-backspace-string-compare/README.md
 create mode 100644 leetcode/leetcode/0872-leaf-similar-trees/0872-leaf-similar-trees.java
 create mode 100644 leetcode/leetcode/0872-leaf-similar-trees/NOTES.md
 create mode 100644 leetcode/leetcode/0872-leaf-similar-trees/README.md
 create mode 100644 leetcode/leetcode/0884-uncommon-words-from-two-sentences/0884-uncommon-words-from-two-sentences.java
 create mode 100644 leetcode/leetcode/0884-uncommon-words-from-two-sentences/NOTES.md
 create mode 100644 leetcode/leetcode/0884-uncommon-words-from-two-sentences/README.md
 create mode 100644 leetcode/leetcode/0894-all-possible-full-binary-trees/0894-all-possible-full-binary-trees.java
 create mode 100644 leetcode/leetcode/0894-all-possible-full-binary-trees/NOTES.md
 create mode 100644 leetcode/leetcode/0894-all-possible-full-binary-trees/README.md
 create mode 100644 leetcode/leetcode/0907-koko-eating-bananas/0907-koko-eating-bananas.java
 create mode 100644 leetcode/leetcode/0907-koko-eating-bananas/README.md
 create mode 100644 leetcode/leetcode/0908-middle-of-the-linked-list/0908-middle-of-the-linked-list.java
 create mode 100644 leetcode/leetcode/0908-middle-of-the-linked-list/README.md
 create mode 100644 leetcode/leetcode/0925-construct-binary-tree-from-preorder-and-postorder-traversal/0925-construct-binary-tree-from-preorder-and-postorder-traversal.java
 create mode 100644 leetcode/leetcode/0925-construct-binary-tree-from-preorder-and-postorder-traversal/README.md
 create mode 100644 leetcode/leetcode/0926-flip-string-to-monotone-increasing/0926-flip-string-to-monotone-increasing.java
 create mode 100644 leetcode/leetcode/0926-flip-string-to-monotone-increasing/NOTES.md
 create mode 100644 leetcode/leetcode/0926-flip-string-to-monotone-increasing/README.md
 create mode 100644 leetcode/leetcode/0937-online-stock-span/0937-online-stock-span.java
 create mode 100644 leetcode/leetcode/0937-online-stock-span/README.md
 create mode 100644 leetcode/leetcode/0944-delete-columns-to-make-sorted/0944-delete-columns-to-make-sorted.java
 create mode 100644 leetcode/leetcode/0944-delete-columns-to-make-sorted/NOTES.md
 create mode 100644 leetcode/leetcode/0944-delete-columns-to-make-sorted/README.md
 create mode 100644 leetcode/leetcode/0954-maximum-sum-circular-subarray/0954-maximum-sum-circular-subarray.java
 create mode 100644 leetcode/leetcode/0954-maximum-sum-circular-subarray/README.md
 create mode 100644 leetcode/leetcode/0966-binary-subarrays-with-sum/0966-binary-subarrays-with-sum.java
 create mode 100644 leetcode/leetcode/0966-binary-subarrays-with-sum/README.md
 create mode 100644 leetcode/leetcode/0967-minimum-falling-path-sum/0967-minimum-falling-path-sum.java
 create mode 100644 leetcode/leetcode/0967-minimum-falling-path-sum/README.md
 create mode 100644 leetcode/leetcode/0988-flip-equivalent-binary-trees/0988-flip-equivalent-binary-trees.java
 create mode 100644 leetcode/leetcode/0988-flip-equivalent-binary-trees/README.md
 create mode 100644 leetcode/leetcode/0997-find-the-town-judge/NOTES.md
 create mode 100644 leetcode/leetcode/0997-find-the-town-judge/README.md
 create mode 100644 leetcode/leetcode/1-two-sum/1-two-sum.java
 create mode 100644 leetcode/leetcode/1-two-sum/NOTES.md
 create mode 100644 leetcode/leetcode/1-two-sum/README.md
 create mode 100644 leetcode/leetcode/1004-max-consecutive-ones-iii/1004-max-consecutive-ones-iii.java
 create mode 100644 leetcode/leetcode/1004-max-consecutive-ones-iii/NOTES.md
 create mode 100644 leetcode/leetcode/1004-max-consecutive-ones-iii/README.md
 create mode 100644 leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/1008-construct-binary-search-tree-from-preorder-traversal.java
 create mode 100644 leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/NOTES.md
 create mode 100644 leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/README.md
 create mode 100644 leetcode/leetcode/1009-complement-of-base-10-integer/1009-complement-of-base-10-integer.java
 create mode 100644 leetcode/leetcode/1009-complement-of-base-10-integer/NOTES.md
 create mode 100644 leetcode/leetcode/1009-complement-of-base-10-integer/README.md
 create mode 100644 leetcode/leetcode/101-symmetric-tree/101-symmetric-tree.java
 create mode 100644 leetcode/leetcode/101-symmetric-tree/NOTES.md
 create mode 100644 leetcode/leetcode/101-symmetric-tree/README.md
 create mode 100644 leetcode/leetcode/1014-k-closest-points-to-origin/1014-k-closest-points-to-origin.java
 create mode 100644 leetcode/leetcode/1014-k-closest-points-to-origin/README.md
 create mode 100644 leetcode/leetcode/1019-next-greater-node-in-linked-list/1019-next-greater-node-in-linked-list.java
 create mode 100644 leetcode/leetcode/1019-next-greater-node-in-linked-list/NOTES.md
 create mode 100644 leetcode/leetcode/1019-next-greater-node-in-linked-list/README.md
 create mode 100644 leetcode/leetcode/102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.java
 create mode 100644 leetcode/leetcode/102-binary-tree-level-order-traversal/NOTES.md
 create mode 100644 leetcode/leetcode/102-binary-tree-level-order-traversal/README.md
 create mode 100644 leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/1022-sum-of-root-to-leaf-binary-numbers.java
 create mode 100644 leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/NOTES.md
 create mode 100644 leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/README.md
 create mode 100644 leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/1026-maximum-difference-between-node-and-ancestor.java
 create mode 100644 leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/NOTES.md
 create mode 100644 leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/README.md
 create mode 100644 leetcode/leetcode/1029-vertical-order-traversal-of-a-binary-tree/1029-vertical-order-traversal-of-a-binary-tree.java
 create mode 100644 leetcode/leetcode/1029-vertical-order-traversal-of-a-binary-tree/README.md
 create mode 100644 leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/103-binary-tree-zigzag-level-order-traversal.java
 create mode 100644 leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/NOTES.md
 create mode 100644 leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/README.md
 create mode 100644 leetcode/leetcode/1030-smallest-string-starting-from-leaf/1030-smallest-string-starting-from-leaf.java
 create mode 100644 leetcode/leetcode/1030-smallest-string-starting-from-leaf/README.md
 create mode 100644 leetcode/leetcode/1034-subarrays-with-k-different-integers/README.md
 create mode 100644 leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/1038-binary-search-tree-to-greater-sum-tree.java
 create mode 100644 leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/NOTES.md
 create mode 100644 leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/README.md
 create mode 100644 leetcode/leetcode/104-maximum-depth-of-binary-tree/104-maximum-depth-of-binary-tree.java
 create mode 100644 leetcode/leetcode/104-maximum-depth-of-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/104-maximum-depth-of-binary-tree/README.md
 create mode 100644 leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/105-construct-binary-tree-from-preorder-and-inorder-traversal.java
 create mode 100644 leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/NOTES.md
 create mode 100644 leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/README.md
 create mode 100644 leetcode/leetcode/1050-construct-binary-search-tree-from-preorder-traversal/1050-construct-binary-search-tree-from-preorder-traversal.java
 create mode 100644 leetcode/leetcode/1050-construct-binary-search-tree-from-preorder-traversal/README.md
 create mode 100644 leetcode/leetcode/1056-capacity-to-ship-packages-within-d-days/1056-capacity-to-ship-packages-within-d-days.java
 create mode 100644 leetcode/leetcode/1056-capacity-to-ship-packages-within-d-days/README.md
 create mode 100644 leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/106-construct-binary-tree-from-inorder-and-postorder-traversal.java
 create mode 100644 leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/NOTES.md
 create mode 100644 leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/README.md
 create mode 100644 leetcode/leetcode/1061-lexicographically-smallest-equivalent-string/1061-lexicographically-smallest-equivalent-string.java
 create mode 100644 leetcode/leetcode/1061-lexicographically-smallest-equivalent-string/README.md
 create mode 100644 leetcode/leetcode/107-binary-tree-level-order-traversal-ii/107-binary-tree-level-order-traversal-ii.java
 create mode 100644 leetcode/leetcode/107-binary-tree-level-order-traversal-ii/NOTES.md
 create mode 100644 leetcode/leetcode/107-binary-tree-level-order-traversal-ii/README.md
 create mode 100644 leetcode/leetcode/1071-greatest-common-divisor-of-strings/1071-greatest-common-divisor-of-strings.java
 create mode 100644 leetcode/leetcode/1071-greatest-common-divisor-of-strings/NOTES.md
 create mode 100644 leetcode/leetcode/1071-greatest-common-divisor-of-strings/README.md
 create mode 100644 leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/1081-smallest-subsequence-of-distinct-characters.java
 create mode 100644 leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/NOTES.md
 create mode 100644 leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/README.md
 create mode 100644 leetcode/leetcode/1089-duplicate-zeros/1089-duplicate-zeros.java
 create mode 100644 leetcode/leetcode/1089-duplicate-zeros/README.md
 create mode 100644 leetcode/leetcode/1093-recover-a-tree-from-preorder-traversal/1093-recover-a-tree-from-preorder-traversal.java
 create mode 100644 leetcode/leetcode/1093-recover-a-tree-from-preorder-traversal/README.md
 create mode 100644 leetcode/leetcode/11-container-with-most-water/11-container-with-most-water.java
 create mode 100644 leetcode/leetcode/11-container-with-most-water/NOTES.md
 create mode 100644 leetcode/leetcode/11-container-with-most-water/README.md
 create mode 100644 leetcode/leetcode/1110-delete-nodes-and-return-forest/1110-delete-nodes-and-return-forest.java
 create mode 100644 leetcode/leetcode/1110-delete-nodes-and-return-forest/NOTES.md
 create mode 100644 leetcode/leetcode/1110-delete-nodes-and-return-forest/README.md
 create mode 100644 leetcode/leetcode/1122-relative-sort-array/1122-relative-sort-array.java
 create mode 100644 leetcode/leetcode/1122-relative-sort-array/NOTES.md
 create mode 100644 leetcode/leetcode/1122-relative-sort-array/README.md
 create mode 100644 leetcode/leetcode/1137-n-th-tribonacci-number/1137-n-th-tribonacci-number.java
 create mode 100644 leetcode/leetcode/1137-n-th-tribonacci-number/NOTES.md
 create mode 100644 leetcode/leetcode/1137-n-th-tribonacci-number/README.md
 create mode 100644 leetcode/leetcode/1143-longest-common-subsequence/1143-longest-common-subsequence.java
 create mode 100644 leetcode/leetcode/1143-longest-common-subsequence/NOTES.md
 create mode 100644 leetcode/leetcode/1143-longest-common-subsequence/README.md
 create mode 100644 leetcode/leetcode/1153-product-sales-analysis-i/README.md
 create mode 100644 leetcode/leetcode/116-populating-next-right-pointers-in-each-node/116-populating-next-right-pointers-in-each-node.java
 create mode 100644 leetcode/leetcode/116-populating-next-right-pointers-in-each-node/NOTES.md
 create mode 100644 leetcode/leetcode/116-populating-next-right-pointers-in-each-node/README.md
 create mode 100644 leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/1160-find-words-that-can-be-formed-by-characters.java
 create mode 100644 leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/NOTES.md
 create mode 100644 leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/README.md
 create mode 100644 leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/1161-maximum-level-sum-of-a-binary-tree.java
 create mode 100644 leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/README.md
 create mode 100644 leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/117-populating-next-right-pointers-in-each-node-ii.java
 create mode 100644 leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/NOTES.md
 create mode 100644 leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/README.md
 create mode 100644 leetcode/leetcode/1170-shortest-common-supersequence/1170-shortest-common-supersequence.java
 create mode 100644 leetcode/leetcode/1170-shortest-common-supersequence/README.md
 create mode 100644 leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/1171-remove-zero-sum-consecutive-nodes-from-linked-list.java
 create mode 100644 leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/NOTES.md
 create mode 100644 leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/README.md
 create mode 100644 leetcode/leetcode/118-pascals-triangle/118-pascals-triangle.java
 create mode 100644 leetcode/leetcode/118-pascals-triangle/NOTES.md
 create mode 100644 leetcode/leetcode/118-pascals-triangle/README.md
 create mode 100644 leetcode/leetcode/1190-reverse-substrings-between-each-pair-of-parentheses/1190-reverse-substrings-between-each-pair-of-parentheses.java
 create mode 100644 leetcode/leetcode/1207-unique-number-of-occurrences/1207-unique-number-of-occurrences.java
 create mode 100644 leetcode/leetcode/1207-unique-number-of-occurrences/NOTES.md
 create mode 100644 leetcode/leetcode/1207-unique-number-of-occurrences/README.md
 create mode 100644 leetcode/leetcode/121-best-time-to-buy-and-sell-stock/121-best-time-to-buy-and-sell-stock.java
 create mode 100644 leetcode/leetcode/121-best-time-to-buy-and-sell-stock/NOTES.md
 create mode 100644 leetcode/leetcode/121-best-time-to-buy-and-sell-stock/README.md
 create mode 100644 leetcode/leetcode/1224-minimum-falling-path-sum-ii/1224-minimum-falling-path-sum-ii.java
 create mode 100644 leetcode/leetcode/1224-minimum-falling-path-sum-ii/README.md
 create mode 100644 leetcode/leetcode/1249-minimum-remove-to-make-valid-parentheses/1249-minimum-remove-to-make-valid-parentheses.java
 create mode 100644 leetcode/leetcode/1249-minimum-remove-to-make-valid-parentheses/README.md
 create mode 100644 leetcode/leetcode/1250-longest-common-subsequence/1250-longest-common-subsequence.java
 create mode 100644 leetcode/leetcode/1250-longest-common-subsequence/README.md
 create mode 100644 leetcode/leetcode/1258-article-views-i/1258-article-views-i.sql
 create mode 100644 leetcode/leetcode/1258-article-views-i/README.md
 create mode 100644 leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/1261-find-elements-in-a-contaminated-binary-tree.java
 create mode 100644 leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/README.md
 create mode 100644 leetcode/leetcode/1266-minimum-time-visiting-all-points/1266-minimum-time-visiting-all-points.java
 create mode 100644 leetcode/leetcode/1266-minimum-time-visiting-all-points/README.md
 create mode 100644 leetcode/leetcode/128-longest-consecutive-sequence/128-longest-consecutive-sequence.java
 create mode 100644 leetcode/leetcode/128-longest-consecutive-sequence/NOTES.md
 create mode 100644 leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/1287-element-appearing-more-than-25-in-sorted-array.java
 create mode 100644 leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/NOTES.md
 create mode 100644 leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/README.md
 create mode 100644 leetcode/leetcode/129-sum-root-to-leaf-numbers/129-sum-root-to-leaf-numbers.java
 create mode 100644 leetcode/leetcode/129-sum-root-to-leaf-numbers/NOTES.md
 create mode 100644 leetcode/leetcode/129-sum-root-to-leaf-numbers/README.md
 create mode 100644 leetcode/leetcode/1291-sequential-digits/1291-sequential-digits.java
 create mode 100644 leetcode/leetcode/1291-sequential-digits/NOTES.md
 create mode 100644 leetcode/leetcode/1291-sequential-digits/README.md
 create mode 100644 leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/1296-divide-array-in-sets-of-k-consecutive-numbers.java
 create mode 100644 leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/NOTES.md
 create mode 100644 leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/README.md
 create mode 100644 leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/1299-replace-elements-with-greatest-element-on-right-side.java
 create mode 100644 leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/NOTES.md
 create mode 100644 leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/README.md
 create mode 100644 leetcode/leetcode/1302-deepest-leaves-sum/1302-deepest-leaves-sum.java
 create mode 100644 leetcode/leetcode/1302-deepest-leaves-sum/NOTES.md
 create mode 100644 leetcode/leetcode/1302-deepest-leaves-sum/README.md
 create mode 100644 leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/1305-all-elements-in-two-binary-search-trees.java
 create mode 100644 leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/NOTES.md
 create mode 100644 leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/README.md
 create mode 100644 leetcode/leetcode/1310-xor-queries-of-a-subarray/1310-xor-queries-of-a-subarray.java
 create mode 100644 leetcode/leetcode/1310-xor-queries-of-a-subarray/README.md
 create mode 100644 leetcode/leetcode/1315-sum-of-nodes-with-even-valued-grandparent/1315-sum-of-nodes-with-even-valued-grandparent.java
 create mode 100644 leetcode/leetcode/1315-sum-of-nodes-with-even-valued-grandparent/NOTES.md
 create mode 100644 leetcode/leetcode/1331-rank-transform-of-an-array/1331-rank-transform-of-an-array.java
 create mode 100644 leetcode/leetcode/1331-rank-transform-of-an-array/NOTES.md
 create mode 100644 leetcode/leetcode/1331-rank-transform-of-an-array/README.md
 create mode 100644 leetcode/leetcode/1335-maximum-candies-allocated-to-k-children/1335-maximum-candies-allocated-to-k-children.java
 create mode 100644 leetcode/leetcode/1335-maximum-candies-allocated-to-k-children/README.md
 create mode 100644 leetcode/leetcode/134-gas-station/134-gas-station.java
 create mode 100644 leetcode/leetcode/134-gas-station/NOTES.md
 create mode 100644 leetcode/leetcode/134-gas-station/README.md
 create mode 100644 leetcode/leetcode/136-single-number/136-single-number.java
 create mode 100644 leetcode/leetcode/136-single-number/NOTES.md
 create mode 100644 leetcode/leetcode/136-single-number/README.md
 create mode 100644 leetcode/leetcode/1367-linked-list-in-binary-tree/1367-linked-list-in-binary-tree.java
 create mode 100644 leetcode/leetcode/1367-linked-list-in-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/1367-linked-list-in-binary-tree/README.md
 create mode 100644 leetcode/leetcode/1371-find-the-longest-substring-containing-vowels-in-even-counts/1371-find-the-longest-substring-containing-vowels-in-even-counts.java
 create mode 100644 leetcode/leetcode/1371-find-the-longest-substring-containing-vowels-in-even-counts/README.md
 create mode 100644 leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/1373-maximum-sum-bst-in-binary-tree.java
 create mode 100644 leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/README.md
 create mode 100644 leetcode/leetcode/13745-606-153-find-minimum-in-rotated-sorted-array/13745-606-153-find-minimum-in-rotated-sorted-array.py
 create mode 100644 leetcode/leetcode/13745-606-153-find-minimum-in-rotated-sorted-array/README.md
 create mode 100644 leetcode/leetcode/138-copy-list-with-random-pointer/138-copy-list-with-random-pointer.java
 create mode 100644 leetcode/leetcode/138-copy-list-with-random-pointer/NOTES.md
 create mode 100644 leetcode/leetcode/138-copy-list-with-random-pointer/README.md
 create mode 100644 leetcode/leetcode/1387-find-elements-in-a-contaminated-binary-tree/1387-find-elements-in-a-contaminated-binary-tree.java
 create mode 100644 leetcode/leetcode/1387-find-elements-in-a-contaminated-binary-tree/README.md
 create mode 100644 leetcode/leetcode/1390-four-divisors/1390-four-divisors.java
 create mode 100644 leetcode/leetcode/1390-four-divisors/NOTES.md
 create mode 100644 leetcode/leetcode/1390-four-divisors/README.md
 create mode 100644 leetcode/leetcode/14-longest-common-prefix/14-longest-common-prefix.java
 create mode 100644 leetcode/leetcode/14-longest-common-prefix/NOTES.md
 create mode 100644 leetcode/leetcode/14-longest-common-prefix/README.md
 create mode 100644 leetcode/leetcode/141-linked-list-cycle/141-linked-list-cycle.java
 create mode 100644 leetcode/leetcode/141-linked-list-cycle/NOTES.md
 create mode 100644 leetcode/leetcode/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k.java
 create mode 100644 leetcode/leetcode/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/NOTES.md
 create mode 100644 leetcode/leetcode/142-linked-list-cycle-ii/142-linked-list-cycle-ii.java
 create mode 100644 leetcode/leetcode/142-linked-list-cycle-ii/NOTES.md
 create mode 100644 leetcode/leetcode/142-linked-list-cycle-ii/README.md
 create mode 100644 leetcode/leetcode/1421-find-numbers-with-even-number-of-digits/1421-find-numbers-with-even-number-of-digits.java
 create mode 100644 leetcode/leetcode/1421-find-numbers-with-even-number-of-digits/README.md
 create mode 100644 leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/1431-kids-with-the-greatest-number-of-candies.java
 create mode 100644 leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/NOTES.md
 create mode 100644 leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/README.md
 create mode 100644 leetcode/leetcode/1441-build-an-array-with-stack-operations/1441-build-an-array-with-stack-operations.java
 create mode 100644 leetcode/leetcode/1441-build-an-array-with-stack-operations/NOTES.md
 create mode 100644 leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/1443-minimum-time-to-collect-all-apples-in-a-tree.java
 create mode 100644 leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/NOTES.md
 create mode 100644 leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/README.md
 create mode 100644 leetcode/leetcode/1448-count-good-nodes-in-binary-tree/1448-count-good-nodes-in-binary-tree.java
 create mode 100644 leetcode/leetcode/1448-count-good-nodes-in-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/1448-count-good-nodes-in-binary-tree/README.md
 create mode 100644 leetcode/leetcode/1451-rearrange-words-in-a-sentence/1451-rearrange-words-in-a-sentence.java
 create mode 100644 leetcode/leetcode/1451-rearrange-words-in-a-sentence/NOTES.md
 create mode 100644 leetcode/leetcode/1451-rearrange-words-in-a-sentence/README.md
 create mode 100644 leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/1456-maximum-number-of-vowels-in-a-substring-of-given-length.java
 create mode 100644 leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/NOTES.md
 create mode 100644 leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/README.md
 create mode 100644 leetcode/leetcode/1460-number-of-substrings-containing-all-three-characters/1460-number-of-substrings-containing-all-three-characters.java
 create mode 100644 leetcode/leetcode/1460-number-of-substrings-containing-all-three-characters/README.md
 create mode 100644 leetcode/leetcode/147-insertion-sort-list/147-insertion-sort-list.java
 create mode 100644 leetcode/leetcode/147-insertion-sort-list/NOTES.md
 create mode 100644 leetcode/leetcode/147-insertion-sort-list/README.md
 create mode 100644 leetcode/leetcode/1476-subrectangle-queries/1476-subrectangle-queries.java
 create mode 100644 leetcode/leetcode/1476-subrectangle-queries/NOTES.md
 create mode 100644 leetcode/leetcode/1476-subrectangle-queries/README.md
 create mode 100644 leetcode/leetcode/148-sort-list/148-sort-list.java
 create mode 100644 leetcode/leetcode/148-sort-list/NOTES.md
 create mode 100644 leetcode/leetcode/148-sort-list/README.md
 create mode 100644 leetcode/leetcode/1480-running-sum-of-1d-array/1480-running-sum-of-1d-array.java
 create mode 100644 leetcode/leetcode/1480-running-sum-of-1d-array/NOTES.md
 create mode 100644 leetcode/leetcode/1480-running-sum-of-1d-array/README.md
 create mode 100644 leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/1491-average-salary-excluding-the-minimum-and-maximum-salary.java
 create mode 100644 leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/NOTES.md
 create mode 100644 leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/README.md
 create mode 100644 leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/1493-longest-subarray-of-1s-after-deleting-one-element.java
 create mode 100644 leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/NOTES.md
 create mode 100644 leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/README.md
 create mode 100644 leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/1497-check-if-array-pairs-are-divisible-by-k.java
 create mode 100644 leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/NOTES.md
 create mode 100644 leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/README.md
 create mode 100644 leetcode/leetcode/150-evaluate-reverse-polish-notation/150-evaluate-reverse-polish-notation.java
 create mode 100644 leetcode/leetcode/150-evaluate-reverse-polish-notation/NOTES.md
 create mode 100644 leetcode/leetcode/150-evaluate-reverse-polish-notation/README.md
 create mode 100644 leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/1508-range-sum-of-sorted-subarray-sums.java
 create mode 100644 leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/NOTES.md
 create mode 100644 leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/README.md
 create mode 100644 leetcode/leetcode/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves.java
 create mode 100644 leetcode/leetcode/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves/NOTES.md
 create mode 100644 leetcode/leetcode/1509-replace-employee-id-with-the-unique-identifier/1509-replace-employee-id-with-the-unique-identifier.sql
 create mode 100644 leetcode/leetcode/1509-replace-employee-id-with-the-unique-identifier/README.md
 create mode 100644 leetcode/leetcode/1518-water-bottles/1518-water-bottles.java
 create mode 100644 leetcode/leetcode/1518-water-bottles/NOTES.md
 create mode 100644 leetcode/leetcode/1518-water-bottles/README.md
 create mode 100644 leetcode/leetcode/1519-number-of-nodes-in-the-sub-tree-with-the-same-label/1519-number-of-nodes-in-the-sub-tree-with-the-same-label.java
 create mode 100644 leetcode/leetcode/1519-number-of-nodes-in-the-sub-tree-with-the-same-label/NOTES.md
 create mode 100644 leetcode/leetcode/155-min-stack/155-min-stack.java
 create mode 100644 leetcode/leetcode/155-min-stack/NOTES.md
 create mode 100644 leetcode/leetcode/155-min-stack/README.md
 create mode 100644 leetcode/leetcode/1550-three-consecutive-odds/1550-three-consecutive-odds.java
 create mode 100644 leetcode/leetcode/1550-three-consecutive-odds/NOTES.md
 create mode 100644 leetcode/leetcode/1550-three-consecutive-odds/README.md
 create mode 100644 leetcode/leetcode/1582-special-positions-in-a-binary-matrix/1582-special-positions-in-a-binary-matrix.java
 create mode 100644 leetcode/leetcode/1582-special-positions-in-a-binary-matrix/NOTES.md
 create mode 100644 leetcode/leetcode/1582-special-positions-in-a-binary-matrix/README.md
 create mode 100644 leetcode/leetcode/1598-crawler-log-folder/1598-crawler-log-folder.java
 create mode 100644 leetcode/leetcode/1598-crawler-log-folder/NOTES.md
 create mode 100644 leetcode/leetcode/1598-crawler-log-folder/README.md
 create mode 100644 leetcode/leetcode/160-intersection-of-two-linked-lists/160-intersection-of-two-linked-lists.java
 create mode 100644 leetcode/leetcode/160-intersection-of-two-linked-lists/NOTES.md
 create mode 100644 leetcode/leetcode/1609-even-odd-tree/1609-even-odd-tree.java
 create mode 100644 leetcode/leetcode/1609-even-odd-tree/NOTES.md
 create mode 100644 leetcode/leetcode/1609-even-odd-tree/README.md
 create mode 100644 leetcode/leetcode/162-find-peak-element/162-find-peak-element.java
 create mode 100644 leetcode/leetcode/162-find-peak-element/NOTES.md
 create mode 100644 leetcode/leetcode/162-find-peak-element/README.md
 create mode 100644 leetcode/leetcode/1631-number-of-sub-arrays-with-odd-sum/1631-number-of-sub-arrays-with-odd-sum.java
 create mode 100644 leetcode/leetcode/1631-number-of-sub-arrays-with-odd-sum/README.md
 create mode 100644 leetcode/leetcode/1642-water-bottles/1642-water-bottles.java
 create mode 100644 leetcode/leetcode/1642-water-bottles/README.md
 create mode 100644 leetcode/leetcode/1652-minimum-suffix-flips/1652-minimum-suffix-flips.py
 create mode 100644 leetcode/leetcode/1652-minimum-suffix-flips/README.md
 create mode 100644 leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/1662-check-if-two-string-arrays-are-equivalent.java
 create mode 100644 leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/NOTES.md
 create mode 100644 leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/README.md
 create mode 100644 leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/167-two-sum-ii-input-array-is-sorted.java
 create mode 100644 leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/NOTES.md
 create mode 100644 leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/README.md
 create mode 100644 leetcode/leetcode/1672-richest-customer-wealth/1672-richest-customer-wealth.java
 create mode 100644 leetcode/leetcode/1672-richest-customer-wealth/NOTES.md
 create mode 100644 leetcode/leetcode/1672-richest-customer-wealth/README.md
 create mode 100644 leetcode/leetcode/1679-max-number-of-k-sum-pairs/1679-max-number-of-k-sum-pairs.java
 create mode 100644 leetcode/leetcode/1679-max-number-of-k-sum-pairs/NOTES.md
 create mode 100644 leetcode/leetcode/1679-max-number-of-k-sum-pairs/README.md
 create mode 100644 leetcode/leetcode/1684-count-the-number-of-consistent-strings/1684-count-the-number-of-consistent-strings.java
 create mode 100644 leetcode/leetcode/1684-count-the-number-of-consistent-strings/NOTES.md
 create mode 100644 leetcode/leetcode/1684-count-the-number-of-consistent-strings/README.md
 create mode 100644 leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/1689-partitioning-into-minimum-number-of-deci-binary-numbers.java
 create mode 100644 leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/NOTES.md
 create mode 100644 leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/README.md
 create mode 100644 leetcode/leetcode/169-majority-element/169-majority-element.java
 create mode 100644 leetcode/leetcode/169-majority-element/NOTES.md
 create mode 100644 leetcode/leetcode/169-majority-element/README.md
 create mode 100644 leetcode/leetcode/17-letter-combinations-of-a-phone-number/17-letter-combinations-of-a-phone-number.java
 create mode 100644 leetcode/leetcode/17-letter-combinations-of-a-phone-number/NOTES.md
 create mode 100644 leetcode/leetcode/17-letter-combinations-of-a-phone-number/README.md
 create mode 100644 leetcode/leetcode/1701-average-waiting-time/1701-average-waiting-time.java
 create mode 100644 leetcode/leetcode/1701-average-waiting-time/NOTES.md
 create mode 100644 leetcode/leetcode/1701-average-waiting-time/README.md
 create mode 100644 leetcode/leetcode/1710-maximum-units-on-a-truck/1710-maximum-units-on-a-truck.java
 create mode 100644 leetcode/leetcode/1710-maximum-units-on-a-truck/NOTES.md
 create mode 100644 leetcode/leetcode/1710-maximum-units-on-a-truck/README.md
 create mode 100644 leetcode/leetcode/1717-maximum-score-from-removing-substrings/1717-maximum-score-from-removing-substrings.java
 create mode 100644 leetcode/leetcode/1717-maximum-score-from-removing-substrings/README.md
 create mode 100644 leetcode/leetcode/172-factorial-trailing-zeroes/172-factorial-trailing-zeroes.java
 create mode 100644 leetcode/leetcode/172-factorial-trailing-zeroes/NOTES.md
 create mode 100644 leetcode/leetcode/172-factorial-trailing-zeroes/README.md
 create mode 100644 leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/1721-swapping-nodes-in-a-linked-list.java
 create mode 100644 leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/NOTES.md
 create mode 100644 leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/README.md
 create mode 100644 leetcode/leetcode/1724-customer-who-visited-but-did-not-make-any-transactions/1724-customer-who-visited-but-did-not-make-any-transactions.sql
 create mode 100644 leetcode/leetcode/1724-customer-who-visited-but-did-not-make-any-transactions/README.md
 create mode 100644 leetcode/leetcode/173-binary-search-tree-iterator/173-binary-search-tree-iterator.java
 create mode 100644 leetcode/leetcode/173-binary-search-tree-iterator/NOTES.md
 create mode 100644 leetcode/leetcode/1732-find-the-highest-altitude/1732-find-the-highest-altitude.java
 create mode 100644 leetcode/leetcode/1732-find-the-highest-altitude/NOTES.md
 create mode 100644 leetcode/leetcode/1732-find-the-highest-altitude/README.md
 create mode 100644 leetcode/leetcode/1768-merge-strings-alternately/1768-merge-strings-alternately.java
 create mode 100644 leetcode/leetcode/1768-merge-strings-alternately/NOTES.md
 create mode 100644 leetcode/leetcode/1768-merge-strings-alternately/README.md
 create mode 100644 leetcode/leetcode/1791-find-center-of-star-graph/1791-find-center-of-star-graph.java
 create mode 100644 leetcode/leetcode/1791-find-center-of-star-graph/README.md
 create mode 100644 leetcode/leetcode/1817-finding-the-users-active-minutes/1817-finding-the-users-active-minutes.java
 create mode 100644 leetcode/leetcode/1817-finding-the-users-active-minutes/NOTES.md
 create mode 100644 leetcode/leetcode/1817-finding-the-users-active-minutes/README.md
 create mode 100644 leetcode/leetcode/182-duplicate-emails/182-duplicate-emails.sql
 create mode 100644 leetcode/leetcode/182-duplicate-emails/NOTES.md
 create mode 100644 leetcode/leetcode/182-duplicate-emails/README.md
 create mode 100644 leetcode/leetcode/1822-sign-of-the-product-of-an-array/1822-sign-of-the-product-of-an-array.java
 create mode 100644 leetcode/leetcode/1822-sign-of-the-product-of-an-array/NOTES.md
 create mode 100644 leetcode/leetcode/1822-sign-of-the-product-of-an-array/README.md
 create mode 100644 leetcode/leetcode/1823-find-the-winner-of-the-circular-game/1823-find-the-winner-of-the-circular-game.java
 create mode 100644 leetcode/leetcode/1823-find-the-winner-of-the-circular-game/NOTES.md
 create mode 100644 leetcode/leetcode/1823-find-the-winner-of-the-circular-game/README.md
 create mode 100644 leetcode/leetcode/1827-invalid-tweets/1827-invalid-tweets.sql
 create mode 100644 leetcode/leetcode/1827-invalid-tweets/README.md
 create mode 100644 leetcode/leetcode/1833-maximum-ice-cream-bars/1833-maximum-ice-cream-bars.java
 create mode 100644 leetcode/leetcode/1833-maximum-ice-cream-bars/NOTES.md
 create mode 100644 leetcode/leetcode/1833-maximum-ice-cream-bars/README.md
 create mode 100644 leetcode/leetcode/1845-seat-reservation-manager/1845-seat-reservation-manager.java
 create mode 100644 leetcode/leetcode/1845-seat-reservation-manager/NOTES.md
 create mode 100644 leetcode/leetcode/1845-seat-reservation-manager/README.md
 create mode 100644 leetcode/leetcode/1846-maximum-element-after-decreasing-and-rearranging/1846-maximum-element-after-decreasing-and-rearranging.java
 create mode 100644 leetcode/leetcode/1846-maximum-element-after-decreasing-and-rearranging/README.md
 create mode 100644 leetcode/leetcode/1849-maximum-absolute-sum-of-any-subarray/1849-maximum-absolute-sum-of-any-subarray.java
 create mode 100644 leetcode/leetcode/1849-maximum-absolute-sum-of-any-subarray/README.md
 create mode 100644 leetcode/leetcode/1889-check-if-number-is-a-sum-of-powers-of-three/1889-check-if-number-is-a-sum-of-powers-of-three.java
 create mode 100644 leetcode/leetcode/1889-check-if-number-is-a-sum-of-powers-of-three/README.md
 create mode 100644 leetcode/leetcode/19-remove-nth-node-from-end-of-list/19-remove-nth-node-from-end-of-list.java
 create mode 100644 leetcode/leetcode/19-remove-nth-node-from-end-of-list/NOTES.md
 create mode 100644 leetcode/leetcode/1908-recyclable-and-low-fat-products/1908-recyclable-and-low-fat-products.sql
 create mode 100644 leetcode/leetcode/1908-recyclable-and-low-fat-products/README.md
 create mode 100644 leetcode/leetcode/1920-build-array-from-permutation/1920-build-array-from-permutation.py
 create mode 100644 leetcode/leetcode/1920-build-array-from-permutation/README.md
 create mode 100644 leetcode/leetcode/1945-sum-of-digits-of-string-after-convert/1945-sum-of-digits-of-string-after-convert.java
 create mode 100644 leetcode/leetcode/1945-sum-of-digits-of-string-after-convert/README.md
 create mode 100644 leetcode/leetcode/1979-find-greatest-common-divisor-of-array/1979-find-greatest-common-divisor-of-array.java
 create mode 100644 leetcode/leetcode/1979-find-greatest-common-divisor-of-array/NOTES.md
 create mode 100644 leetcode/leetcode/1979-find-greatest-common-divisor-of-array/README.md
 create mode 100644 leetcode/leetcode/198-house-robber/198-house-robber.java
 create mode 100644 leetcode/leetcode/198-house-robber/NOTES.md
 create mode 100644 leetcode/leetcode/198-house-robber/README.md
 create mode 100644 leetcode/leetcode/1983-maximum-population-year/1983-maximum-population-year.java
 create mode 100644 leetcode/leetcode/1983-maximum-population-year/README.md
 create mode 100644 leetcode/leetcode/199-binary-tree-right-side-view/199-binary-tree-right-side-view.java
 create mode 100644 leetcode/leetcode/199-binary-tree-right-side-view/NOTES.md
 create mode 100644 leetcode/leetcode/199-binary-tree-right-side-view/README.md
 create mode 100644 leetcode/leetcode/1991-find-the-middle-index-in-array/1991-find-the-middle-index-in-array.java
 create mode 100644 leetcode/leetcode/1991-find-the-middle-index-in-array/NOTES.md
 create mode 100644 leetcode/leetcode/1991-find-the-middle-index-in-array/README.md
 create mode 100644 leetcode/leetcode/2-add-two-numbers/2-add-two-numbers.java
 create mode 100644 leetcode/leetcode/2-add-two-numbers/NOTES.md
 create mode 100644 leetcode/leetcode/20-valid-parentheses/20-valid-parentheses.java
 create mode 100644 leetcode/leetcode/20-valid-parentheses/NOTES.md
 create mode 100644 leetcode/leetcode/20-valid-parentheses/README.md
 create mode 100644 leetcode/leetcode/2000-reverse-prefix-of-word/2000-reverse-prefix-of-word.java
 create mode 100644 leetcode/leetcode/2000-reverse-prefix-of-word/NOTES.md
 create mode 100644 leetcode/leetcode/2000-reverse-prefix-of-word/README.md
 create mode 100644 leetcode/leetcode/202-happy-number/202-happy-number.java
 create mode 100644 leetcode/leetcode/202-happy-number/NOTES.md
 create mode 100644 leetcode/leetcode/2021-remove-all-occurrences-of-a-substring/2021-remove-all-occurrences-of-a-substring.java
 create mode 100644 leetcode/leetcode/2021-remove-all-occurrences-of-a-substring/README.md
 create mode 100644 leetcode/leetcode/2048-build-array-from-permutation/2048-build-array-from-permutation.java
 create mode 100644 leetcode/leetcode/2048-build-array-from-permutation/README.md
 create mode 100644 leetcode/leetcode/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points.java
 create mode 100644 leetcode/leetcode/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points/README.md
 create mode 100644 leetcode/leetcode/2085-count-common-words-with-one-occurrence/2085-count-common-words-with-one-occurrence.java
 create mode 100644 leetcode/leetcode/2085-count-common-words-with-one-occurrence/README.md
 create mode 100644 leetcode/leetcode/2089-find-target-indices-after-sorting-array/2089-find-target-indices-after-sorting-array.java
 create mode 100644 leetcode/leetcode/2089-find-target-indices-after-sorting-array/NOTES.md
 create mode 100644 leetcode/leetcode/2090-number-of-ways-to-arrive-at-destination/2090-number-of-ways-to-arrive-at-destination.java
 create mode 100644 leetcode/leetcode/2090-number-of-ways-to-arrive-at-destination/README.md
 create mode 100644 leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/2091-removing-minimum-and-maximum-from-array.java
 create mode 100644 leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/NOTES.md
 create mode 100644 leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/README.md
 create mode 100644 leetcode/leetcode/21-merge-two-sorted-lists/21-merge-two-sorted-lists.java
 create mode 100644 leetcode/leetcode/21-merge-two-sorted-lists/NOTES.md
 create mode 100644 leetcode/leetcode/2107-find-unique-binary-string/2107-find-unique-binary-string.java
 create mode 100644 leetcode/leetcode/2107-find-unique-binary-string/README.md
 create mode 100644 leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/2131-longest-palindrome-by-concatenating-two-letter-words.java
 create mode 100644 leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/NOTES.md
 create mode 100644 leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/README.md
 create mode 100644 leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/2133-check-if-every-row-and-column-contains-all-numbers.java
 create mode 100644 leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/NOTES.md
 create mode 100644 leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/README.md
 create mode 100644 leetcode/leetcode/2138-divide-a-string-into-groups-of-size-k/2138-divide-a-string-into-groups-of-size-k.java
 create mode 100644 leetcode/leetcode/2138-divide-a-string-into-groups-of-size-k/README.md
 create mode 100644 leetcode/leetcode/2139-minimum-moves-to-reach-target-score/2139-minimum-moves-to-reach-target-score.java
 create mode 100644 leetcode/leetcode/2139-minimum-moves-to-reach-target-score/NOTES.md
 create mode 100644 leetcode/leetcode/2139-minimum-moves-to-reach-target-score/README.md
 create mode 100644 leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/2148-count-elements-with-strictly-smaller-and-greater-elements.java
 create mode 100644 leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/NOTES.md
 create mode 100644 leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/README.md
 create mode 100644 leetcode/leetcode/2149-rearrange-array-elements-by-sign/2149-rearrange-array-elements-by-sign.java
 create mode 100644 leetcode/leetcode/2149-rearrange-array-elements-by-sign/NOTES.md
 create mode 100644 leetcode/leetcode/2149-rearrange-array-elements-by-sign/README.md
 create mode 100644 leetcode/leetcode/215-kth-largest-element-in-an-array/215-kth-largest-element-in-an-array.java
 create mode 100644 leetcode/leetcode/215-kth-largest-element-in-an-array/NOTES.md
 create mode 100644 leetcode/leetcode/215-kth-largest-element-in-an-array/README.md
 create mode 100644 leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/2150-find-all-lonely-numbers-in-the-array.java
 create mode 100644 leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/NOTES.md
 create mode 100644 leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/README.md
 create mode 100644 leetcode/leetcode/2154-keep-multiplying-found-values-by-two/2154-keep-multiplying-found-values-by-two.java
 create mode 100644 leetcode/leetcode/2154-keep-multiplying-found-values-by-two/README.md
 create mode 100644 leetcode/leetcode/2160-minimum-operations-to-make-a-uni-value-grid/2160-minimum-operations-to-make-a-uni-value-grid.java
 create mode 100644 leetcode/leetcode/2160-minimum-operations-to-make-a-uni-value-grid/README.md
 create mode 100644 leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/2160-minimum-sum-of-four-digit-number-after-splitting-digits.java
 create mode 100644 leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/NOTES.md
 create mode 100644 leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/README.md
 create mode 100644 leetcode/leetcode/2161-partition-array-according-to-given-pivot/2161-partition-array-according-to-given-pivot.java
 create mode 100644 leetcode/leetcode/2161-partition-array-according-to-given-pivot/README.md
 create mode 100644 leetcode/leetcode/2164-sort-even-and-odd-indices-independently/2164-sort-even-and-odd-indices-independently.java
 create mode 100644 leetcode/leetcode/2164-sort-even-and-odd-indices-independently/NOTES.md
 create mode 100644 leetcode/leetcode/2164-sort-even-and-odd-indices-independently/README.md
 create mode 100644 leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/2165-smallest-value-of-the-rearranged-number.java
 create mode 100644 leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/NOTES.md
 create mode 100644 leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/README.md
 create mode 100644 leetcode/leetcode/2166-design-bitset/2166-design-bitset.java
 create mode 100644 leetcode/leetcode/2166-design-bitset/NOTES.md
 create mode 100644 leetcode/leetcode/2166-design-bitset/README.md
 create mode 100644 leetcode/leetcode/2174-next-greater-numerically-balanced-number/2174-next-greater-numerically-balanced-number.java
 create mode 100644 leetcode/leetcode/2174-next-greater-numerically-balanced-number/README.md
 create mode 100644 leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/2177-find-three-consecutive-integers-that-sum-to-a-given-number.java
 create mode 100644 leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/NOTES.md
 create mode 100644 leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/README.md
 create mode 100644 leetcode/leetcode/2180-count-integers-with-even-digit-sum/2180-count-integers-with-even-digit-sum.java
 create mode 100644 leetcode/leetcode/2180-count-integers-with-even-digit-sum/README.md
 create mode 100644 leetcode/leetcode/2181-merge-nodes-in-between-zeros/2181-merge-nodes-in-between-zeros.java
 create mode 100644 leetcode/leetcode/2181-merge-nodes-in-between-zeros/NOTES.md
 create mode 100644 leetcode/leetcode/2181-merge-nodes-in-between-zeros/README.md
 create mode 100644 leetcode/leetcode/2183-count-array-pairs-divisible-by-k/2183-count-array-pairs-divisible-by-k.java
 create mode 100644 leetcode/leetcode/2183-count-array-pairs-divisible-by-k/NOTES.md
 create mode 100644 leetcode/leetcode/2183-count-array-pairs-divisible-by-k/README.md
 create mode 100644 leetcode/leetcode/2190-most-frequent-number-following-key-in-an-array/2190-most-frequent-number-following-key-in-an-array.java
 create mode 100644 leetcode/leetcode/2190-most-frequent-number-following-key-in-an-array/README.md
 create mode 100644 leetcode/leetcode/2215-find-the-difference-of-two-arrays/2215-find-the-difference-of-two-arrays.java
 create mode 100644 leetcode/leetcode/2215-find-the-difference-of-two-arrays/NOTES.md
 create mode 100644 leetcode/leetcode/2215-find-the-difference-of-two-arrays/README.md
 create mode 100644 leetcode/leetcode/2216-delete-the-middle-node-of-a-linked-list/2216-delete-the-middle-node-of-a-linked-list.java
 create mode 100644 leetcode/leetcode/2216-delete-the-middle-node-of-a-linked-list/README.md
 create mode 100644 leetcode/leetcode/2220-find-all-possible-recipes-from-given-supplies/2220-find-all-possible-recipes-from-given-supplies.java
 create mode 100644 leetcode/leetcode/2220-find-all-possible-recipes-from-given-supplies/README.md
 create mode 100644 leetcode/leetcode/2220-minimum-bit-flips-to-convert-number/2220-minimum-bit-flips-to-convert-number.java
 create mode 100644 leetcode/leetcode/2220-minimum-bit-flips-to-convert-number/README.md
 create mode 100644 leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/2244-minimum-rounds-to-complete-all-tasks.java
 create mode 100644 leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/NOTES.md
 create mode 100644 leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/README.md
 create mode 100644 leetcode/leetcode/2246-longest-path-with-different-adjacent-characters/2246-longest-path-with-different-adjacent-characters.java
 create mode 100644 leetcode/leetcode/2246-longest-path-with-different-adjacent-characters/README.md
 create mode 100644 leetcode/leetcode/225-implement-stack-using-queues/225-implement-stack-using-queues.java
 create mode 100644 leetcode/leetcode/225-implement-stack-using-queues/NOTES.md
 create mode 100644 leetcode/leetcode/225-implement-stack-using-queues/README.md
 create mode 100644 leetcode/leetcode/2255-minimum-swaps-to-group-all-1s-together-ii/2255-minimum-swaps-to-group-all-1s-together-ii.java
 create mode 100644 leetcode/leetcode/2255-minimum-swaps-to-group-all-1s-together-ii/README.md
 create mode 100644 leetcode/leetcode/2260-divide-a-string-into-groups-of-size-k/2260-divide-a-string-into-groups-of-size-k.java
 create mode 100644 leetcode/leetcode/2260-divide-a-string-into-groups-of-size-k/README.md
 create mode 100644 leetcode/leetcode/2264-largest-3-same-digit-number-in-string/2264-largest-3-same-digit-number-in-string.java
 create mode 100644 leetcode/leetcode/2264-largest-3-same-digit-number-in-string/NOTES.md
 create mode 100644 leetcode/leetcode/2264-largest-3-same-digit-number-in-string/README.md
 create mode 100644 leetcode/leetcode/2265-partition-array-according-to-given-pivot/2265-partition-array-according-to-given-pivot.java
 create mode 100644 leetcode/leetcode/2265-partition-array-according-to-given-pivot/README.md
 create mode 100644 leetcode/leetcode/228-summary-ranges/228-summary-ranges.java
 create mode 100644 leetcode/leetcode/228-summary-ranges/NOTES.md
 create mode 100644 leetcode/leetcode/228-summary-ranges/README.md
 create mode 100644 leetcode/leetcode/23-merge-k-sorted-lists/23-merge-k-sorted-lists.java
 create mode 100644 leetcode/leetcode/23-merge-k-sorted-lists/NOTES.md
 create mode 100644 leetcode/leetcode/23-merge-k-sorted-lists/README.md
 create mode 100644 leetcode/leetcode/230-kth-smallest-element-in-a-bst/230-kth-smallest-element-in-a-bst.java
 create mode 100644 leetcode/leetcode/230-kth-smallest-element-in-a-bst/NOTES.md
 create mode 100644 leetcode/leetcode/2307-replace-non-coprime-numbers-in-array/2307-replace-non-coprime-numbers-in-array.py
 create mode 100644 leetcode/leetcode/2307-replace-non-coprime-numbers-in-array/README.md
 create mode 100644 leetcode/leetcode/2308-divide-array-into-equal-pairs/2308-divide-array-into-equal-pairs.java
 create mode 100644 leetcode/leetcode/2308-divide-array-into-equal-pairs/README.md
 create mode 100644 leetcode/leetcode/232-implement-queue-using-stacks/232-implement-queue-using-stacks.java
 create mode 100644 leetcode/leetcode/232-implement-queue-using-stacks/NOTES.md
 create mode 100644 leetcode/leetcode/232-implement-queue-using-stacks/README.md
 create mode 100644 leetcode/leetcode/2324-find-triangular-sum-of-an-array/2324-find-triangular-sum-of-an-array.java
 create mode 100644 leetcode/leetcode/2324-find-triangular-sum-of-an-array/README.md
 create mode 100644 leetcode/leetcode/234-palindrome-linked-list/README.md
 create mode 100644 leetcode/leetcode/2352-equal-row-and-column-pairs/2352-equal-row-and-column-pairs.java
 create mode 100644 leetcode/leetcode/2352-equal-row-and-column-pairs/NOTES.md
 create mode 100644 leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/236-lowest-common-ancestor-of-a-binary-tree.java
 create mode 100644 leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/README.md
 create mode 100644 leetcode/leetcode/238-product-of-array-except-self/238-product-of-array-except-self.java
 create mode 100644 leetcode/leetcode/238-product-of-array-except-self/NOTES.md
 create mode 100644 leetcode/leetcode/238-product-of-array-except-self/README.md
 create mode 100644 leetcode/leetcode/2390-removing-stars-from-a-string/2390-removing-stars-from-a-string.java
 create mode 100644 leetcode/leetcode/2390-removing-stars-from-a-string/NOTES.md
 create mode 100644 leetcode/leetcode/2390-removing-stars-from-a-string/README.md
 create mode 100644 leetcode/leetcode/2394-count-subarrays-with-score-less-than-k/2394-count-subarrays-with-score-less-than-k.java
 create mode 100644 leetcode/leetcode/2394-count-subarrays-with-score-less-than-k/README.md
 create mode 100644 leetcode/leetcode/24-swap-nodes-in-pairs/24-swap-nodes-in-pairs.java
 create mode 100644 leetcode/leetcode/24-swap-nodes-in-pairs/README.md
 create mode 100644 leetcode/leetcode/240-search-a-2d-matrix-ii/240-search-a-2d-matrix-ii.java
 create mode 100644 leetcode/leetcode/240-search-a-2d-matrix-ii/NOTES.md
 create mode 100644 leetcode/leetcode/240-search-a-2d-matrix-ii/README.md
 create mode 100644 leetcode/leetcode/2405-optimal-partition-of-string/2405-optimal-partition-of-string.java
 create mode 100644 leetcode/leetcode/2405-optimal-partition-of-string/NOTES.md
 create mode 100644 leetcode/leetcode/2405-optimal-partition-of-string/README.md
 create mode 100644 leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/2419-longest-subarray-with-maximum-bitwise-and.java
 create mode 100644 leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/NOTES.md
 create mode 100644 leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/README.md
 create mode 100644 leetcode/leetcode/2421-number-of-good-paths/2421-number-of-good-paths.java
 create mode 100644 leetcode/leetcode/2421-number-of-good-paths/README.md
 create mode 100644 leetcode/leetcode/2427-first-letter-to-appear-twice/2427-first-letter-to-appear-twice.java
 create mode 100644 leetcode/leetcode/2427-first-letter-to-appear-twice/README.md
 create mode 100644 leetcode/leetcode/2429-design-a-food-rating-system/2429-design-a-food-rating-system.java
 create mode 100644 leetcode/leetcode/2429-design-a-food-rating-system/README.md
 create mode 100644 leetcode/leetcode/2448-count-number-of-bad-pairs/2448-count-number-of-bad-pairs.java
 create mode 100644 leetcode/leetcode/2448-count-number-of-bad-pairs/README.md
 create mode 100644 leetcode/leetcode/2461-amount-of-time-for-binary-tree-to-be-infected/2461-amount-of-time-for-binary-tree-to-be-infected.java
 create mode 100644 leetcode/leetcode/2461-amount-of-time-for-binary-tree-to-be-infected/README.md
 create mode 100644 leetcode/leetcode/2463-minimum-recolors-to-get-k-consecutive-black-blocks/2463-minimum-recolors-to-get-k-consecutive-black-blocks.java
 create mode 100644 leetcode/leetcode/2463-minimum-recolors-to-get-k-consecutive-black-blocks/README.md
 create mode 100644 leetcode/leetcode/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.java
 create mode 100644 leetcode/leetcode/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level/README.md
 create mode 100644 leetcode/leetcode/2478-longest-nice-subarray/2478-longest-nice-subarray.java
 create mode 100644 leetcode/leetcode/2478-longest-nice-subarray/README.md
 create mode 100644 leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/2482-difference-between-ones-and-zeros-in-row-and-column.java
 create mode 100644 leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/NOTES.md
 create mode 100644 leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/README.md
 create mode 100644 leetcode/leetcode/2487-remove-nodes-from-linked-list/2487-remove-nodes-from-linked-list.java
 create mode 100644 leetcode/leetcode/2487-remove-nodes-from-linked-list/NOTES.md
 create mode 100644 leetcode/leetcode/2487-remove-nodes-from-linked-list/README.md
 create mode 100644 leetcode/leetcode/2493-reverse-odd-levels-of-binary-tree/2493-reverse-odd-levels-of-binary-tree.java
 create mode 100644 leetcode/leetcode/2493-reverse-odd-levels-of-binary-tree/README.md
 create mode 100644 leetcode/leetcode/2551-apply-operations-to-an-array/2551-apply-operations-to-an-array.java
 create mode 100644 leetcode/leetcode/2551-apply-operations-to-an-array/README.md
 create mode 100644 leetcode/leetcode/2564-most-profitable-path-in-a-tree/2564-most-profitable-path-in-a-tree.java
 create mode 100644 leetcode/leetcode/2564-most-profitable-path-in-a-tree/README.md
 create mode 100644 leetcode/leetcode/258-add-digits/258-add-digits.java
 create mode 100644 leetcode/leetcode/258-add-digits/README.md
 create mode 100644 leetcode/leetcode/2582-pass-the-pillow/2582-pass-the-pillow.java
 create mode 100644 leetcode/leetcode/2582-pass-the-pillow/NOTES.md
 create mode 100644 leetcode/leetcode/2582-pass-the-pillow/README.md
 create mode 100644 leetcode/leetcode/2588-maximum-number-of-points-from-grid-queries/2588-maximum-number-of-points-from-grid-queries.java
 create mode 100644 leetcode/leetcode/2588-maximum-number-of-points-from-grid-queries/README.md
 create mode 100644 leetcode/leetcode/2610-closest-prime-numbers-in-range/2610-closest-prime-numbers-in-range.java
 create mode 100644 leetcode/leetcode/2610-closest-prime-numbers-in-range/README.md
 create mode 100644 leetcode/leetcode/2614-maximum-count-of-positive-integer-and-negative-integer/2614-maximum-count-of-positive-integer-and-negative-integer.java
 create mode 100644 leetcode/leetcode/2614-maximum-count-of-positive-integer-and-negative-integer/README.md
 create mode 100644 leetcode/leetcode/263-ugly-number/263-ugly-number.java
 create mode 100644 leetcode/leetcode/263-ugly-number/NOTES.md
 create mode 100644 leetcode/leetcode/263-ugly-number/README.md
 create mode 100644 leetcode/leetcode/2649-count-total-number-of-colored-cells/2649-count-total-number-of-colored-cells.java
 create mode 100644 leetcode/leetcode/2649-count-total-number-of-colored-cells/README.md
 create mode 100644 leetcode/leetcode/2665-minimum-time-to-repair-cars/2665-minimum-time-to-repair-cars.java
 create mode 100644 leetcode/leetcode/2665-minimum-time-to-repair-cars/README.md
 create mode 100644 leetcode/leetcode/2681-put-marbles-in-bags/2681-put-marbles-in-bags.java
 create mode 100644 leetcode/leetcode/2681-put-marbles-in-bags/README.md
 create mode 100644 leetcode/leetcode/2690-house-robber-iv/2690-house-robber-iv.java
 create mode 100644 leetcode/leetcode/2690-house-robber-iv/README.md
 create mode 100644 leetcode/leetcode/2707-extra-characters-in-a-string/2707-extra-characters-in-a-string.java
 create mode 100644 leetcode/leetcode/2707-extra-characters-in-a-string/README.md
 create mode 100644 leetcode/leetcode/2707-merge-two-2d-arrays-by-summing-values/2707-merge-two-2d-arrays-by-summing-values.java
 create mode 100644 leetcode/leetcode/2707-merge-two-2d-arrays-by-summing-values/README.md
 create mode 100644 leetcode/leetcode/2751-robot-collisions/2751-robot-collisions.java
 create mode 100644 leetcode/leetcode/2751-robot-collisions/NOTES.md
 create mode 100644 leetcode/leetcode/279-perfect-squares/279-perfect-squares.java
 create mode 100644 leetcode/leetcode/279-perfect-squares/NOTES.md
 create mode 100644 leetcode/leetcode/2793-count-the-number-of-complete-components/2793-count-the-number-of-complete-components.java
 create mode 100644 leetcode/leetcode/2793-count-the-number-of-complete-components/README.md
 create mode 100644 leetcode/leetcode/2807-insert-greatest-common-divisors-in-linked-list/2807-insert-greatest-common-divisors-in-linked-list.java
 create mode 100644 leetcode/leetcode/2807-insert-greatest-common-divisors-in-linked-list/README.md
 create mode 100644 leetcode/leetcode/284-peeking-iterator/284-peeking-iterator.java
 create mode 100644 leetcode/leetcode/284-peeking-iterator/NOTES.md
 create mode 100644 leetcode/leetcode/284-peeking-iterator/README.md
 create mode 100644 leetcode/leetcode/2869-minimum-operations-to-collect-elements/2869-minimum-operations-to-collect-elements.java
 create mode 100644 leetcode/leetcode/2869-minimum-operations-to-collect-elements/NOTES.md
 create mode 100644 leetcode/leetcode/2869-minimum-operations-to-collect-elements/README.md
 create mode 100644 leetcode/leetcode/287-find-the-duplicate-number/287-find-the-duplicate-number.java
 create mode 100644 leetcode/leetcode/287-find-the-duplicate-number/NOTES.md
 create mode 100644 leetcode/leetcode/287-find-the-duplicate-number/README.md
 create mode 100644 leetcode/leetcode/2887-sort-vowels-in-a-string/2887-sort-vowels-in-a-string.py
 create mode 100644 leetcode/leetcode/2887-sort-vowels-in-a-string/README.md
 create mode 100644 leetcode/leetcode/2888-minimum-index-of-a-valid-split/2888-minimum-index-of-a-valid-split.java
 create mode 100644 leetcode/leetcode/2888-minimum-index-of-a-valid-split/README.md
 create mode 100644 leetcode/leetcode/290-word-pattern/290-word-pattern.java
 create mode 100644 leetcode/leetcode/290-word-pattern/NOTES.md
 create mode 100644 leetcode/leetcode/290-word-pattern/README.md
 create mode 100644 leetcode/leetcode/295-find-median-from-data-stream/295-find-median-from-data-stream.java
 create mode 100644 leetcode/leetcode/295-find-median-from-data-stream/NOTES.md
 create mode 100644 leetcode/leetcode/297-serialize-and-deserialize-binary-tree/297-serialize-and-deserialize-binary-tree.java
 create mode 100644 leetcode/leetcode/297-serialize-and-deserialize-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/297-serialize-and-deserialize-binary-tree/README.md
 create mode 100644 leetcode/leetcode/300-longest-increasing-subsequence/300-longest-increasing-subsequence.java
 create mode 100644 leetcode/leetcode/300-longest-increasing-subsequence/NOTES.md
 create mode 100644 leetcode/leetcode/300-longest-increasing-subsequence/README.md
 create mode 100644 leetcode/leetcode/3001-apply-operations-to-maximize-score/3001-apply-operations-to-maximize-score.java
 create mode 100644 leetcode/leetcode/3001-apply-operations-to-maximize-score/README.md
 create mode 100644 leetcode/leetcode/3075-maximize-happiness-of-selected-children/3075-maximize-happiness-of-selected-children.java
 create mode 100644 leetcode/leetcode/3075-maximize-happiness-of-selected-children/NOTES.md
 create mode 100644 leetcode/leetcode/3075-maximize-happiness-of-selected-children/README.md
 create mode 100644 leetcode/leetcode/316-remove-duplicate-letters/316-remove-duplicate-letters.java
 create mode 100644 leetcode/leetcode/316-remove-duplicate-letters/NOTES.md
 create mode 100644 leetcode/leetcode/316-remove-duplicate-letters/README.md
 create mode 100644 leetcode/leetcode/3172-divisible-and-non-divisible-sums-difference/3172-divisible-and-non-divisible-sums-difference.java
 create mode 100644 leetcode/leetcode/3172-divisible-and-non-divisible-sums-difference/README.md
 create mode 100644 leetcode/leetcode/3201-distribute-candies-among-children-ii/3201-distribute-candies-among-children-ii.java
 create mode 100644 leetcode/leetcode/3201-distribute-candies-among-children-ii/README.md
 create mode 100644 leetcode/leetcode/3213-count-subarrays-where-max-element-appears-at-least-k-times/3213-count-subarrays-where-max-element-appears-at-least-k-times.java
 create mode 100644 leetcode/leetcode/3213-count-subarrays-where-max-element-appears-at-least-k-times/README.md
 create mode 100644 leetcode/leetcode/3227-find-missing-and-repeated-values/3227-find-missing-and-repeated-values.java
 create mode 100644 leetcode/leetcode/3227-find-missing-and-repeated-values/README.md
 create mode 100644 leetcode/leetcode/3242-count-elements-with-maximum-frequency/3242-count-elements-with-maximum-frequency.java
 create mode 100644 leetcode/leetcode/3242-count-elements-with-maximum-frequency/README.md
 create mode 100644 leetcode/leetcode/328-odd-even-linked-list/328-odd-even-linked-list.java
 create mode 100644 leetcode/leetcode/328-odd-even-linked-list/NOTES.md
 create mode 100644 leetcode/leetcode/33-search-in-rotated-sorted-array/33-search-in-rotated-sorted-array.java
 create mode 100644 leetcode/leetcode/3332-minimum-operations-to-exceed-threshold-value-ii/3332-minimum-operations-to-exceed-threshold-value-ii.java
 create mode 100644 leetcode/leetcode/3332-minimum-operations-to-exceed-threshold-value-ii/README.md
 create mode 100644 leetcode/leetcode/3348-minimum-cost-walk-in-weighted-graph/3348-minimum-cost-walk-in-weighted-graph.java
 create mode 100644 leetcode/leetcode/3348-minimum-cost-walk-in-weighted-graph/README.md
 create mode 100644 leetcode/leetcode/3372-longest-strictly-increasing-or-strictly-decreasing-subarray/3372-longest-strictly-increasing-or-strictly-decreasing-subarray.java
 create mode 100644 leetcode/leetcode/3372-longest-strictly-increasing-or-strictly-decreasing-subarray/README.md
 create mode 100644 leetcode/leetcode/338-counting-bits/338-counting-bits.java
 create mode 100644 leetcode/leetcode/338-counting-bits/NOTES.md
 create mode 100644 leetcode/leetcode/338-counting-bits/README.md
 create mode 100644 leetcode/leetcode/3398-make-a-square-with-the-same-color/3398-make-a-square-with-the-same-color.java
 create mode 100644 leetcode/leetcode/3398-make-a-square-with-the-same-color/README.md
 create mode 100644 leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/34-find-first-and-last-position-of-element-in-sorted-array.java
 create mode 100644 leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/NOTES.md
 create mode 100644 leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/README.md
 create mode 100644 leetcode/leetcode/3430-count-days-without-meetings/3430-count-days-without-meetings.java
 create mode 100644 leetcode/leetcode/3430-count-days-without-meetings/README.md
 create mode 100644 leetcode/leetcode/344-reverse-string/344-reverse-string.java
 create mode 100644 leetcode/leetcode/344-reverse-string/README.md
 create mode 100644 leetcode/leetcode/3447-clear-digits/3447-clear-digits.java
 create mode 100644 leetcode/leetcode/3447-clear-digits/README.md
 create mode 100644 leetcode/leetcode/347-top-k-frequent-elements/347-top-k-frequent-elements.java
 create mode 100644 leetcode/leetcode/347-top-k-frequent-elements/NOTES.md
 create mode 100644 leetcode/leetcode/347-top-k-frequent-elements/README.md
 create mode 100644 leetcode/leetcode/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i.java
 create mode 100644 leetcode/leetcode/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i/README.md
 create mode 100644 leetcode/leetcode/3483-alternating-groups-ii/3483-alternating-groups-ii.java
 create mode 100644 leetcode/leetcode/3483-alternating-groups-ii/README.md
 create mode 100644 leetcode/leetcode/350-intersection-of-two-arrays-ii/350-intersection-of-two-arrays-ii.java
 create mode 100644 leetcode/leetcode/350-intersection-of-two-arrays-ii/NOTES.md
 create mode 100644 leetcode/leetcode/350-intersection-of-two-arrays-ii/README.md
 create mode 100644 leetcode/leetcode/3501-delete-nodes-from-linked-list-present-in-array/3501-delete-nodes-from-linked-list-present-in-array.java
 create mode 100644 leetcode/leetcode/3501-delete-nodes-from-linked-list-present-in-array/README.md
 create mode 100644 leetcode/leetcode/3541-report-spam-message/3541-report-spam-message.java
 create mode 100644 leetcode/leetcode/3541-report-spam-message/README.md
 create mode 100644 leetcode/leetcode/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii.java
 create mode 100644 leetcode/leetcode/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii/README.md
 create mode 100644 leetcode/leetcode/36-valid-sudoku/36-valid-sudoku.java
 create mode 100644 leetcode/leetcode/36-valid-sudoku/NOTES.md
 create mode 100644 leetcode/leetcode/36-valid-sudoku/README.md
 create mode 100644 leetcode/leetcode/3643-zero-array-transformation-ii/3643-zero-array-transformation-ii.java
 create mode 100644 leetcode/leetcode/3643-zero-array-transformation-ii/README.md
 create mode 100644 leetcode/leetcode/3657-check-if-grid-can-be-cut-into-sections/3657-check-if-grid-can-be-cut-into-sections.java
 create mode 100644 leetcode/leetcode/3657-check-if-grid-can-be-cut-into-sections/README.md
 create mode 100644 leetcode/leetcode/3685-count-subarrays-of-length-three-with-a-condition/README.md
 create mode 100644 leetcode/leetcode/371-sum-of-two-integers/371-sum-of-two-integers.java
 create mode 100644 leetcode/leetcode/371-sum-of-two-integers/NOTES.md
 create mode 100644 leetcode/leetcode/371-sum-of-two-integers/README.md
 create mode 100644 leetcode/leetcode/380-insert-delete-getrandom-o1/380-insert-delete-getrandom-o1.java
 create mode 100644 leetcode/leetcode/380-insert-delete-getrandom-o1/NOTES.md
 create mode 100644 leetcode/leetcode/380-insert-delete-getrandom-o1/README.md
 create mode 100644 leetcode/leetcode/382-linked-list-random-node/382-linked-list-random-node.java
 create mode 100644 leetcode/leetcode/382-linked-list-random-node/NOTES.md
 create mode 100644 leetcode/leetcode/382-linked-list-random-node/README.md
 create mode 100644 leetcode/leetcode/387-first-unique-character-in-a-string/387-first-unique-character-in-a-string.java
 create mode 100644 leetcode/leetcode/387-first-unique-character-in-a-string/NOTES.md
 create mode 100644 leetcode/leetcode/387-first-unique-character-in-a-string/README.md
 create mode 100644 leetcode/leetcode/389-find-the-difference/389-find-the-difference.java
 create mode 100644 leetcode/leetcode/389-find-the-difference/NOTES.md
 create mode 100644 leetcode/leetcode/389-find-the-difference/README.md
 create mode 100644 leetcode/leetcode/39-combination-sum/39-combination-sum.java
 create mode 100644 leetcode/leetcode/39-combination-sum/NOTES.md
 create mode 100644 leetcode/leetcode/39-combination-sum/README.md
 create mode 100644 leetcode/leetcode/392-is-subsequence/392-is-subsequence.java
 create mode 100644 leetcode/leetcode/392-is-subsequence/NOTES.md
 create mode 100644 leetcode/leetcode/392-is-subsequence/README.md
 create mode 100644 leetcode/leetcode/397-integer-replacement/397-integer-replacement.java
 create mode 100644 leetcode/leetcode/397-integer-replacement/NOTES.md
 create mode 100644 leetcode/leetcode/397-integer-replacement/README.md
 create mode 100644 leetcode/leetcode/398-random-pick-index/398-random-pick-index.java
 create mode 100644 leetcode/leetcode/398-random-pick-index/NOTES.md
 create mode 100644 leetcode/leetcode/398-random-pick-index/README.md
 create mode 100644 leetcode/leetcode/400-nth-digit/400-nth-digit.java
 create mode 100644 leetcode/leetcode/400-nth-digit/NOTES.md
 create mode 100644 leetcode/leetcode/400-nth-digit/README.md
 create mode 100644 leetcode/leetcode/413-arithmetic-slices/413-arithmetic-slices.java
 create mode 100644 leetcode/leetcode/413-arithmetic-slices/NOTES.md
 create mode 100644 leetcode/leetcode/413-arithmetic-slices/README.md
 create mode 100644 leetcode/leetcode/416-partition-equal-subset-sum/416-partition-equal-subset-sum.java
 create mode 100644 leetcode/leetcode/416-partition-equal-subset-sum/NOTES.md
 create mode 100644 leetcode/leetcode/416-partition-equal-subset-sum/README.md
 create mode 100644 leetcode/leetcode/42-trapping-rain-water/42-trapping-rain-water.java
 create mode 100644 leetcode/leetcode/42-trapping-rain-water/NOTES.md
 create mode 100644 leetcode/leetcode/42-trapping-rain-water/README.md
 create mode 100644 leetcode/leetcode/429-n-ary-tree-level-order-traversal/429-n-ary-tree-level-order-traversal.java
 create mode 100644 leetcode/leetcode/429-n-ary-tree-level-order-traversal/NOTES.md
 create mode 100644 leetcode/leetcode/429-n-ary-tree-level-order-traversal/README.md
 create mode 100644 leetcode/leetcode/438-find-all-anagrams-in-a-string/438-find-all-anagrams-in-a-string.java
 create mode 100644 leetcode/leetcode/438-find-all-anagrams-in-a-string/NOTES.md
 create mode 100644 leetcode/leetcode/438-find-all-anagrams-in-a-string/README.md
 create mode 100644 leetcode/leetcode/449-serialize-and-deserialize-bst/449-serialize-and-deserialize-bst.java
 create mode 100644 leetcode/leetcode/449-serialize-and-deserialize-bst/NOTES.md
 create mode 100644 leetcode/leetcode/449-serialize-and-deserialize-bst/README.md
 create mode 100644 leetcode/leetcode/45-jump-game-ii/45-jump-game-ii.java
 create mode 100644 leetcode/leetcode/45-jump-game-ii/NOTES.md
 create mode 100644 leetcode/leetcode/45-jump-game-ii/README.md
 create mode 100644 leetcode/leetcode/450-delete-node-in-a-bst/450-delete-node-in-a-bst.java
 create mode 100644 leetcode/leetcode/450-delete-node-in-a-bst/NOTES.md
 create mode 100644 leetcode/leetcode/450-delete-node-in-a-bst/README.md
 create mode 100644 leetcode/leetcode/451-sort-characters-by-frequency/451-sort-characters-by-frequency.java
 create mode 100644 leetcode/leetcode/451-sort-characters-by-frequency/NOTES.md
 create mode 100644 leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/452-minimum-number-of-arrows-to-burst-balloons.java
 create mode 100644 leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/NOTES.md
 create mode 100644 leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/README.md
 create mode 100644 leetcode/leetcode/46-permutations/46-permutations.java
 create mode 100644 leetcode/leetcode/46-permutations/NOTES.md
 create mode 100644 leetcode/leetcode/46-permutations/README.md
 create mode 100644 leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/462-minimum-moves-to-equal-array-elements-ii.java
 create mode 100644 leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/NOTES.md
 create mode 100644 leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/README.md
 create mode 100644 leetcode/leetcode/470-implement-rand10-using-rand7/470-implement-rand10-using-rand7.java
 create mode 100644 leetcode/leetcode/470-implement-rand10-using-rand7/NOTES.md
 create mode 100644 leetcode/leetcode/470-implement-rand10-using-rand7/README.md
 create mode 100644 leetcode/leetcode/48-rotate-image/48-rotate-image.java
 create mode 100644 leetcode/leetcode/48-rotate-image/NOTES.md
 create mode 100644 leetcode/leetcode/48-rotate-image/README.md
 create mode 100644 leetcode/leetcode/494-target-sum/494-target-sum.java
 create mode 100644 leetcode/leetcode/494-target-sum/NOTES.md
 create mode 100644 leetcode/leetcode/494-target-sum/README.md
 create mode 100644 leetcode/leetcode/496-next-greater-element-i/496-next-greater-element-i.java
 create mode 100644 leetcode/leetcode/496-next-greater-element-i/NOTES.md
 create mode 100644 leetcode/leetcode/496-next-greater-element-i/README.md
 create mode 100644 leetcode/leetcode/509-fibonacci-number/509-fibonacci-number.java
 create mode 100644 leetcode/leetcode/509-fibonacci-number/NOTES.md
 create mode 100644 leetcode/leetcode/509-fibonacci-number/README.md
 create mode 100644 leetcode/leetcode/511-game-play-analysis-i/511-game-play-analysis-i.sql
 create mode 100644 leetcode/leetcode/511-game-play-analysis-i/NOTES.md
 create mode 100644 leetcode/leetcode/511-game-play-analysis-i/README.md
 create mode 100644 leetcode/leetcode/515-find-largest-value-in-each-tree-row/515-find-largest-value-in-each-tree-row.java
 create mode 100644 leetcode/leetcode/515-find-largest-value-in-each-tree-row/NOTES.md
 create mode 100644 leetcode/leetcode/515-find-largest-value-in-each-tree-row/README.md
 create mode 100644 leetcode/leetcode/520-detect-capital/520-detect-capital.java
 create mode 100644 leetcode/leetcode/520-detect-capital/NOTES.md
 create mode 100644 leetcode/leetcode/525-contiguous-array/525-contiguous-array.java
 create mode 100644 leetcode/leetcode/525-contiguous-array/NOTES.md
 create mode 100644 leetcode/leetcode/525-contiguous-array/README.md
 create mode 100644 leetcode/leetcode/532-k-diff-pairs-in-an-array/532-k-diff-pairs-in-an-array.java
 create mode 100644 leetcode/leetcode/532-k-diff-pairs-in-an-array/NOTES.md
 create mode 100644 leetcode/leetcode/532-k-diff-pairs-in-an-array/README.md
 create mode 100644 leetcode/leetcode/538-convert-bst-to-greater-tree/538-convert-bst-to-greater-tree.java
 create mode 100644 leetcode/leetcode/538-convert-bst-to-greater-tree/NOTES.md
 create mode 100644 leetcode/leetcode/538-convert-bst-to-greater-tree/README.md
 create mode 100644 leetcode/leetcode/54-spiral-matrix/54-spiral-matrix.java
 create mode 100644 leetcode/leetcode/54-spiral-matrix/NOTES.md
 create mode 100644 leetcode/leetcode/54-spiral-matrix/README.md
 create mode 100644 leetcode/leetcode/540-single-element-in-a-sorted-array/540-single-element-in-a-sorted-array.java
 create mode 100644 leetcode/leetcode/540-single-element-in-a-sorted-array/NOTES.md
 create mode 100644 leetcode/leetcode/55-jump-game/55-jump-game.java
 create mode 100644 leetcode/leetcode/55-jump-game/NOTES.md
 create mode 100644 leetcode/leetcode/55-jump-game/README.md
 create mode 100644 leetcode/leetcode/560-subarray-sum-equals-k/560-subarray-sum-equals-k.java
 create mode 100644 leetcode/leetcode/560-subarray-sum-equals-k/NOTES.md
 create mode 100644 leetcode/leetcode/560-subarray-sum-equals-k/README.md
 create mode 100644 leetcode/leetcode/567-permutation-in-string/567-permutation-in-string.java
 create mode 100644 leetcode/leetcode/567-permutation-in-string/NOTES.md
 create mode 100644 leetcode/leetcode/567-permutation-in-string/README.md
 create mode 100644 leetcode/leetcode/575-distribute-candies/575-distribute-candies.java
 create mode 100644 leetcode/leetcode/575-distribute-candies/NOTES.md
 create mode 100644 leetcode/leetcode/575-distribute-candies/README.md
 create mode 100644 leetcode/leetcode/59-spiral-matrix-ii/59-spiral-matrix-ii.java
 create mode 100644 leetcode/leetcode/59-spiral-matrix-ii/NOTES.md
 create mode 100644 leetcode/leetcode/59-spiral-matrix-ii/README.md
 create mode 100644 leetcode/leetcode/595-big-countries/595-big-countries.sql
 create mode 100644 leetcode/leetcode/595-big-countries/NOTES.md
 create mode 100644 leetcode/leetcode/595-big-countries/README.md
 create mode 100644 leetcode/leetcode/596-classes-more-than-5-students/596-classes-more-than-5-students.sql
 create mode 100644 leetcode/leetcode/596-classes-more-than-5-students/NOTES.md
 create mode 100644 leetcode/leetcode/596-classes-more-than-5-students/README.md
 create mode 100644 leetcode/leetcode/605-can-place-flowers/605-can-place-flowers.java
 create mode 100644 leetcode/leetcode/605-can-place-flowers/NOTES.md
 create mode 100644 leetcode/leetcode/605-can-place-flowers/README.md
 create mode 100644 leetcode/leetcode/606-construct-string-from-binary-tree/606-construct-string-from-binary-tree.java
 create mode 100644 leetcode/leetcode/606-construct-string-from-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/606-construct-string-from-binary-tree/README.md
 create mode 100644 leetcode/leetcode/61-rotate-list/61-rotate-list.java
 create mode 100644 leetcode/leetcode/61-rotate-list/NOTES.md
 create mode 100644 leetcode/leetcode/62-unique-paths/62-unique-paths.java
 create mode 100644 leetcode/leetcode/62-unique-paths/NOTES.md
 create mode 100644 leetcode/leetcode/62-unique-paths/README.md
 create mode 100644 leetcode/leetcode/623-add-one-row-to-tree/623-add-one-row-to-tree.java
 create mode 100644 leetcode/leetcode/623-add-one-row-to-tree/NOTES.md
 create mode 100644 leetcode/leetcode/623-add-one-row-to-tree/README.md
 create mode 100644 leetcode/leetcode/63-unique-paths-ii/63-unique-paths-ii.java
 create mode 100644 leetcode/leetcode/63-unique-paths-ii/NOTES.md
 create mode 100644 leetcode/leetcode/63-unique-paths-ii/README.md
 create mode 100644 leetcode/leetcode/637-average-of-levels-in-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/637-average-of-levels-in-binary-tree/README.md
 create mode 100644 leetcode/leetcode/64-minimum-path-sum/64-minimum-path-sum.java
 create mode 100644 leetcode/leetcode/64-minimum-path-sum/NOTES.md
 create mode 100644 leetcode/leetcode/64-minimum-path-sum/README.md
 create mode 100644 leetcode/leetcode/645-set-mismatch/645-set-mismatch.java
 create mode 100644 leetcode/leetcode/645-set-mismatch/README.md
 create mode 100644 leetcode/leetcode/662-maximum-width-of-binary-tree/662-maximum-width-of-binary-tree.java
 create mode 100644 leetcode/leetcode/662-maximum-width-of-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/662-maximum-width-of-binary-tree/README.md
 create mode 100644 leetcode/leetcode/669-trim-a-binary-search-tree/669-trim-a-binary-search-tree.java
 create mode 100644 leetcode/leetcode/669-trim-a-binary-search-tree/NOTES.md
 create mode 100644 leetcode/leetcode/669-trim-a-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/67-add-binary/67-add-binary.java
 create mode 100644 leetcode/leetcode/67-add-binary/README.md
 create mode 100644 leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/671-second-minimum-node-in-a-binary-tree.java
 create mode 100644 leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/NOTES.md
 create mode 100644 leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/README.md
 create mode 100644 leetcode/leetcode/695-max-area-of-island/695-max-area-of-island.java
 create mode 100644 leetcode/leetcode/695-max-area-of-island/NOTES.md
 create mode 100644 leetcode/leetcode/695-max-area-of-island/README.md
 create mode 100644 leetcode/leetcode/70-climbing-stairs/70-climbing-stairs.java
 create mode 100644 leetcode/leetcode/70-climbing-stairs/README.md
 create mode 100644 leetcode/leetcode/700-search-in-a-binary-search-tree/700-search-in-a-binary-search-tree.java
 create mode 100644 leetcode/leetcode/700-search-in-a-binary-search-tree/NOTES.md
 create mode 100644 leetcode/leetcode/700-search-in-a-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/701-insert-into-a-binary-search-tree/701-insert-into-a-binary-search-tree.java
 create mode 100644 leetcode/leetcode/701-insert-into-a-binary-search-tree/NOTES.md
 create mode 100644 leetcode/leetcode/701-insert-into-a-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/704-binary-search/704-binary-search.java
 create mode 100644 leetcode/leetcode/704-binary-search/NOTES.md
 create mode 100644 leetcode/leetcode/704-binary-search/README.md
 create mode 100644 leetcode/leetcode/709-to-lower-case/709-to-lower-case.java
 create mode 100644 leetcode/leetcode/709-to-lower-case/NOTES.md
 create mode 100644 leetcode/leetcode/709-to-lower-case/README.md
 create mode 100644 leetcode/leetcode/72-edit-distance/72-edit-distance.java
 create mode 100644 leetcode/leetcode/72-edit-distance/NOTES.md
 create mode 100644 leetcode/leetcode/72-edit-distance/README.md
 create mode 100644 leetcode/leetcode/73-set-matrix-zeroes/73-set-matrix-zeroes.java
 create mode 100644 leetcode/leetcode/73-set-matrix-zeroes/NOTES.md
 create mode 100644 leetcode/leetcode/73-set-matrix-zeroes/README.md
 create mode 100644 leetcode/leetcode/735-asteroid-collision/735-asteroid-collision.java
 create mode 100644 leetcode/leetcode/735-asteroid-collision/NOTES.md
 create mode 100644 leetcode/leetcode/739-daily-temperatures/739-daily-temperatures.java
 create mode 100644 leetcode/leetcode/739-daily-temperatures/NOTES.md
 create mode 100644 leetcode/leetcode/739-daily-temperatures/README.md
 create mode 100644 leetcode/leetcode/74-search-a-2d-matrix/74-search-a-2d-matrix.java
 create mode 100644 leetcode/leetcode/74-search-a-2d-matrix/NOTES.md
 create mode 100644 leetcode/leetcode/74-search-a-2d-matrix/README.md
 create mode 100644 leetcode/leetcode/740-delete-and-earn/740-delete-and-earn.java
 create mode 100644 leetcode/leetcode/740-delete-and-earn/README.md
 create mode 100644 leetcode/leetcode/746-min-cost-climbing-stairs/746-min-cost-climbing-stairs.java
 create mode 100644 leetcode/leetcode/746-min-cost-climbing-stairs/NOTES.md
 create mode 100644 leetcode/leetcode/746-min-cost-climbing-stairs/README.md
 create mode 100644 leetcode/leetcode/747-largest-number-at-least-twice-of-others/747-largest-number-at-least-twice-of-others.java
 create mode 100644 leetcode/leetcode/747-largest-number-at-least-twice-of-others/NOTES.md
 create mode 100644 leetcode/leetcode/747-largest-number-at-least-twice-of-others/README.md
 create mode 100644 leetcode/leetcode/75-sort-colors/75-sort-colors.java
 create mode 100644 leetcode/leetcode/75-sort-colors/NOTES.md
 create mode 100644 leetcode/leetcode/75-sort-colors/README.md
 create mode 100644 leetcode/leetcode/78-subsets/78-subsets.java
 create mode 100644 leetcode/leetcode/78-subsets/NOTES.md
 create mode 100644 leetcode/leetcode/78-subsets/README.md
 create mode 100644 leetcode/leetcode/79-word-search/79-word-search.java
 create mode 100644 leetcode/leetcode/79-word-search/NOTES.md
 create mode 100644 leetcode/leetcode/79-word-search/README.md
 create mode 100644 leetcode/leetcode/799-champagne-tower/799-champagne-tower.java
 create mode 100644 leetcode/leetcode/799-champagne-tower/NOTES.md
 create mode 100644 leetcode/leetcode/799-champagne-tower/README.md
 create mode 100644 leetcode/leetcode/8-string-to-integer-atoi/8-string-to-integer-atoi.java
 create mode 100644 leetcode/leetcode/8-string-to-integer-atoi/NOTES.md
 create mode 100644 leetcode/leetcode/8-string-to-integer-atoi/README.md
 create mode 100644 leetcode/leetcode/807-max-increase-to-keep-city-skyline/807-max-increase-to-keep-city-skyline.java
 create mode 100644 leetcode/leetcode/807-max-increase-to-keep-city-skyline/NOTES.md
 create mode 100644 leetcode/leetcode/807-max-increase-to-keep-city-skyline/README.md
 create mode 100644 leetcode/leetcode/814-binary-tree-pruning/814-binary-tree-pruning.c
 create mode 100644 leetcode/leetcode/814-binary-tree-pruning/814-binary-tree-pruning.java
 create mode 100644 leetcode/leetcode/814-binary-tree-pruning/NOTES.md
 create mode 100644 leetcode/leetcode/814-binary-tree-pruning/README.md
 create mode 100644 leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/82-remove-duplicates-from-sorted-list-ii.java
 create mode 100644 leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/NOTES.md
 create mode 100644 leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/README.md
 create mode 100644 leetcode/leetcode/846-hand-of-straights/846-hand-of-straights.java
 create mode 100644 leetcode/leetcode/846-hand-of-straights/NOTES.md
 create mode 100644 leetcode/leetcode/846-hand-of-straights/README.md
 create mode 100644 leetcode/leetcode/849-maximize-distance-to-closest-person/849-maximize-distance-to-closest-person.java
 create mode 100644 leetcode/leetcode/849-maximize-distance-to-closest-person/NOTES.md
 create mode 100644 leetcode/leetcode/849-maximize-distance-to-closest-person/README.md
 create mode 100644 leetcode/leetcode/852-peak-index-in-a-mountain-array/852-peak-index-in-a-mountain-array.java
 create mode 100644 leetcode/leetcode/852-peak-index-in-a-mountain-array/NOTES.md
 create mode 100644 leetcode/leetcode/852-peak-index-in-a-mountain-array/README.md
 create mode 100644 leetcode/leetcode/867-transpose-matrix/867-transpose-matrix.java
 create mode 100644 leetcode/leetcode/867-transpose-matrix/NOTES.md
 create mode 100644 leetcode/leetcode/867-transpose-matrix/README.md
 create mode 100644 leetcode/leetcode/875-koko-eating-bananas/875-koko-eating-bananas.java
 create mode 100644 leetcode/leetcode/875-koko-eating-bananas/NOTES.md
 create mode 100644 leetcode/leetcode/875-koko-eating-bananas/README.md
 create mode 100644 leetcode/leetcode/88-merge-sorted-array/88-merge-sorted-array.java
 create mode 100644 leetcode/leetcode/88-merge-sorted-array/NOTES.md
 create mode 100644 leetcode/leetcode/88-merge-sorted-array/README.md
 create mode 100644 leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/889-construct-binary-tree-from-preorder-and-postorder-traversal.java
 create mode 100644 leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/NOTES.md
 create mode 100644 leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/README.md
 create mode 100644 leetcode/leetcode/890-find-and-replace-pattern/890-find-and-replace-pattern.java
 create mode 100644 leetcode/leetcode/890-find-and-replace-pattern/NOTES.md
 create mode 100644 leetcode/leetcode/890-find-and-replace-pattern/README.md
 create mode 100644 leetcode/leetcode/9-palindrome-number/9-palindrome-number.cpp
 create mode 100644 leetcode/leetcode/9-palindrome-number/9-palindrome-number.java
 create mode 100644 leetcode/leetcode/9-palindrome-number/NOTES.md
 create mode 100644 leetcode/leetcode/9-palindrome-number/README.md
 create mode 100644 leetcode/leetcode/931-minimum-falling-path-sum/931-minimum-falling-path-sum.java
 create mode 100644 leetcode/leetcode/94-binary-tree-inorder-traversal/94-binary-tree-inorder-traversal.java
 create mode 100644 leetcode/leetcode/94-binary-tree-inorder-traversal/NOTES.md
 create mode 100644 leetcode/leetcode/94-binary-tree-inorder-traversal/README.md
 create mode 100644 leetcode/leetcode/941-valid-mountain-array/941-valid-mountain-array.java
 create mode 100644 leetcode/leetcode/941-valid-mountain-array/NOTES.md
 create mode 100644 leetcode/leetcode/941-valid-mountain-array/README.md
 create mode 100644 leetcode/leetcode/946-validate-stack-sequences/946-validate-stack-sequences.java
 create mode 100644 leetcode/leetcode/946-validate-stack-sequences/NOTES.md
 create mode 100644 leetcode/leetcode/946-validate-stack-sequences/README.md
 create mode 100644 leetcode/leetcode/96-unique-binary-search-trees/96-unique-binary-search-trees.java
 create mode 100644 leetcode/leetcode/96-unique-binary-search-trees/NOTES.md
 create mode 100644 leetcode/leetcode/96-unique-binary-search-trees/README.md
 create mode 100644 leetcode/leetcode/969-pancake-sorting/969-pancake-sorting.java
 create mode 100644 leetcode/leetcode/969-pancake-sorting/NOTES.md
 create mode 100644 leetcode/leetcode/969-pancake-sorting/README.md
 create mode 100644 leetcode/leetcode/973-k-closest-points-to-origin/973-k-closest-points-to-origin.java
 create mode 100644 leetcode/leetcode/973-k-closest-points-to-origin/NOTES.md
 create mode 100644 leetcode/leetcode/973-k-closest-points-to-origin/README.md
 create mode 100644 leetcode/leetcode/991-broken-calculator/991-broken-calculator.java
 create mode 100644 leetcode/leetcode/991-broken-calculator/NOTES.md
 create mode 100644 leetcode/leetcode/991-broken-calculator/README.md
 create mode 100644 leetcode/leetcode/Binary Search - GFG/README.md
 create mode 100644 leetcode/leetcode/Binary Search - GFG/binary-search.java
 create mode 100644 leetcode/leetcode/Bottom View of Binary Tree - GFG/README.md
 create mode 100644 leetcode/leetcode/Bottom View of Binary Tree - GFG/bottom-view-of-binary-tree.java
 create mode 100644 leetcode/leetcode/Buildings receiving sunlight - GFG/README.md
 create mode 100644 leetcode/leetcode/Buildings receiving sunlight - GFG/buildings-receiving-sunlight.java
 create mode 100644 leetcode/leetcode/Check for BST - GFG/README.md
 create mode 100644 leetcode/leetcode/Check for BST - GFG/check-for-bst.java
 create mode 100644 leetcode/leetcode/Check if Linked List is Palindrome - GFG/README.md
 create mode 100644 leetcode/leetcode/Check if Linked List is Palindrome - GFG/check-if-linked-list-is-palindrome.java
 create mode 100644 leetcode/leetcode/Connect Nodes at Same Level - GFG/README.md
 create mode 100644 leetcode/leetcode/Connect Nodes at Same Level - GFG/connect-nodes-at-same-level.java
 create mode 100644 leetcode/leetcode/Count distinct elements in every window - GFG/README.md
 create mode 100644 leetcode/leetcode/Count distinct elements in every window - GFG/count-distinct-elements-in-every-window.java
 create mode 100644 leetcode/leetcode/Count pairs in array divisible by K - GFG/README.md
 create mode 100644 leetcode/leetcode/Count pairs in array divisible by K - GFG/count-pairs-in-array-divisible-by-k.java
 create mode 100644 leetcode/leetcode/Detect Loop in linked list - GFG/README.md
 create mode 100644 leetcode/leetcode/Detect Loop in linked list - GFG/detect-loop-in-linked-list.java
 create mode 100644 leetcode/leetcode/Diameter of a Binary Tree - GFG/README.md
 create mode 100644 leetcode/leetcode/Diameter of a Binary Tree - GFG/diameter-of-a-binary-tree.java
 create mode 100644 leetcode/leetcode/Find Transition Point - GFG/README.md
 create mode 100644 leetcode/leetcode/Find Transition Point - GFG/find-transition-point.java
 create mode 100644 leetcode/leetcode/Find duplicates in an array - GFG/README.md
 create mode 100644 leetcode/leetcode/Find duplicates in an array - GFG/find-duplicates-in-an-array.java
 create mode 100644 leetcode/leetcode/Finding middle element in a linked list - GFG/README.md
 create mode 100644 leetcode/leetcode/Finding middle element in a linked list - GFG/finding-middle-element-in-a-linked-list.java
 create mode 100644 leetcode/leetcode/GCD of two numbers - GFG/README.md
 create mode 100644 leetcode/leetcode/GCD of two numbers - GFG/gcd-of-two-numbers.java
 create mode 100644 leetcode/leetcode/Get minimum element from stack - GFG/README.md
 create mode 100644 leetcode/leetcode/Get minimum element from stack - GFG/get-minimum-element-from-stack.java
 create mode 100644 leetcode/leetcode/Given a linked list of 0s, 1s and 2s, sort it. - GFG/README.md
 create mode 100644 leetcode/leetcode/Given a linked list of 0s, 1s and 2s, sort it. - GFG/given-a-linked-list-of-0s-1s-and-2s-sort-it..java
 create mode 100644 leetcode/leetcode/Height of Binary Tree - GFG/README.md
 create mode 100644 leetcode/leetcode/Height of Binary Tree - GFG/height-of-binary-tree.java
 create mode 100644 leetcode/leetcode/Inorder Successor in BST - GFG/README.md
 create mode 100644 leetcode/leetcode/Inorder Successor in BST - GFG/inorder-successor-in-bst.java
 create mode 100644 leetcode/leetcode/Intersection Point in Y Shapped Linked Lists - GFG/README.md
 create mode 100644 leetcode/leetcode/Intersection Point in Y Shapped Linked Lists - GFG/intersection-point-in-y-shapped-linked-lists.java
 create mode 100644 leetcode/leetcode/Kadane's Algorithm - GFG/README.md
 create mode 100644 leetcode/leetcode/Kadane's Algorithm - GFG/kadanes-algorithm.java
 create mode 100644 leetcode/leetcode/Largest value in each level - GFG/README.md
 create mode 100644 leetcode/leetcode/Largest value in each level - GFG/largest-value-in-each-level.java
 create mode 100644 leetcode/leetcode/Left View of Binary Tree - GFG/README.md
 create mode 100644 leetcode/leetcode/Left View of Binary Tree - GFG/left-view-of-binary-tree.java
 create mode 100644 leetcode/leetcode/Level order traversal in spiral form - GFG/README.md
 create mode 100644 leetcode/leetcode/Level order traversal in spiral form - GFG/level-order-traversal-in-spiral-form.java
 create mode 100644 leetcode/leetcode/Lowest Common Ancestor in a Binary Tree - GFG/README.md
 create mode 100644 leetcode/leetcode/Lowest Common Ancestor in a Binary Tree - GFG/lowest-common-ancestor-in-a-binary-tree.java
 create mode 100644 leetcode/leetcode/Max Sum Subarray of size K - GFG/README.md
 create mode 100644 leetcode/leetcode/Max Sum Subarray of size K - GFG/max-sum-subarray-of-size-k.java
 create mode 100644 leetcode/leetcode/Maximum no of 1's row - GFG/README.md
 create mode 100644 leetcode/leetcode/Maximum no of 1's row - GFG/maximum-no-of-1s-row.java
 create mode 100644 leetcode/leetcode/Minimum Operations - GFG/README.md
 create mode 100644 leetcode/leetcode/Minimum Operations - GFG/minimum-operations.java
 create mode 100644 leetcode/leetcode/Missing number in array - GFG/README.md
 create mode 100644 leetcode/leetcode/Missing number in array - GFG/missing-number-in-array.java
 create mode 100644 leetcode/leetcode/Move all zeroes to end of array - GFG/README.md
 create mode 100644 leetcode/leetcode/Move all zeroes to end of array - GFG/move-all-zeroes-to-end-of-array.java
 create mode 100644 leetcode/leetcode/Peak element - GFG/README.md
 create mode 100644 leetcode/leetcode/Peak element - GFG/peak-element.java
 create mode 100644 leetcode/leetcode/README.md
 create mode 100644 leetcode/leetcode/Rearrange a linked list - GFG/README.md
 create mode 100644 leetcode/leetcode/Rearrange a linked list - GFG/rearrange-a-linked-list.java
 create mode 100644 leetcode/leetcode/Remove loop in Linked List - GFG/README.md
 create mode 100644 leetcode/leetcode/Remove loop in Linked List - GFG/remove-loop-in-linked-list.java
 create mode 100644 leetcode/leetcode/Rotate Array - GFG/README.md
 create mode 100644 leetcode/leetcode/Rotate Array - GFG/rotate-array.c
 create mode 100644 leetcode/leetcode/Rotate a Linked List - GFG/README.md
 create mode 100644 leetcode/leetcode/Rotate a Linked List - GFG/rotate-a-linked-list.java
 create mode 100644 leetcode/leetcode/Subset Sum Problem - GFG/subset-sum-problem.java
 create mode 100644 leetcode/leetcode/Sum Tree - GFG/README.md
 create mode 100644 leetcode/leetcode/Sum Tree - GFG/sum-tree.java
 create mode 100644 leetcode/leetcode/Top View of Binary Tree - GFG/README.md
 create mode 100644 leetcode/leetcode/Top View of Binary Tree - GFG/top-view-of-binary-tree.java
 create mode 100644 leetcode/leetcode/Trailing zeroes in factorial - GFG/README.md
 create mode 100644 leetcode/leetcode/Trailing zeroes in factorial - GFG/trailing-zeroes-in-factorial.java
 create mode 100644 leetcode/leetcode/Transform to Sum Tree - GFG/README.md
 create mode 100644 leetcode/leetcode/Vertical Traversal of Binary Tree - GFG/README.md
 create mode 100644 leetcode/leetcode/Vertical Traversal of Binary Tree - GFG/vertical-traversal-of-binary-tree.java
 create mode 100644 leetcode/leetcode/a-number-after-a-double-reversal/README.md
 create mode 100644 leetcode/leetcode/a-number-after-a-double-reversal/a-number-after-a-double-reversal.java
 create mode 100644 leetcode/leetcode/add-digits/README.md
 create mode 100644 leetcode/leetcode/add-digits/add-digits.java
 create mode 100644 leetcode/leetcode/add-two-numbers-ii/README.md
 create mode 100644 leetcode/leetcode/add-two-numbers-ii/add-two-numbers-ii.java
 create mode 100644 leetcode/leetcode/add-two-numbers/README.md
 create mode 100644 leetcode/leetcode/add-two-numbers/add-two-numbers.java
 create mode 100644 leetcode/leetcode/adding-spaces-to-a-string/README.md
 create mode 100644 leetcode/leetcode/adding-spaces-to-a-string/adding-spaces-to-a-string.java
 create mode 100644 leetcode/leetcode/apply-discount-every-n-orders/README.md
 create mode 100644 leetcode/leetcode/apply-discount-every-n-orders/apply-discount-every-n-orders.java
 create mode 100644 leetcode/leetcode/arranging-coins/README.md
 create mode 100644 leetcode/leetcode/arranging-coins/arranging-coins.java
 create mode 100644 leetcode/leetcode/array-partition-i/README.md
 create mode 100644 leetcode/leetcode/array-partition-i/array-partition-i.java
 create mode 100644 leetcode/leetcode/average-of-levels-in-binary-tree/README.md
 create mode 100644 leetcode/leetcode/average-of-levels-in-binary-tree/average-of-levels-in-binary-tree.java
 create mode 100644 leetcode/leetcode/balanced-binary-tree/README.md
 create mode 100644 leetcode/leetcode/balanced-binary-tree/balanced-binary-tree.java
 create mode 100644 leetcode/leetcode/binary-search/README.md
 create mode 100644 leetcode/leetcode/binary-search/binary-search.java
 create mode 100644 leetcode/leetcode/binary-tree-inorder-traversal/README.md
 create mode 100644 leetcode/leetcode/binary-tree-inorder-traversal/binary-tree-inorder-traversal.java
 create mode 100644 leetcode/leetcode/binary-tree-postorder-traversal/README.md
 create mode 100644 leetcode/leetcode/binary-tree-postorder-traversal/binary-tree-postorder-traversal.java
 create mode 100644 leetcode/leetcode/binary-tree-preorder-traversal/README.md
 create mode 100644 leetcode/leetcode/binary-tree-preorder-traversal/binary-tree-preorder-traversal.java
 create mode 100644 leetcode/leetcode/binary-tree-tilt/README.md
 create mode 100644 leetcode/leetcode/binary-tree-tilt/binary-tree-tilt.java
 create mode 100644 leetcode/leetcode/bitwise-and-of-numbers-range/README.md
 create mode 100644 leetcode/leetcode/bitwise-and-of-numbers-range/bitwise-and-of-numbers-range.cpp
 create mode 100644 leetcode/leetcode/bitwise-and-of-numbers-range/bitwise-and-of-numbers-range.java
 create mode 100644 leetcode/leetcode/build-array-from-permutation/README.md
 create mode 100644 leetcode/leetcode/build-array-from-permutation/build-array-from-permutation.java
 create mode 100644 leetcode/leetcode/calculate-money-in-leetcode-bank/README.md
 create mode 100644 leetcode/leetcode/calculate-money-in-leetcode-bank/calculate-money-in-leetcode-bank.java
 create mode 100644 leetcode/leetcode/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/README.md
 create mode 100644 leetcode/leetcode/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.java
 create mode 100644 leetcode/leetcode/check-if-all-as-appears-before-all-bs/README.md
 create mode 100644 leetcode/leetcode/check-if-all-as-appears-before-all-bs/check-if-all-as-appears-before-all-bs.java
 create mode 100644 leetcode/leetcode/check-if-one-string-swap-can-make-strings-equal/README.md
 create mode 100644 leetcode/leetcode/check-if-one-string-swap-can-make-strings-equal/check-if-one-string-swap-can-make-strings-equal.java
 create mode 100644 leetcode/leetcode/check-if-the-sentence-is-pangram/README.md
 create mode 100644 leetcode/leetcode/check-if-the-sentence-is-pangram/check-if-the-sentence-is-pangram.java
 create mode 100644 leetcode/leetcode/check-if-two-string-arrays-are-equivalent/README.md
 create mode 100644 leetcode/leetcode/check-if-two-string-arrays-are-equivalent/check-if-two-string-arrays-are-equivalent.java
 create mode 100644 leetcode/leetcode/climbing-stairs/README.md
 create mode 100644 leetcode/leetcode/climbing-stairs/climbing-stairs.cpp
 create mode 100644 leetcode/leetcode/climbing-stairs/climbing-stairs.java
 create mode 100644 leetcode/leetcode/complement-of-base-10-integer/README.md
 create mode 100644 leetcode/leetcode/complement-of-base-10-integer/complement-of-base-10-integer.java
 create mode 100644 leetcode/leetcode/complex-number-multiplication/README.md
 create mode 100644 leetcode/leetcode/complex-number-multiplication/complex-number-multiplication.java
 create mode 100644 leetcode/leetcode/concatenation-of-array/README.md
 create mode 100644 leetcode/leetcode/concatenation-of-array/concatenation-of-array.java
 create mode 100644 leetcode/leetcode/consecutive-characters/README.md
 create mode 100644 leetcode/leetcode/consecutive-characters/consecutive-characters.java
 create mode 100644 leetcode/leetcode/contains-duplicate/README.md
 create mode 100644 leetcode/leetcode/contains-duplicate/contains-duplicate.java
 create mode 100644 leetcode/leetcode/convert-1d-array-into-2d-array/README.md
 create mode 100644 leetcode/leetcode/convert-1d-array-into-2d-array/convert-1d-array-into-2d-array.java
 create mode 100644 leetcode/leetcode/convert-binary-number-in-a-linked-list-to-integer/README.md
 create mode 100644 leetcode/leetcode/convert-binary-number-in-a-linked-list-to-integer/convert-binary-number-in-a-linked-list-to-integer.java
 create mode 100644 leetcode/leetcode/convert-sorted-array-to-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/convert-sorted-array-to-binary-search-tree/convert-sorted-array-to-binary-search-tree.java
 create mode 100644 leetcode/leetcode/convert-sorted-list-to-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/convert-sorted-list-to-binary-search-tree/convert-sorted-list-to-binary-search-tree.java
 create mode 100644 leetcode/leetcode/count-complete-tree-nodes/README.md
 create mode 100644 leetcode/leetcode/count-complete-tree-nodes/count-complete-tree-nodes.java
 create mode 100644 leetcode/leetcode/count-items-matching-a-rule/README.md
 create mode 100644 leetcode/leetcode/count-items-matching-a-rule/count-items-matching-a-rule.java
 create mode 100644 leetcode/leetcode/count-negative-numbers-in-a-sorted-matrix/README.md
 create mode 100644 leetcode/leetcode/count-negative-numbers-in-a-sorted-matrix/count-negative-numbers-in-a-sorted-matrix.java
 create mode 100644 leetcode/leetcode/count-number-of-pairs-with-absolute-difference-k/README.md
 create mode 100644 leetcode/leetcode/count-number-of-pairs-with-absolute-difference-k/count-number-of-pairs-with-absolute-difference-k.java
 create mode 100644 leetcode/leetcode/count-odd-numbers-in-an-interval-range/README.md
 create mode 100644 leetcode/leetcode/count-odd-numbers-in-an-interval-range/count-odd-numbers-in-an-interval-range.java
 create mode 100644 leetcode/leetcode/count-primes/README.md
 create mode 100644 leetcode/leetcode/count-primes/count-primes.java
 create mode 100644 leetcode/leetcode/create-target-array-in-the-given-order/README.md
 create mode 100644 leetcode/leetcode/create-target-array-in-the-given-order/create-target-array-in-the-given-order.java
 create mode 100644 leetcode/leetcode/delete-leaves-with-a-given-value/README.md
 create mode 100644 leetcode/leetcode/delete-leaves-with-a-given-value/delete-leaves-with-a-given-value.java
 create mode 100644 leetcode/leetcode/delete-node-in-a-linked-list/README.md
 create mode 100644 leetcode/leetcode/delete-node-in-a-linked-list/delete-node-in-a-linked-list.java
 create mode 100644 leetcode/leetcode/delete-the-middle-node-of-a-linked-list/README.md
 create mode 100644 leetcode/leetcode/delete-the-middle-node-of-a-linked-list/delete-the-middle-node-of-a-linked-list.java
 create mode 100644 leetcode/leetcode/design-a-stack-with-increment-operation/README.md
 create mode 100644 leetcode/leetcode/design-a-stack-with-increment-operation/design-a-stack-with-increment-operation.java
 create mode 100644 leetcode/leetcode/design-browser-history/README.md
 create mode 100644 leetcode/leetcode/design-browser-history/design-browser-history.java
 create mode 100644 leetcode/leetcode/design-circular-queue/README.md
 create mode 100644 leetcode/leetcode/design-circular-queue/design-circular-queue.java
 create mode 100644 leetcode/leetcode/design-linked-list/README.md
 create mode 100644 leetcode/leetcode/design-linked-list/design-linked-list.java
 create mode 100644 leetcode/leetcode/destroying-asteroids/README.md
 create mode 100644 leetcode/leetcode/destroying-asteroids/destroying-asteroids.java
 create mode 100644 leetcode/leetcode/detect-capital/README.md
 create mode 100644 leetcode/leetcode/detect-capital/detect-capital.java
 create mode 100644 leetcode/leetcode/diameter-of-binary-tree/README.md
 create mode 100644 leetcode/leetcode/diameter-of-binary-tree/diameter-of-binary-tree.java
 create mode 100644 leetcode/leetcode/encode-and-decode-tinyurl/README.md
 create mode 100644 leetcode/leetcode/encode-and-decode-tinyurl/encode-and-decode-tinyurl.java
 create mode 100644 leetcode/leetcode/fibonacci-number/README.md
 create mode 100644 leetcode/leetcode/fibonacci-number/fibonacci-number.java
 create mode 100644 leetcode/leetcode/final-value-of-variable-after-performing-operations/README.md
 create mode 100644 leetcode/leetcode/final-value-of-variable-after-performing-operations/final-value-of-variable-after-performing-operations.java
 create mode 100644 leetcode/leetcode/find-all-duplicates-in-an-array/README.md
 create mode 100644 leetcode/leetcode/find-all-duplicates-in-an-array/find-all-duplicates-in-an-array.java
 create mode 100644 leetcode/leetcode/find-first-and-last-position-of-element-in-sorted-array/README.md
 create mode 100644 leetcode/leetcode/find-first-and-last-position-of-element-in-sorted-array/find-first-and-last-position-of-element-in-sorted-array.java
 create mode 100644 leetcode/leetcode/find-first-palindromic-string-in-the-array/README.md
 create mode 100644 leetcode/leetcode/find-first-palindromic-string-in-the-array/find-first-palindromic-string-in-the-array.java
 create mode 100644 leetcode/leetcode/find-minimum-in-rotated-sorted-array/README.md
 create mode 100644 leetcode/leetcode/find-minimum-in-rotated-sorted-array/find-minimum-in-rotated-sorted-array.java
 create mode 100644 leetcode/leetcode/find-pivot-index/README.md
 create mode 100644 leetcode/leetcode/find-pivot-index/find-pivot-index.java
 create mode 100644 leetcode/leetcode/find-the-duplicate-number/README.md
 create mode 100644 leetcode/leetcode/find-the-duplicate-number/find-the-duplicate-number.java
 create mode 100644 leetcode/leetcode/find-the-student-that-will-replace-the-chalk/README.md
 create mode 100644 leetcode/leetcode/find-the-student-that-will-replace-the-chalk/find-the-student-that-will-replace-the-chalk.java
 create mode 100644 leetcode/leetcode/find-the-town-judge/README.md
 create mode 100644 leetcode/leetcode/find-the-town-judge/find-the-town-judge.java
 create mode 100644 leetcode/leetcode/finding-pairs-with-a-certain-sum/README.md
 create mode 100644 leetcode/leetcode/finding-pairs-with-a-certain-sum/finding-pairs-with-a-certain-sum.java
 create mode 100644 leetcode/leetcode/first-bad-version/README.md
 create mode 100644 leetcode/leetcode/first-bad-version/first-bad-version.java
 create mode 100644 leetcode/leetcode/first-missing-positive/README.md
 create mode 100644 leetcode/leetcode/first-missing-positive/first-missing-positive.java
 create mode 100644 leetcode/leetcode/first-unique-character-in-a-string/README.md
 create mode 100644 leetcode/leetcode/first-unique-character-in-a-string/first-unique-character-in-a-string.java
 create mode 100644 leetcode/leetcode/flatten-a-multilevel-doubly-linked-list/README.md
 create mode 100644 leetcode/leetcode/flatten-a-multilevel-doubly-linked-list/flatten-a-multilevel-doubly-linked-list.java
 create mode 100644 leetcode/leetcode/flatten-binary-tree-to-linked-list/README.md
 create mode 100644 leetcode/leetcode/flatten-binary-tree-to-linked-list/flatten-binary-tree-to-linked-list.java
 create mode 100644 leetcode/leetcode/guess-number-higher-or-lower/README.md
 create mode 100644 leetcode/leetcode/guess-number-higher-or-lower/guess-number-higher-or-lower.java
 create mode 100644 leetcode/leetcode/implement-strstr/README.md
 create mode 100644 leetcode/leetcode/implement-strstr/implement-strstr.java
 create mode 100644 leetcode/leetcode/insert-into-a-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/insert-into-a-binary-search-tree/insert-into-a-binary-search-tree.java
 create mode 100644 leetcode/leetcode/intersection-of-two-arrays/README.md
 create mode 100644 leetcode/leetcode/intersection-of-two-arrays/intersection-of-two-arrays.java
 create mode 100644 leetcode/leetcode/invert-binary-tree/README.md
 create mode 100644 leetcode/leetcode/invert-binary-tree/invert-binary-tree.java
 create mode 100644 leetcode/leetcode/kth-largest-element-in-an-array/README.md
 create mode 100644 leetcode/leetcode/kth-largest-element-in-an-array/kth-largest-element-in-an-array.java
 create mode 100644 leetcode/leetcode/largest-perimeter-triangle/README.md
 create mode 100644 leetcode/leetcode/largest-perimeter-triangle/largest-perimeter-triangle.java
 create mode 100644 leetcode/leetcode/length-of-last-word/README.md
 create mode 100644 leetcode/leetcode/length-of-last-word/length-of-last-word.java
 create mode 100644 leetcode/leetcode/linked-list-cycle/README.md
 create mode 100644 leetcode/leetcode/linked-list-cycle/linked-list-cycle.java
 create mode 100644 leetcode/leetcode/linked-list-random-node/README.md
 create mode 100644 leetcode/leetcode/linked-list-random-node/linked-list-random-node.java
 create mode 100644 leetcode/leetcode/longest-increasing-subsequence/README.md
 create mode 100644 leetcode/leetcode/longest-increasing-subsequence/longest-increasing-subsequence.java
 create mode 100644 leetcode/leetcode/longest-substring-without-repeating-characters/README.md
 create mode 100644 leetcode/leetcode/longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.java
 create mode 100644 leetcode/leetcode/majority-element/README.md
 create mode 100644 leetcode/leetcode/majority-element/majority-element.java
 create mode 100644 leetcode/leetcode/make-two-arrays-equal-by-reversing-sub-arrays/README.md
 create mode 100644 leetcode/leetcode/make-two-arrays-equal-by-reversing-sub-arrays/make-two-arrays-equal-by-reversing-sub-arrays.java
 create mode 100644 leetcode/leetcode/matrix-diagonal-sum/README.md
 create mode 100644 leetcode/leetcode/matrix-diagonal-sum/matrix-diagonal-sum.java
 create mode 100644 leetcode/leetcode/max-consecutive-ones/README.md
 create mode 100644 leetcode/leetcode/max-consecutive-ones/max-consecutive-ones.java
 create mode 100644 leetcode/leetcode/maximum-binary-tree/README.md
 create mode 100644 leetcode/leetcode/maximum-binary-tree/maximum-binary-tree.java
 create mode 100644 leetcode/leetcode/maximum-depth-of-binary-tree/README.md
 create mode 100644 leetcode/leetcode/maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.java
 create mode 100644 leetcode/leetcode/maximum-depth-of-n-ary-tree/README.md
 create mode 100644 leetcode/leetcode/maximum-depth-of-n-ary-tree/maximum-depth-of-n-ary-tree.java
 create mode 100644 leetcode/leetcode/maximum-ice-cream-bars/README.md
 create mode 100644 leetcode/leetcode/maximum-ice-cream-bars/maximum-ice-cream-bars.java
 create mode 100644 leetcode/leetcode/maximum-number-of-coins-you-can-get/README.md
 create mode 100644 leetcode/leetcode/maximum-number-of-coins-you-can-get/maximum-number-of-coins-you-can-get.java
 create mode 100644 leetcode/leetcode/maximum-product-difference-between-two-pairs/README.md
 create mode 100644 leetcode/leetcode/maximum-product-difference-between-two-pairs/maximum-product-difference-between-two-pairs.java
 create mode 100644 leetcode/leetcode/maximum-product-of-three-numbers/README.md
 create mode 100644 leetcode/leetcode/maximum-product-of-three-numbers/maximum-product-of-three-numbers.java
 create mode 100644 leetcode/leetcode/maximum-product-of-two-elements-in-an-array/README.md
 create mode 100644 leetcode/leetcode/maximum-product-of-two-elements-in-an-array/maximum-product-of-two-elements-in-an-array.java
 create mode 100644 leetcode/leetcode/maximum-product-subarray/README.md
 create mode 100644 leetcode/leetcode/maximum-product-subarray/maximum-product-subarray.java
 create mode 100644 leetcode/leetcode/maximum-subarray/README.md
 create mode 100644 leetcode/leetcode/maximum-subarray/maximum-subarray.java
 create mode 100644 leetcode/leetcode/median-of-two-sorted-arrays/README.md
 create mode 100644 leetcode/leetcode/median-of-two-sorted-arrays/median-of-two-sorted-arrays.java
 create mode 100644 leetcode/leetcode/merge-in-between-linked-lists/README.md
 create mode 100644 leetcode/leetcode/merge-in-between-linked-lists/merge-in-between-linked-lists.java
 create mode 100644 leetcode/leetcode/merge-two-sorted-lists/README.md
 create mode 100644 leetcode/leetcode/merge-two-sorted-lists/merge-two-sorted-lists.java
 create mode 100644 leetcode/leetcode/middle-of-the-linked-list/README.md
 create mode 100644 leetcode/leetcode/middle-of-the-linked-list/middle-of-the-linked-list.java
 create mode 100644 leetcode/leetcode/minimize-maximum-pair-sum-in-array/README.md
 create mode 100644 leetcode/leetcode/minimize-maximum-pair-sum-in-array/minimize-maximum-pair-sum-in-array.java
 create mode 100644 leetcode/leetcode/minimum-absolute-difference/README.md
 create mode 100644 leetcode/leetcode/minimum-absolute-difference/minimum-absolute-difference.java
 create mode 100644 leetcode/leetcode/minimum-moves-to-equal-array-elements-ii/README.md
 create mode 100644 leetcode/leetcode/minimum-moves-to-equal-array-elements-ii/minimum-moves-to-equal-array-elements-ii.java
 create mode 100644 leetcode/leetcode/minimum-number-of-operations-to-move-all-balls-to-each-box/README.md
 create mode 100644 leetcode/leetcode/minimum-number-of-operations-to-move-all-balls-to-each-box/minimum-number-of-operations-to-move-all-balls-to-each-box.java
 create mode 100644 leetcode/leetcode/minimum-number-of-steps-to-make-two-strings-anagram/README.md
 create mode 100644 leetcode/leetcode/minimum-number-of-steps-to-make-two-strings-anagram/minimum-number-of-steps-to-make-two-strings-anagram.java
 create mode 100644 leetcode/leetcode/minimum-operations-to-make-array-equal/README.md
 create mode 100644 leetcode/leetcode/minimum-operations-to-make-array-equal/minimum-operations-to-make-array-equal.java
 create mode 100644 leetcode/leetcode/missing-number/README.md
 create mode 100644 leetcode/leetcode/missing-number/missing-number.java
 create mode 100644 leetcode/leetcode/move-zeroes/README.md
 create mode 100644 leetcode/leetcode/move-zeroes/move-zeroes.java
 create mode 100644 leetcode/leetcode/n-ary-tree-postorder-traversal/README.md
 create mode 100644 leetcode/leetcode/n-ary-tree-postorder-traversal/n-ary-tree-postorder-traversal.java
 create mode 100644 leetcode/leetcode/n-ary-tree-preorder-traversal/README.md
 create mode 100644 leetcode/leetcode/n-ary-tree-preorder-traversal/n-ary-tree-preorder-traversal.java
 create mode 100644 leetcode/leetcode/n-repeated-element-in-size-2n-array/README.md
 create mode 100644 leetcode/leetcode/n-repeated-element-in-size-2n-array/n-repeated-element-in-size-2n-array.java
 create mode 100644 leetcode/leetcode/number-complement/README.md
 create mode 100644 leetcode/leetcode/number-complement/number-complement.java
 create mode 100644 leetcode/leetcode/number-of-laser-beams-in-a-bank/README.md
 create mode 100644 leetcode/leetcode/number-of-laser-beams-in-a-bank/number-of-laser-beams-in-a-bank.java
 create mode 100644 leetcode/leetcode/number-of-segments-in-a-string/README.md
 create mode 100644 leetcode/leetcode/number-of-segments-in-a-string/number-of-segments-in-a-string.java
 create mode 100644 leetcode/leetcode/number-of-steps-to-reduce-a-number-to-zero/README.md
 create mode 100644 leetcode/leetcode/number-of-steps-to-reduce-a-number-to-zero/number-of-steps-to-reduce-a-number-to-zero.java
 create mode 100644 leetcode/leetcode/odd-even-linked-list/README.md
 create mode 100644 leetcode/leetcode/odd-even-linked-list/odd-even-linked-list.java
 create mode 100644 leetcode/leetcode/palindrome-linked-list/README.md
 create mode 100644 leetcode/leetcode/palindrome-linked-list/palindrome-linked-list.java
 create mode 100644 leetcode/leetcode/palindrome-number/README.md
 create mode 100644 leetcode/leetcode/palindrome-number/palindrome-number.java
 create mode 100644 leetcode/leetcode/partition-list/README.md
 create mode 100644 leetcode/leetcode/partition-list/partition-list.java
 create mode 100644 leetcode/leetcode/partitioning-into-minimum-number-of-deci-binary-numbers/README.md
 create mode 100644 leetcode/leetcode/partitioning-into-minimum-number-of-deci-binary-numbers/partitioning-into-minimum-number-of-deci-binary-numbers.java
 create mode 100644 leetcode/leetcode/pascals-triangle-ii/README.md
 create mode 100644 leetcode/leetcode/pascals-triangle-ii/pascals-triangle-ii.java
 create mode 100644 leetcode/leetcode/pascals-triangle/README.md
 create mode 100644 leetcode/leetcode/pascals-triangle/pascals-triangle.java
 create mode 100644 leetcode/leetcode/path-sum/README.md
 create mode 100644 leetcode/leetcode/plus-one/README.md
 create mode 100644 leetcode/leetcode/plus-one/plus-one.java
 create mode 100644 leetcode/leetcode/power-of-two/README.md
 create mode 100644 leetcode/leetcode/power-of-two/power-of-two.java
 create mode 100644 leetcode/leetcode/power-of-two/power-of-two.py
 create mode 100644 leetcode/leetcode/range-sum-of-bst/README.md
 create mode 100644 leetcode/leetcode/range-sum-of-bst/range-sum-of-bst.java
 create mode 100644 leetcode/leetcode/reduce-array-size-to-the-half/README.md
 create mode 100644 leetcode/leetcode/reduce-array-size-to-the-half/reduce-array-size-to-the-half.java
 create mode 100644 leetcode/leetcode/remove-all-adjacent-duplicates-in-string/README.md
 create mode 100644 leetcode/leetcode/remove-all-adjacent-duplicates-in-string/remove-all-adjacent-duplicates-in-string.java
 create mode 100644 leetcode/leetcode/remove-all-occurrences-of-a-substring/README.md
 create mode 100644 leetcode/leetcode/remove-all-occurrences-of-a-substring/remove-all-occurrences-of-a-substring.java
 create mode 100644 leetcode/leetcode/remove-duplicates-from-sorted-array/README.md
 create mode 100644 leetcode/leetcode/remove-duplicates-from-sorted-array/remove-duplicates-from-sorted-array.java
 create mode 100644 leetcode/leetcode/remove-duplicates-from-sorted-list-ii/README.md
 create mode 100644 leetcode/leetcode/remove-duplicates-from-sorted-list-ii/remove-duplicates-from-sorted-list-ii.java
 create mode 100644 leetcode/leetcode/remove-element/README.md
 create mode 100644 leetcode/leetcode/remove-element/remove-element.java
 create mode 100644 leetcode/leetcode/remove-linked-list-elements/README.md
 create mode 100644 leetcode/leetcode/remove-linked-list-elements/remove-linked-list-elements.java
 create mode 100644 leetcode/leetcode/remove-nth-node-from-end-of-list/README.md
 create mode 100644 leetcode/leetcode/remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.java
 create mode 100644 leetcode/leetcode/reorder-list/README.md
 create mode 100644 leetcode/leetcode/reorder-list/reorder-list.java
 create mode 100644 leetcode/leetcode/reordered-power-of-2/README.md
 create mode 100644 leetcode/leetcode/reordered-power-of-2/reordered-power-of-2.java
 create mode 100644 leetcode/leetcode/reverse-integer/README.md
 create mode 100644 leetcode/leetcode/reverse-integer/reverse-integer.java
 create mode 100644 leetcode/leetcode/reverse-linked-list-ii/README.md
 create mode 100644 leetcode/leetcode/reverse-linked-list-ii/reverse-linked-list-ii.java
 create mode 100644 leetcode/leetcode/reverse-linked-list/README.md
 create mode 100644 leetcode/leetcode/reverse-linked-list/reverse-linked-list.java
 create mode 100644 leetcode/leetcode/reverse-nodes-in-k-group/README.md
 create mode 100644 leetcode/leetcode/reverse-nodes-in-k-group/reverse-nodes-in-k-group.java
 create mode 100644 leetcode/leetcode/reverse-string/README.md
 create mode 100644 leetcode/leetcode/reverse-string/reverse-string.java
 create mode 100644 leetcode/leetcode/reverse-words-in-a-string/README.md
 create mode 100644 leetcode/leetcode/reverse-words-in-a-string/reverse-words-in-a-string.java
 create mode 100644 leetcode/leetcode/rotate-array/README.md
 create mode 100644 leetcode/leetcode/rotate-array/rotate-array.java
 create mode 100644 leetcode/leetcode/rotate-list/README.md
 create mode 100644 leetcode/leetcode/rotate-list/rotate-list.java
 create mode 100644 leetcode/leetcode/running-sum-of-1d-array/README.md
 create mode 100644 leetcode/leetcode/running-sum-of-1d-array/running-sum-of-1d-array.java
 create mode 100644 leetcode/leetcode/same-tree/README.md
 create mode 100644 leetcode/leetcode/same-tree/same-tree.java
 create mode 100644 leetcode/leetcode/search-insert-position/README.md
 create mode 100644 leetcode/leetcode/search-insert-position/search-insert-position.java
 create mode 100644 leetcode/leetcode/second-largest-digit-in-a-string/README.md
 create mode 100644 leetcode/leetcode/second-largest-digit-in-a-string/second-largest-digit-in-a-string.java
 create mode 100644 leetcode/leetcode/shuffle-an-array/README.md
 create mode 100644 leetcode/leetcode/shuffle-an-array/shuffle-an-array.java
 create mode 100644 leetcode/leetcode/sign-of-the-product-of-an-array/README.md
 create mode 100644 leetcode/leetcode/sign-of-the-product-of-an-array/sign-of-the-product-of-an-array.java
 create mode 100644 leetcode/leetcode/simple-bank-system/README.md
 create mode 100644 leetcode/leetcode/simple-bank-system/simple-bank-system.java
 create mode 100644 leetcode/leetcode/single-element-in-a-sorted-array/README.md
 create mode 100644 leetcode/leetcode/single-element-in-a-sorted-array/single-element-in-a-sorted-array.java
 create mode 100644 leetcode/leetcode/single-number-ii/README.md
 create mode 100644 leetcode/leetcode/single-number-ii/single-number-ii.java
 create mode 100644 leetcode/leetcode/single-number/README.md
 create mode 100644 leetcode/leetcode/single-number/single-number.java
 create mode 100644 leetcode/leetcode/sort-an-array/README.md
 create mode 100644 leetcode/leetcode/sort-an-array/sort-an-array.java
 create mode 100644 leetcode/leetcode/sort-array-by-parity/sort-array-by-parity.java
 create mode 100644 leetcode/leetcode/sort-colors/README.md
 create mode 100644 leetcode/leetcode/sort-colors/sort-colors.java
 create mode 100644 leetcode/leetcode/sort-list/README.md
 create mode 100644 leetcode/leetcode/sort-list/sort-list.java
 create mode 100644 leetcode/leetcode/subdomain-visit-count/README.md
 create mode 100644 leetcode/leetcode/subdomain-visit-count/subdomain-visit-count.java
 create mode 100644 leetcode/leetcode/sum-of-digits-of-string-after-convert/README.md
 create mode 100644 leetcode/leetcode/sum-of-digits-of-string-after-convert/sum-of-digits-of-string-after-convert.java
 create mode 100644 leetcode/leetcode/sum-of-left-leaves/README.md
 create mode 100644 leetcode/leetcode/sum-of-left-leaves/sum-of-left-leaves.java
 create mode 100644 leetcode/leetcode/sum-of-nodes-with-even-valued-grandparent/README.md
 create mode 100644 leetcode/leetcode/sum-of-nodes-with-even-valued-grandparent/sum-of-nodes-with-even-valued-grandparent.java
 create mode 100644 leetcode/leetcode/sum-of-unique-elements/README.md
 create mode 100644 leetcode/leetcode/sum-of-unique-elements/sum-of-unique-elements.java
 create mode 100644 leetcode/leetcode/swap-nodes-in-pairs/README.md
 create mode 100644 leetcode/leetcode/swap-nodes-in-pairs/swap-nodes-in-pairs.java
 create mode 100644 leetcode/leetcode/swapping-nodes-in-a-linked-list/README.md
 create mode 100644 leetcode/leetcode/swapping-nodes-in-a-linked-list/swapping-nodes-in-a-linked-list.java
 create mode 100644 leetcode/leetcode/the-kth-factor-of-n/README.md
 create mode 100644 leetcode/leetcode/the-kth-factor-of-n/the-kth-factor-of-n.java
 create mode 100644 leetcode/leetcode/time-needed-to-buy-tickets/README.md
 create mode 100644 leetcode/leetcode/time-needed-to-buy-tickets/time-needed-to-buy-tickets.java
 create mode 100644 leetcode/leetcode/truncate-sentence/README.md
 create mode 100644 leetcode/leetcode/truncate-sentence/truncate-sentence.java
 create mode 100644 leetcode/leetcode/two-sum-ii-input-array-is-sorted/README.md
 create mode 100644 leetcode/leetcode/two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted.java
 create mode 100644 leetcode/leetcode/two-sum/README.md
 create mode 100644 leetcode/leetcode/two-sum/two-sum.java
 create mode 100644 leetcode/leetcode/unique-number-of-occurrences/README.md
 create mode 100644 leetcode/leetcode/unique-number-of-occurrences/unique-number-of-occurrences.java
 create mode 100644 leetcode/leetcode/valid-parentheses/README.md
 create mode 100644 leetcode/leetcode/valid-parentheses/valid-parentheses.java
 create mode 100644 leetcode/leetcode/valid-perfect-square/README.md
 create mode 100644 leetcode/leetcode/valid-perfect-square/valid-perfect-square.cpp
 create mode 100644 leetcode/leetcode/valid-triangle-number/README.md
 create mode 100644 leetcode/leetcode/valid-triangle-number/valid-triangle-number.java
 create mode 100644 leetcode/leetcode/validate-binary-search-tree/README.md
 create mode 100644 leetcode/leetcode/validate-binary-search-tree/validate-binary-search-tree.java
 create mode 100644 leetcode/leetcode/water-bottles/README.md
 create mode 100644 leetcode/leetcode/water-bottles/water-bottles.java
 create mode 100644 leetcode/leetcode/watering-plants/README.md
 create mode 100644 leetcode/leetcode/watering-plants/watering-plants.java

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..c30cae7dbdbc85dcf9ef9d5e644cdb1bd91d705e
GIT binary patch
literal 6148
zcmeHKI|>3p3{BKx!N$^ZuHX#@(Gz$9LB&QCM6I{-TprDr52CC#f{nZ^$(zaM&9bl9
zY(zw-=k-KnBq9ymP_7obX7|lI*2|0n;W%R@2U*MJvN-NL)$bF=ZDc1KT&HLL?y%p+
zx$lY0QUNMJ1*iZOpaNehV7(XC3<DXd02QDD4+ZS|P~e6&u?_T32ZE0PzyZ>3So<si
zES3P)#5NEam<AOXRLv1XgN}U3x|-Mq23<6V56vfQPAKY6$N9y}MQb1<6`%sI3iM+;
zvi?7Zf0+MYN!(EZD)3hd=wP;(P4P<ETRSgjy|%!YaI3k&&9HU~g12L!w_|Lq9gn>z
a>WZy#zb3YUPDkG9K>iGvE;K6eYX$DxiWPYP

literal 0
HcmV?d00001

diff --git a/leetcode/leetcode/0001-two-sum/0001-two-sum.cpp b/leetcode/leetcode/0001-two-sum/0001-two-sum.cpp
new file mode 100644
index 0000000..43cb7b7
--- /dev/null
+++ b/leetcode/leetcode/0001-two-sum/0001-two-sum.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        for(int i=0;i<nums.size()-1;i++){
+            for(int j=i+1;j<nums.size();j++){
+                if(nums[i]+nums[j]==target){
+                    return{i,j};
+                }
+            }
+        }
+        return {};
+
+    }
+};
\ No newline at end of file
diff --git a/leetcode/leetcode/0001-two-sum/0001-two-sum.java b/leetcode/leetcode/0001-two-sum/0001-two-sum.java
new file mode 100644
index 0000000..c7bc327
--- /dev/null
+++ b/leetcode/leetcode/0001-two-sum/0001-two-sum.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+
+        int[] ans = {-1,-1};
+        
+        for(int i = 0;i<nums.length;i++){
+            if(map.containsKey(target-nums[i])){
+                ans[0] = i;
+                ans[1] = map.get(target-nums[i]);
+                return ans;
+            }
+            map.put(nums[i],i);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0001-two-sum/NOTES.md b/leetcode/leetcode/0001-two-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0001-two-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0001-two-sum/README.md b/leetcode/leetcode/0001-two-sum/README.md
new file mode 100644
index 0000000..2958322
--- /dev/null
+++ b/leetcode/leetcode/0001-two-sum/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/two-sum">1. Two Sum</a></h2><h3>Easy</h3><hr><p>Given an array of integers <code>nums</code>&nbsp;and an integer <code>target</code>, return <em>indices of the two numbers such that they add up to <code>target</code></em>.</p>
+
+<p>You may assume that each input would have <strong><em>exactly</em> one solution</strong>, and you may not use the <em>same</em> element twice.</p>
+
+<p>You can return the answer in any order.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,7,11,15], target = 9
+<strong>Output:</strong> [0,1]
+<strong>Explanation:</strong> Because nums[0] + nums[1] == 9, we return [0, 1].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,2,4], target = 6
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,3], target = 6
+<strong>Output:</strong> [0,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= target &lt;= 10<sup>9</sup></code></li>
+	<li><strong>Only one valid answer exists.</strong></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow-up:&nbsp;</strong>Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code><font face="monospace">&nbsp;</font>time complexity?
\ No newline at end of file
diff --git a/leetcode/leetcode/0003-longest-substring-without-repeating-characters/0003-longest-substring-without-repeating-characters.java b/leetcode/leetcode/0003-longest-substring-without-repeating-characters/0003-longest-substring-without-repeating-characters.java
new file mode 100644
index 0000000..0d0174b
--- /dev/null
+++ b/leetcode/leetcode/0003-longest-substring-without-repeating-characters/0003-longest-substring-without-repeating-characters.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        boolean[] freq = new boolean[256];
+        int start = 0;
+        int end = 0;
+        int max = 0;
+        while(end<s.length()){
+            if(freq[(int) s.charAt(end)]){
+                freq[(int) s.charAt(start)] = false;
+                start++;
+            }
+            else{
+                freq[(int) s.charAt(end)] = true;
+                end++; 
+            }
+            max = Math.max(max,end-start);
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0003-longest-substring-without-repeating-characters/README.md b/leetcode/leetcode/0003-longest-substring-without-repeating-characters/README.md
new file mode 100644
index 0000000..76430b4
--- /dev/null
+++ b/leetcode/leetcode/0003-longest-substring-without-repeating-characters/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/longest-substring-without-repeating-characters">3. Longest Substring Without Repeating Characters</a></h2><h3>Medium</h3><hr><p>Given a string <code>s</code>, find the length of the <strong>longest</strong> <span data-keyword="substring-nonempty"><strong>substring</strong></span> without duplicate characters.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcabcbb&quot;
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The answer is &quot;abc&quot;, with the length of 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;bbbbb&quot;
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The answer is &quot;b&quot;, with the length of 1.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;pwwkew&quot;
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The answer is &quot;wke&quot;, with the length of 3.
+Notice that the answer must be a substring, &quot;pwke&quot; is a subsequence and not a substring.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of English letters, digits, symbols and spaces.</li>
+</ul>
diff --git a/leetcode/leetcode/0005-longest-palindromic-substring/0005-longest-palindromic-substring.java b/leetcode/leetcode/0005-longest-palindromic-substring/0005-longest-palindromic-substring.java
new file mode 100644
index 0000000..7e6e3ea
--- /dev/null
+++ b/leetcode/leetcode/0005-longest-palindromic-substring/0005-longest-palindromic-substring.java
@@ -0,0 +1,34 @@
+class Solution {
+    public String longestPalindrome(String s) {
+        int n = s.length();
+        boolean[][] dp = new boolean[n][n];
+        int[] ans = new int[]{0, 0};
+        
+        for (int i = 0; i < n; i++) {
+            dp[i][i] = true;
+        }
+        
+        for (int i = 0; i < n - 1; i++) {
+            if (s.charAt(i) == s.charAt(i + 1)) {
+                dp[i][i + 1] = true;
+                ans[0] = i;
+                ans[1] = i + 1;
+            }
+        }
+        
+        for (int diff = 2; diff < n; diff++) {
+            for (int i = 0; i < n - diff; i++) {
+                int j = i + diff;
+                if (s.charAt(i) == s.charAt(j) && dp[i + 1][j - 1]) {
+                    dp[i][j] = true;
+                    ans[0] = i;
+                    ans[1] = j;
+                }
+            }
+        }
+        
+        int i = ans[0];
+        int j = ans[1];
+        return s.substring(i, j + 1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0005-longest-palindromic-substring/NOTES.md b/leetcode/leetcode/0005-longest-palindromic-substring/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0005-longest-palindromic-substring/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0005-longest-palindromic-substring/README.md b/leetcode/leetcode/0005-longest-palindromic-substring/README.md
new file mode 100644
index 0000000..ea3d657
--- /dev/null
+++ b/leetcode/leetcode/0005-longest-palindromic-substring/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/longest-palindromic-substring/">5. Longest Palindromic Substring</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code>, return <em>the longest</em> <span data-keyword="palindromic-string"><em>palindromic</em></span> <span data-keyword="substring-nonempty"><em>substring</em></span> in <code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "babad"
+<strong>Output:</strong> "bab"
+<strong>Explanation:</strong> "aba" is also a valid answer.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "cbbd"
+<strong>Output:</strong> "bb"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 1000</code></li>
+	<li><code>s</code> consist of only digits and English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0009-palindrome-number/0009-palindrome-number.java b/leetcode/leetcode/0009-palindrome-number/0009-palindrome-number.java
new file mode 100644
index 0000000..e8fffd6
--- /dev/null
+++ b/leetcode/leetcode/0009-palindrome-number/0009-palindrome-number.java
@@ -0,0 +1,23 @@
+class Solution {
+    public boolean check(ArrayList<Integer> list){
+        int low = 0;
+        int high = list.size()-1;
+        while(low<high){
+            if(list.get(low) != list.get(high)){
+                return false;
+            }
+            low++;
+            high--;
+        }
+        return true;
+    }
+    public boolean isPalindrome(int x) {
+        if(x<0) return false;
+        ArrayList<Integer> list = new ArrayList<>();
+        while(x!=0){
+            list.add(x%10);
+            x = x/10;
+        }
+        return check(list);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0009-palindrome-number/NOTES.md b/leetcode/leetcode/0009-palindrome-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0009-palindrome-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0011-container-with-most-water/0011-container-with-most-water.java b/leetcode/leetcode/0011-container-with-most-water/0011-container-with-most-water.java
new file mode 100644
index 0000000..4f20893
--- /dev/null
+++ b/leetcode/leetcode/0011-container-with-most-water/0011-container-with-most-water.java
@@ -0,0 +1,28 @@
+class Solution {
+    public int maxArea(int[] height) {
+
+        // Initilization the two pointer 
+        int low  = 0;
+        int high = height.length -1;
+
+        int ans = Integer.MIN_VALUE;
+        while(low<high){
+            // finding the min height for the water level
+            int currHeight = Math.min(height[low],height[high]); 
+
+            // finding the width
+            int width  = high-low;
+
+            // calculating the area and updating the maximum area
+            ans = Math.max(ans,currHeight*width);
+
+            // Changing the pointer which has minimum height
+            if(height[low]>height[high]){
+                high--;
+            } else{
+                low++;
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0011-container-with-most-water/NOTES.md b/leetcode/leetcode/0011-container-with-most-water/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0011-container-with-most-water/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0011-container-with-most-water/README.md b/leetcode/leetcode/0011-container-with-most-water/README.md
new file mode 100644
index 0000000..d639cbc
--- /dev/null
+++ b/leetcode/leetcode/0011-container-with-most-water/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/container-with-most-water">11. Container With Most Water</a></h2><h3>Medium</h3><hr><p>You are given an integer array <code>height</code> of length <code>n</code>. There are <code>n</code> vertical lines drawn such that the two endpoints of the <code>i<sup>th</sup></code> line are <code>(i, 0)</code> and <code>(i, height[i])</code>.</p>
+
+<p>Find two lines that together with the x-axis form a container, such that the container contains the most water.</p>
+
+<p>Return <em>the maximum amount of water a container can store</em>.</p>
+
+<p><strong>Notice</strong> that you may not slant the container.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/17/question_11.jpg" style="width: 600px; height: 287px;" />
+<pre>
+<strong>Input:</strong> height = [1,8,6,2,5,4,8,3,7]
+<strong>Output:</strong> 49
+<strong>Explanation:</strong> The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> height = [1,1]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == height.length</code></li>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= height[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0013-roman-to-integer/0013-roman-to-integer.java b/leetcode/leetcode/0013-roman-to-integer/0013-roman-to-integer.java
new file mode 100644
index 0000000..b8b9206
--- /dev/null
+++ b/leetcode/leetcode/0013-roman-to-integer/0013-roman-to-integer.java
@@ -0,0 +1,77 @@
+class Solution {
+    public int romanToInt(String s) {
+        int ans = 0;
+        int index = 0;
+
+        while(index<s.length()){
+            char c = s.charAt(index);
+            if(c == 'I'){
+                if(index+1<s.length()){
+                    if(s.charAt(index+1) == 'V'){
+                        ans+=4;
+                        index+=2;
+                    }else if(s.charAt(index+1) == 'X'){
+                        ans+=9;
+                        index+=2;
+                    }else {
+                        ans+=1;
+                        index+=1;
+                    }
+                }else{
+                    ans+=1;
+                    index+=1;
+                }
+            }else if(c== 'V'){
+                ans+=5;
+                index++;
+
+            }else if(c == 'X'){
+                if(index+1<s.length()){
+                    if(s.charAt(index+1) == 'L'){
+                        ans+=40;
+                        index+=2;
+                    }else if(s.charAt(index+1) == 'C'){
+                        ans+=90;
+                        index+=2;
+                    }else {
+                        ans+=10;
+                        index+=1;
+                    }
+                }else{
+                    ans+=10;
+                    index+=1;
+                }
+
+            }else if(c == 'L'){
+                ans+=50;
+                index++;
+                
+            }else if(c == 'C'){
+                if(index+1<s.length()){
+                    if(s.charAt(index+1) == 'D'){
+                        ans+=400;
+                        index+=2;
+                    }else if(s.charAt(index+1) == 'M'){
+                        ans+=900;
+                        index+=2;
+                    }else {
+                        ans+=100;
+                        index+=1;
+                    }
+                }else{
+                    ans+=100;
+                    index+=1;
+                }
+
+            }else if(c == 'D'){
+                ans+=500;
+                index++;
+
+            }else if(c == 'M'){
+                ans+=1000;
+                index++;
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0013-roman-to-integer/NOTES.md b/leetcode/leetcode/0013-roman-to-integer/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0013-roman-to-integer/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0013-roman-to-integer/README.md b/leetcode/leetcode/0013-roman-to-integer/README.md
new file mode 100644
index 0000000..0cff3a1
--- /dev/null
+++ b/leetcode/leetcode/0013-roman-to-integer/README.md
@@ -0,0 +1,57 @@
+<h2><a href="https://leetcode.com/problems/roman-to-integer">13. Roman to Integer</a></h2><h3>Easy</h3><hr><p>Roman numerals are represented by seven different symbols:&nbsp;<code>I</code>, <code>V</code>, <code>X</code>, <code>L</code>, <code>C</code>, <code>D</code> and <code>M</code>.</p>
+
+<pre>
+<strong>Symbol</strong>       <strong>Value</strong>
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000</pre>
+
+<p>For example,&nbsp;<code>2</code> is written as <code>II</code>&nbsp;in Roman numeral, just two ones added together. <code>12</code> is written as&nbsp;<code>XII</code>, which is simply <code>X + II</code>. The number <code>27</code> is written as <code>XXVII</code>, which is <code>XX + V + II</code>.</p>
+
+<p>Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not <code>IIII</code>. Instead, the number four is written as <code>IV</code>. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as <code>IX</code>. There are six instances where subtraction is used:</p>
+
+<ul>
+	<li><code>I</code> can be placed before <code>V</code> (5) and <code>X</code> (10) to make 4 and 9.&nbsp;</li>
+	<li><code>X</code> can be placed before <code>L</code> (50) and <code>C</code> (100) to make 40 and 90.&nbsp;</li>
+	<li><code>C</code> can be placed before <code>D</code> (500) and <code>M</code> (1000) to make 400 and 900.</li>
+</ul>
+
+<p>Given a roman numeral, convert it to an integer.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;III&quot;
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> III = 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;LVIII&quot;
+<strong>Output:</strong> 58
+<strong>Explanation:</strong> L = 50, V= 5, III = 3.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;MCMXCIV&quot;
+<strong>Output:</strong> 1994
+<strong>Explanation:</strong> M = 1000, CM = 900, XC = 90 and IV = 4.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 15</code></li>
+	<li><code>s</code> contains only&nbsp;the characters <code>(&#39;I&#39;, &#39;V&#39;, &#39;X&#39;, &#39;L&#39;, &#39;C&#39;, &#39;D&#39;, &#39;M&#39;)</code>.</li>
+	<li>It is <strong>guaranteed</strong>&nbsp;that <code>s</code> is a valid roman numeral in the range <code>[1, 3999]</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0014-longest-common-prefix/0014-longest-common-prefix.java b/leetcode/leetcode/0014-longest-common-prefix/0014-longest-common-prefix.java
new file mode 100644
index 0000000..a2dd07c
--- /dev/null
+++ b/leetcode/leetcode/0014-longest-common-prefix/0014-longest-common-prefix.java
@@ -0,0 +1,21 @@
+class Solution {
+    public String longestCommonPrefix(String[] strs) {
+        StringBuilder sb = new StringBuilder(strs[0]);
+        // sb = strs[0];
+        for(int i = 1;i<strs.length;i++){
+            String curr = strs[i];
+            
+            if(curr.length()<sb.length()){
+                sb.setLength(curr.length());
+            }
+            for(int j = 0;j<Math.min(sb.length(),curr.length());j++){
+                if(curr.charAt(j)!=sb.charAt(j)){
+                    sb.setLength(j);
+                    break;
+                }
+            }
+            
+        }
+        return sb.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0014-longest-common-prefix/NOTES.md b/leetcode/leetcode/0014-longest-common-prefix/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0014-longest-common-prefix/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0014-longest-common-prefix/README.md b/leetcode/leetcode/0014-longest-common-prefix/README.md
new file mode 100644
index 0000000..712faf3
--- /dev/null
+++ b/leetcode/leetcode/0014-longest-common-prefix/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/longest-common-prefix/">14. Longest Common Prefix</a></h2><h3>Easy</h3><hr><div><p>Write a function to find the longest common prefix string amongst an array of strings.</p>
+
+<p>If there is no common prefix, return an empty string <code>""</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> strs = ["flower","flow","flight"]
+<strong>Output:</strong> "fl"
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> strs = ["dog","racecar","car"]
+<strong>Output:</strong> ""
+<strong>Explanation:</strong> There is no common prefix among the input strings.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= strs.length &lt;= 200</code></li>
+	<li><code>0 &lt;= strs[i].length &lt;= 200</code></li>
+	<li><code>strs[i]</code> consists of only lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0015-3sum/0015-3sum.java b/leetcode/leetcode/0015-3sum/0015-3sum.java
new file mode 100644
index 0000000..34d0dae
--- /dev/null
+++ b/leetcode/leetcode/0015-3sum/0015-3sum.java
@@ -0,0 +1,32 @@
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Set<List<Integer>> set= new HashSet<>();
+        Arrays.sort(nums);
+        for(int i = 0;i<nums.length-2;i++){
+            int left = i+1;
+            int right = nums.length - 1;
+            while(left<right){
+                int sum = nums[i]+nums[left]+nums[right];
+                if(sum == 0){
+                    List<Integer> list = new ArrayList<>();
+                    list.add(nums[i]);
+                    list.add(nums[left]);
+                    list.add(nums[right]);
+                    set.add(list);
+                    left++;
+                    right--;
+
+                }else if(sum<0){
+                    left++;
+                }else{
+                    right--;
+                }
+            }
+        }
+        List<List<Integer>> result = new ArrayList<>();
+        for(List<Integer> list: set){
+            result.add(list);
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0015-3sum/README.md b/leetcode/leetcode/0015-3sum/README.md
new file mode 100644
index 0000000..84e5854
--- /dev/null
+++ b/leetcode/leetcode/0015-3sum/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/3sum">15. 3Sum</a></h2><h3>Medium</h3><hr><p>Given an integer array nums, return all the triplets <code>[nums[i], nums[j], nums[k]]</code> such that <code>i != j</code>, <code>i != k</code>, and <code>j != k</code>, and <code>nums[i] + nums[j] + nums[k] == 0</code>.</p>
+
+<p>Notice that the solution set must not contain duplicate triplets.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [-1,0,1,2,-1,-4]
+<strong>Output:</strong> [[-1,-1,2],[-1,0,1]]
+<strong>Explanation:</strong> 
+nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.
+nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.
+nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.
+The distinct triplets are [-1,0,1] and [-1,-1,2].
+Notice that the order of the output and the order of the triplets does not matter.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,1,1]
+<strong>Output:</strong> []
+<strong>Explanation:</strong> The only possible triplet does not sum up to 0.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,0,0]
+<strong>Output:</strong> [[0,0,0]]
+<strong>Explanation:</strong> The only possible triplet sums up to 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= nums.length &lt;= 3000</code></li>
+	<li><code>-10<sup>5</sup> &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0016-3sum-closest/0016-3sum-closest.java b/leetcode/leetcode/0016-3sum-closest/0016-3sum-closest.java
new file mode 100644
index 0000000..1350ef2
--- /dev/null
+++ b/leetcode/leetcode/0016-3sum-closest/0016-3sum-closest.java
@@ -0,0 +1,24 @@
+class Solution {
+    public int threeSumClosest(int[] nums, int target) {
+        Arrays.sort(nums);
+        int ans = Integer.MAX_VALUE;
+        int sum = Integer.MAX_VALUE;
+        for(int i = 0;i<nums.length-1;i++){
+            int start = i+1;
+            int end   = nums.length-1;
+            while(start<end){
+                int currentSum = nums[i]+nums[start]+nums[end];
+                if(Math.abs(currentSum-target)< sum){
+                    ans = currentSum;
+                    sum = Math.abs(currentSum-target);
+                }
+                if(currentSum>target){
+                    end--;
+                }else{
+                    start++;
+                }
+             }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0016-3sum-closest/README.md b/leetcode/leetcode/0016-3sum-closest/README.md
new file mode 100644
index 0000000..a6789ba
--- /dev/null
+++ b/leetcode/leetcode/0016-3sum-closest/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/3sum-closest">16. 3Sum Closest</a></h2><h3>Medium</h3><hr><p>Given an integer array <code>nums</code> of length <code>n</code> and an integer <code>target</code>, find three integers in <code>nums</code> such that the sum is closest to <code>target</code>.</p>
+
+<p>Return <em>the sum of the three integers</em>.</p>
+
+<p>You may assume that each input would have exactly one solution.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [-1,2,1,-4], target = 1
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,0,0], target = 1
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The sum that is closest to the target is 0. (0 + 0 + 0 = 0).
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= nums.length &lt;= 500</code></li>
+	<li><code>-1000 &lt;= nums[i] &lt;= 1000</code></li>
+	<li><code>-10<sup>4</sup> &lt;= target &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0020-valid-parentheses/0020-valid-parentheses.java b/leetcode/leetcode/0020-valid-parentheses/0020-valid-parentheses.java
new file mode 100644
index 0000000..63bc673
--- /dev/null
+++ b/leetcode/leetcode/0020-valid-parentheses/0020-valid-parentheses.java
@@ -0,0 +1,22 @@
+class Solution {
+    public boolean isValid(String s) {
+        Stack<Character> stack = new Stack<>();
+        for(int i = 0;i<s.length();i++){
+            char c = s.charAt(i);
+
+            if(c == '('){
+                stack.push(')');
+            }else if(c == '{'){
+                stack.push('}');
+            }else if(c == '['){
+                stack.push(']');
+            }else if(!stack.isEmpty() && stack.peek() == c ){
+                stack.pop();
+            }else{
+                return false;
+            }
+        }
+
+        return stack.isEmpty();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0020-valid-parentheses/README.md b/leetcode/leetcode/0020-valid-parentheses/README.md
new file mode 100644
index 0000000..cd6320f
--- /dev/null
+++ b/leetcode/leetcode/0020-valid-parentheses/README.md
@@ -0,0 +1,50 @@
+<h2><a href="https://leetcode.com/problems/valid-parentheses">20. Valid Parentheses</a></h2><h3>Easy</h3><hr><p>Given a string <code>s</code> containing just the characters <code>&#39;(&#39;</code>, <code>&#39;)&#39;</code>, <code>&#39;{&#39;</code>, <code>&#39;}&#39;</code>, <code>&#39;[&#39;</code> and <code>&#39;]&#39;</code>, determine if the input string is valid.</p>
+
+<p>An input string is valid if:</p>
+
+<ol>
+	<li>Open brackets must be closed by the same type of brackets.</li>
+	<li>Open brackets must be closed in the correct order.</li>
+	<li>Every close bracket has a corresponding open bracket of the same type.</li>
+</ol>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s = &quot;()&quot;</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s = &quot;()[]{}&quot;</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s = &quot;(]&quot;</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">false</span></p>
+</div>
+
+<p><strong class="example">Example 4:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s = &quot;([])&quot;</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of parentheses only <code>&#39;()[]{}&#39;</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0021-merge-two-sorted-lists/0021-merge-two-sorted-lists.java b/leetcode/leetcode/0021-merge-two-sorted-lists/0021-merge-two-sorted-lists.java
new file mode 100644
index 0000000..d464062
--- /dev/null
+++ b/leetcode/leetcode/0021-merge-two-sorted-lists/0021-merge-two-sorted-lists.java
@@ -0,0 +1,37 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+        if(list1==null) return list2;
+        if(list2==null) return list1;
+        ListNode head = list1;
+        if(head.val>list2.val){
+            head = list2;
+            list2 = list2.next;
+        }else{
+            list1 = list1.next;
+        }
+        ListNode temp = head;
+        while(list1!=null && list2!=null){
+            if(list1.val>list2.val){
+                temp.next = list2;
+                list2 = list2.next;
+            }else{
+                temp.next = list1;
+                list1 = list1.next;
+            }
+            temp = temp.next;
+        }
+        if(list1==null) temp.next = list2;
+        else if(list2==null) temp.next = list1;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0021-merge-two-sorted-lists/README.md b/leetcode/leetcode/0021-merge-two-sorted-lists/README.md
new file mode 100644
index 0000000..859aec2
--- /dev/null
+++ b/leetcode/leetcode/0021-merge-two-sorted-lists/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/merge-two-sorted-lists">21. Merge Two Sorted Lists</a></h2><h3>Easy</h3><hr><p>You are given the heads of two sorted linked lists <code>list1</code> and <code>list2</code>.</p>
+
+<p>Merge the two lists into one <strong>sorted</strong> list. The list should be made by splicing together the nodes of the first two lists.</p>
+
+<p>Return <em>the head of the merged linked list</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg" style="width: 662px; height: 302px;" />
+<pre>
+<strong>Input:</strong> list1 = [1,2,4], list2 = [1,3,4]
+<strong>Output:</strong> [1,1,2,3,4,4]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> list1 = [], list2 = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> list1 = [], list2 = [0]
+<strong>Output:</strong> [0]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in both lists is in the range <code>[0, 50]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li>Both <code>list1</code> and <code>list2</code> are sorted in <strong>non-decreasing</strong> order.</li>
+</ul>
diff --git a/leetcode/leetcode/0023-merge-k-sorted-lists/0023-merge-k-sorted-lists.java b/leetcode/leetcode/0023-merge-k-sorted-lists/0023-merge-k-sorted-lists.java
new file mode 100644
index 0000000..8a6c733
--- /dev/null
+++ b/leetcode/leetcode/0023-merge-k-sorted-lists/0023-merge-k-sorted-lists.java
@@ -0,0 +1,45 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public class Pair implements Comparable<Pair>{
+        ListNode head;
+
+        Pair(ListNode head){
+            this.head = head;
+        }
+        @Override
+        public int compareTo(Pair p){
+            return this.head.val - p.head.val;
+        }
+    }
+    public ListNode mergeKLists(ListNode[] lists) {
+        if(lists.length == 0) return null;
+        PriorityQueue<Pair> pq = new PriorityQueue<>();
+
+        for(int i = 0;i<lists.length;i++){
+            ListNode head = lists[i];
+            if(head!=null) pq.add(new Pair(head));
+        }
+
+        ListNode head = new ListNode(0);
+        ListNode tail = head;
+        while(pq.size()!=0){
+            ListNode temp = pq.remove().head;
+            if(temp.next!=null) pq.add(new Pair(temp.next));
+            tail.next = temp;
+            tail = tail.next;
+        }
+        tail.next = null;
+        return head.next;
+        
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0023-merge-k-sorted-lists/README.md b/leetcode/leetcode/0023-merge-k-sorted-lists/README.md
new file mode 100644
index 0000000..39f48ee
--- /dev/null
+++ b/leetcode/leetcode/0023-merge-k-sorted-lists/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/merge-k-sorted-lists/description/">23. Merge k Sorted Lists</a></h2><h3>Hard</h3><hr><p>You are given an array of <code>k</code> linked-lists <code>lists</code>, each linked-list is sorted in ascending order.</p>
+
+<p><em>Merge all the linked-lists into one sorted linked-list and return it.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> lists = [[1,4,5],[1,3,4],[2,6]]
+<strong>Output:</strong> [1,1,2,3,4,4,5,6]
+<strong>Explanation:</strong> The linked-lists are:
+[
+  1-&gt;4-&gt;5,
+  1-&gt;3-&gt;4,
+  2-&gt;6
+]
+merging them into one sorted list:
+1-&gt;1-&gt;2-&gt;3-&gt;4-&gt;4-&gt;5-&gt;6
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> lists = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> lists = [[]]
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>k == lists.length</code></li>
+	<li><code>0 &lt;= k &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= lists[i].length &lt;= 500</code></li>
+	<li><code>-10<sup>4</sup> &lt;= lists[i][j] &lt;= 10<sup>4</sup></code></li>
+	<li><code>lists[i]</code> is sorted in <strong>ascending order</strong>.</li>
+	<li>The sum of <code>lists[i].length</code> will not exceed <code>10<sup>4</sup></code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0024-swap-nodes-in-pairs/0024-swap-nodes-in-pairs.java b/leetcode/leetcode/0024-swap-nodes-in-pairs/0024-swap-nodes-in-pairs.java
new file mode 100644
index 0000000..87f6bfb
--- /dev/null
+++ b/leetcode/leetcode/0024-swap-nodes-in-pairs/0024-swap-nodes-in-pairs.java
@@ -0,0 +1,20 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode swapPairs(ListNode head) {
+        if(head == null || head.next == null) return head;
+        int val = head.val;
+        head.val = head.next.val;
+        head.next.val = val;
+        head.next.next = swapPairs(head.next.next);
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0024-swap-nodes-in-pairs/NOTES.md b/leetcode/leetcode/0024-swap-nodes-in-pairs/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0024-swap-nodes-in-pairs/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0024-swap-nodes-in-pairs/README.md b/leetcode/leetcode/0024-swap-nodes-in-pairs/README.md
new file mode 100644
index 0000000..f410f5b
--- /dev/null
+++ b/leetcode/leetcode/0024-swap-nodes-in-pairs/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/swap-nodes-in-pairs/">24. Swap Nodes in Pairs</a></h2><h3>Medium</h3><hr><div><p>Given a&nbsp;linked list, swap every two adjacent nodes and return its head. You must solve the problem without&nbsp;modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg" style="width: 422px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4]
+<strong>Output:</strong> [2,1,4,3]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the&nbsp;list&nbsp;is in the range <code>[0, 100]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0025-reverse-nodes-in-k-group/0025-reverse-nodes-in-k-group.java b/leetcode/leetcode/0025-reverse-nodes-in-k-group/0025-reverse-nodes-in-k-group.java
new file mode 100644
index 0000000..53b5f5f
--- /dev/null
+++ b/leetcode/leetcode/0025-reverse-nodes-in-k-group/0025-reverse-nodes-in-k-group.java
@@ -0,0 +1,46 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode reverse(ListNode head){
+        ListNode prev =  null;
+        ListNode curr = head;
+        ListNode next = head.next;
+        while(next!=null){
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+            next = next.next;
+        }
+        curr.next = prev;
+        return curr;
+    }
+    public ListNode reverseKGroup(ListNode head, int k) {
+        if(k == 1) return head;
+        if(head == null || head.next == null) return head;
+        int count = 1;
+        ListNode temp = head;
+        while(temp.next!=null ){
+            temp = temp.next;
+            count++;
+            if(count == k) break;
+        }
+        if(count<k){
+            return head;
+        }else{
+            ListNode node = temp.next;
+            node = reverseKGroup(node,k);
+            temp.next = null;
+            ListNode result = reverse(head);
+            head.next = node;
+            return result;
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0025-reverse-nodes-in-k-group/README.md b/leetcode/leetcode/0025-reverse-nodes-in-k-group/README.md
new file mode 100644
index 0000000..546ce7c
--- /dev/null
+++ b/leetcode/leetcode/0025-reverse-nodes-in-k-group/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/reverse-nodes-in-k-group">25. Reverse Nodes in k-Group</a></h2><h3>Hard</h3><hr><p>Given the <code>head</code> of a linked list, reverse the nodes of the list <code>k</code> at a time, and return <em>the modified list</em>.</p>
+
+<p><code>k</code> is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of <code>k</code> then left-out nodes, in the end, should remain as it is.</p>
+
+<p>You may not alter the values in the list&#39;s nodes, only nodes themselves may be changed.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex1.jpg" style="width: 542px; height: 222px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5], k = 2
+<strong>Output:</strong> [2,1,4,3,5]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg" style="width: 542px; height: 222px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5], k = 3
+<strong>Output:</strong> [3,2,1,4,5]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is <code>n</code>.</li>
+	<li><code>1 &lt;= k &lt;= n &lt;= 5000</code></li>
+	<li><code>0 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong> Can you solve the problem in <code>O(1)</code> extra memory space?</p>
diff --git a/leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/0028-find-the-index-of-the-first-occurrence-in-a-string.java b/leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/0028-find-the-index-of-the-first-occurrence-in-a-string.java
new file mode 100644
index 0000000..5f3b358
--- /dev/null
+++ b/leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/0028-find-the-index-of-the-first-occurrence-in-a-string.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int strStr(String haystack, String needle) {
+        if(needle.length()>haystack.length()) return -1;
+        if(needle.length()==haystack.length()) return needle.equals(haystack) ? 0 : -1;
+        int curr = 0;
+        int size = needle.length();
+        int terminalIndex = curr+size;
+        while(terminalIndex!=haystack.length()+1){
+            if(haystack.substring(curr,terminalIndex).equals(needle)) return curr;
+            curr++;
+            terminalIndex++;
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/NOTES.md b/leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/README.md b/leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/README.md
new file mode 100644
index 0000000..f1a24ee
--- /dev/null
+++ b/leetcode/leetcode/0028-find-the-index-of-the-first-occurrence-in-a-string/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/">28. Find the Index of the First Occurrence in a String</a></h2><h3>Easy</h3><hr><div><p>Given two strings <code>needle</code> and <code>haystack</code>, return the index of the first occurrence of <code>needle</code> in <code>haystack</code>, or <code>-1</code> if <code>needle</code> is not part of <code>haystack</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> haystack = "sadbutsad", needle = "sad"
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> "sad" occurs at index 0 and 6.
+The first occurrence is at index 0, so we return 0.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> haystack = "leetcode", needle = "leeto"
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> "leeto" did not occur in "leetcode", so we return -1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= haystack.length, needle.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>haystack</code> and <code>needle</code> consist of only lowercase English characters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0029-divide-two-integers/0029-divide-two-integers.java b/leetcode/leetcode/0029-divide-two-integers/0029-divide-two-integers.java
new file mode 100644
index 0000000..2942344
--- /dev/null
+++ b/leetcode/leetcode/0029-divide-two-integers/0029-divide-two-integers.java
@@ -0,0 +1,33 @@
+class Solution {
+    public int divide(long dividend, long divisor) {
+        long sign = 1;
+        if(dividend<0){
+            dividend = -dividend;
+            sign = -1*sign; 
+        }
+        if(divisor<0){
+            divisor = -divisor;
+            sign = -1*sign;
+        }
+        if(dividend<divisor) return 0; 
+        // if(dividend==divisor) return 1;
+
+        long lastDivisor = divisor;
+        long currentDivisor = divisor << 1;
+        long ans = 1;
+        while(currentDivisor<dividend){
+            lastDivisor = currentDivisor;
+            ans = ans << 1;
+            currentDivisor = currentDivisor << 1;
+        }
+
+        long temp =  sign * (ans + divide(dividend - lastDivisor, divisor));
+        if(temp>Integer.MAX_VALUE) return Integer.MAX_VALUE;
+        if(temp<Integer.MIN_VALUE) return Integer.MIN_VALUE;
+        return (int) temp;
+        
+        
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0029-divide-two-integers/README.md b/leetcode/leetcode/0029-divide-two-integers/README.md
new file mode 100644
index 0000000..f8c4af7
--- /dev/null
+++ b/leetcode/leetcode/0029-divide-two-integers/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/divide-two-integers">29. Divide Two Integers</a></h2><h3>Medium</h3><hr><p>Given two integers <code>dividend</code> and <code>divisor</code>, divide two integers <strong>without</strong> using multiplication, division, and mod operator.</p>
+
+<p>The integer division should truncate toward zero, which means losing its fractional part. For example, <code>8.345</code> would be truncated to <code>8</code>, and <code>-2.7335</code> would be truncated to <code>-2</code>.</p>
+
+<p>Return <em>the <strong>quotient</strong> after dividing </em><code>dividend</code><em> by </em><code>divisor</code>.</p>
+
+<p><strong>Note: </strong>Assume we are dealing with an environment that could only store integers within the <strong>32-bit</strong> signed integer range: <code>[&minus;2<sup>31</sup>, 2<sup>31</sup> &minus; 1]</code>. For this problem, if the quotient is <strong>strictly greater than</strong> <code>2<sup>31</sup> - 1</code>, then return <code>2<sup>31</sup> - 1</code>, and if the quotient is <strong>strictly less than</strong> <code>-2<sup>31</sup></code>, then return <code>-2<sup>31</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> dividend = 10, divisor = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 10/3 = 3.33333.. which is truncated to 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> dividend = 7, divisor = -3
+<strong>Output:</strong> -2
+<strong>Explanation:</strong> 7/-3 = -2.33333.. which is truncated to -2.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= dividend, divisor &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>divisor != 0</code></li>
+</ul>
diff --git a/leetcode/leetcode/0032-longest-valid-parentheses/0032-longest-valid-parentheses.java b/leetcode/leetcode/0032-longest-valid-parentheses/0032-longest-valid-parentheses.java
new file mode 100644
index 0000000..591acdc
--- /dev/null
+++ b/leetcode/leetcode/0032-longest-valid-parentheses/0032-longest-valid-parentheses.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int longestValidParentheses(String S) {
+        Stack<Integer> s = new Stack<>();
+        s.push(-1);
+        int maxLen = 0;
+        for(int i = 0;i<S.length();i++){
+            if(S.charAt(i)=='('){
+                s.push(i);
+            }else{
+                s.pop();
+                if(s.isEmpty()) s.push(i);
+                else maxLen = Math.max(maxLen,i - s.peek());
+            }
+        }
+        return maxLen;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0032-longest-valid-parentheses/NOTES.md b/leetcode/leetcode/0032-longest-valid-parentheses/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0032-longest-valid-parentheses/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0032-longest-valid-parentheses/README.md b/leetcode/leetcode/0032-longest-valid-parentheses/README.md
new file mode 100644
index 0000000..1b8ba1d
--- /dev/null
+++ b/leetcode/leetcode/0032-longest-valid-parentheses/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/longest-valid-parentheses/">32. Longest Valid Parentheses</a></h2><h3>Hard</h3><hr><div><p>Given a string containing just the characters <code>'('</code> and <code>')'</code>, return <em>the length of the longest valid (well-formed) parentheses </em><span data-keyword="substring-nonempty"><em>substring</em></span>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "(()"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The longest valid parentheses substring is "()".
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = ")()())"
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The longest valid parentheses substring is "()()".
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = ""
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>s[i]</code> is <code>'('</code>, or <code>')'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0033-search-in-rotated-sorted-array/0033-search-in-rotated-sorted-array.java b/leetcode/leetcode/0033-search-in-rotated-sorted-array/0033-search-in-rotated-sorted-array.java
new file mode 100644
index 0000000..d7acb24
--- /dev/null
+++ b/leetcode/leetcode/0033-search-in-rotated-sorted-array/0033-search-in-rotated-sorted-array.java
@@ -0,0 +1,27 @@
+class Solution {
+
+    public int search(int[] arr, int target) {
+        int low = 0;
+        int high = arr.length -1;
+        int N = arr.length;
+        while(low<=high){
+            int mid = low + (high-low)/2;
+            if(arr[mid]==target){
+                return mid;
+            }else if(arr[mid]<arr[0]){
+                if(arr[mid]<=target && target<=arr[N-1]){
+                    low = mid+1;
+                }else{
+                    high = mid - 1;
+                }
+            }else{
+                if(arr[0]<=target && target<=arr[mid]){
+                    high = mid -1;
+                }else{
+                    low = mid+1;
+                }
+            }
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0033-search-in-rotated-sorted-array/README.md b/leetcode/leetcode/0033-search-in-rotated-sorted-array/README.md
new file mode 100644
index 0000000..abac798
--- /dev/null
+++ b/leetcode/leetcode/0033-search-in-rotated-sorted-array/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/search-in-rotated-sorted-array">33. Search in Rotated Sorted Array</a></h2><h3>Medium</h3><hr><p>There is an integer array <code>nums</code> sorted in ascending order (with <strong>distinct</strong> values).</p>
+
+<p>Prior to being passed to your function, <code>nums</code> is <strong>possibly rotated</strong> at an unknown pivot index <code>k</code> (<code>1 &lt;= k &lt; nums.length</code>) such that the resulting array is <code>[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]</code> (<strong>0-indexed</strong>). For example, <code>[0,1,2,4,5,6,7]</code> might be rotated at pivot index <code>3</code> and become <code>[4,5,6,7,0,1,2]</code>.</p>
+
+<p>Given the array <code>nums</code> <strong>after</strong> the possible rotation and an integer <code>target</code>, return <em>the index of </em><code>target</code><em> if it is in </em><code>nums</code><em>, or </em><code>-1</code><em> if it is not in </em><code>nums</code>.</p>
+
+<p>You must write an algorithm with <code>O(log n)</code> runtime complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [4,5,6,7,0,1,2], target = 0
+<strong>Output:</strong> 4
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [4,5,6,7,0,1,2], target = 3
+<strong>Output:</strong> -1
+</pre><p><strong class="example">Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1], target = 0
+<strong>Output:</strong> -1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 5000</code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+	<li>All values of <code>nums</code> are <strong>unique</strong>.</li>
+	<li><code>nums</code> is an ascending array that is possibly rotated.</li>
+	<li><code>-10<sup>4</sup> &lt;= target &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0034-find-first-and-last-position-of-element-in-sorted-array/0034-find-first-and-last-position-of-element-in-sorted-array.java b/leetcode/leetcode/0034-find-first-and-last-position-of-element-in-sorted-array/0034-find-first-and-last-position-of-element-in-sorted-array.java
new file mode 100644
index 0000000..dfff5f1
--- /dev/null
+++ b/leetcode/leetcode/0034-find-first-and-last-position-of-element-in-sorted-array/0034-find-first-and-last-position-of-element-in-sorted-array.java
@@ -0,0 +1,38 @@
+class Solution {
+    public int[] searchRange(int[] arr, int target) {
+        int[] result = {-1,-1};
+        int low = 0;
+        int high = arr.length - 1;
+        boolean found = false;
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(arr[mid] == target){
+                result[0] = mid;
+                found = true;
+                high = mid -1;
+            }else if(arr[mid]>target){
+                high = mid -1;
+            }else {
+                low = mid+1;
+            }
+        }
+        if(!found) return result;
+
+        low = 0;
+        high = arr.length - 1;
+
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(arr[mid] == target){
+                result[1] = mid;
+                low = mid + 1;
+            }else if(arr[mid]>target){
+                high = mid -1;
+            }else{
+                low = mid+1;         
+            }
+        }
+        return result;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0034-find-first-and-last-position-of-element-in-sorted-array/README.md b/leetcode/leetcode/0034-find-first-and-last-position-of-element-in-sorted-array/README.md
new file mode 100644
index 0000000..567e3ee
--- /dev/null
+++ b/leetcode/leetcode/0034-find-first-and-last-position-of-element-in-sorted-array/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array">34. Find First and Last Position of Element in Sorted Array</a></h2><h3>Medium</h3><hr><p>Given an array of integers <code>nums</code> sorted in non-decreasing order, find the starting and ending position of a given <code>target</code> value.</p>
+
+<p>If <code>target</code> is not found in the array, return <code>[-1, -1]</code>.</p>
+
+<p>You must&nbsp;write an algorithm with&nbsp;<code>O(log n)</code> runtime complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [5,7,7,8,8,10], target = 8
+<strong>Output:</strong> [3,4]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [5,7,7,8,8,10], target = 6
+<strong>Output:</strong> [-1,-1]
+</pre><p><strong class="example">Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [], target = 0
+<strong>Output:</strong> [-1,-1]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup>&nbsp;&lt;= nums[i]&nbsp;&lt;= 10<sup>9</sup></code></li>
+	<li><code>nums</code> is a non-decreasing array.</li>
+	<li><code>-10<sup>9</sup>&nbsp;&lt;= target&nbsp;&lt;= 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0038-count-and-say/0038-count-and-say.java b/leetcode/leetcode/0038-count-and-say/0038-count-and-say.java
new file mode 100644
index 0000000..fc96327
--- /dev/null
+++ b/leetcode/leetcode/0038-count-and-say/0038-count-and-say.java
@@ -0,0 +1,20 @@
+class Solution {
+    public String countAndSay(int n) {
+        if(n == 1) return "1";
+        String lastNum = countAndSay(n-1);
+        int index = 0;
+        StringBuilder sb = new StringBuilder();
+        while(index<lastNum.length()){
+            char currElement = lastNum.charAt(index++);
+            int freq = 1;
+            while(index<lastNum.length()){
+                if(lastNum.charAt(index) != currElement) break;
+                index++;
+                freq++;
+            }
+            sb.append(Integer.toString(freq));
+            sb.append(currElement);
+        }
+        return sb.toString(); 
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0038-count-and-say/README.md b/leetcode/leetcode/0038-count-and-say/README.md
new file mode 100644
index 0000000..8ad8a0c
--- /dev/null
+++ b/leetcode/leetcode/0038-count-and-say/README.md
@@ -0,0 +1,50 @@
+<h2><a href="https://leetcode.com/problems/count-and-say">38. Count and Say</a></h2><h3>Medium</h3><hr><p>The <strong>count-and-say</strong> sequence is a sequence of digit strings defined by the recursive formula:</p>
+
+<ul>
+	<li><code>countAndSay(1) = &quot;1&quot;</code></li>
+	<li><code>countAndSay(n)</code> is the run-length encoding of <code>countAndSay(n - 1)</code>.</li>
+</ul>
+
+<p><a href="http://en.wikipedia.org/wiki/Run-length_encoding" target="_blank">Run-length encoding</a> (RLE) is a string compression method that works by replacing consecutive identical characters (repeated 2 or more times) with the concatenation of the character and the number marking the count of the characters (length of the run). For example, to compress the string <code>&quot;3322251&quot;</code> we replace <code>&quot;33&quot;</code> with <code>&quot;23&quot;</code>, replace <code>&quot;222&quot;</code> with <code>&quot;32&quot;</code>, replace <code>&quot;5&quot;</code> with <code>&quot;15&quot;</code> and replace <code>&quot;1&quot;</code> with <code>&quot;11&quot;</code>. Thus the compressed string becomes <code>&quot;23321511&quot;</code>.</p>
+
+<p>Given a positive integer <code>n</code>, return <em>the </em><code>n<sup>th</sup></code><em> element of the <strong>count-and-say</strong> sequence</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 4</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">&quot;1211&quot;</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<pre>
+countAndSay(1) = &quot;1&quot;
+countAndSay(2) = RLE of &quot;1&quot; = &quot;11&quot;
+countAndSay(3) = RLE of &quot;11&quot; = &quot;21&quot;
+countAndSay(4) = RLE of &quot;21&quot; = &quot;1211&quot;
+</pre>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 1</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">&quot;1&quot;</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>This is the base case.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 30</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you solve it iteratively?
\ No newline at end of file
diff --git a/leetcode/leetcode/0039-combination-sum/0039-combination-sum.java b/leetcode/leetcode/0039-combination-sum/0039-combination-sum.java
new file mode 100644
index 0000000..3bc4244
--- /dev/null
+++ b/leetcode/leetcode/0039-combination-sum/0039-combination-sum.java
@@ -0,0 +1,29 @@
+class Solution {
+    public List<List<Integer>> helper(int[] candidates, int startIndex,int target){
+        List<List<Integer>> result = new ArrayList<>();
+        if(startIndex == candidates.length) return result;
+        if(target<0) return result; 
+        if(target == candidates[startIndex]){
+            List<Integer> temp = new ArrayList<>();
+            temp.add(candidates[startIndex]);
+            result.add(temp);
+            return result;
+        }
+        result = helper(candidates,startIndex,target-candidates[startIndex]);
+        if(result.size()!=0){
+            for(int i = 0;i<result.size();i++){
+                result.get(i).add(candidates[startIndex]);
+            }
+        }
+        result.addAll(helper(candidates,startIndex+1,target));
+        return result;
+    }
+    
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        Arrays.sort(candidates);
+        List<List<Integer>> ans = helper(candidates,0,target);
+        return ans;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0039-combination-sum/0039-combination-sum.py b/leetcode/leetcode/0039-combination-sum/0039-combination-sum.py
new file mode 100644
index 0000000..7d6bf25
--- /dev/null
+++ b/leetcode/leetcode/0039-combination-sum/0039-combination-sum.py
@@ -0,0 +1,19 @@
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        
+        res = []
+
+        def helper(temp, current_sum, current_index):
+            if(current_index>= len(candidates) or current_sum>target):
+                return 
+            if(current_sum == target):
+                res.append(temp[:])
+                return
+            
+            temp.append(candidates[current_index])
+            helper(temp,current_sum+candidates[current_index],current_index)
+            temp.pop()
+            helper(temp,current_sum,current_index+1)
+            return
+        helper([],0,0)
+        return res
\ No newline at end of file
diff --git a/leetcode/leetcode/0039-combination-sum/README.md b/leetcode/leetcode/0039-combination-sum/README.md
new file mode 100644
index 0000000..241b5ce
--- /dev/null
+++ b/leetcode/leetcode/0039-combination-sum/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/combination-sum">39. Combination Sum</a></h2><h3>Medium</h3><hr><p>Given an array of <strong>distinct</strong> integers <code>candidates</code> and a target integer <code>target</code>, return <em>a list of all <strong>unique combinations</strong> of </em><code>candidates</code><em> where the chosen numbers sum to </em><code>target</code><em>.</em> You may return the combinations in <strong>any order</strong>.</p>
+
+<p>The <strong>same</strong> number may be chosen from <code>candidates</code> an <strong>unlimited number of times</strong>. Two combinations are unique if the <span data-keyword="frequency-array">frequency</span> of at least one of the chosen numbers is different.</p>
+
+<p>The test cases are generated such that the number of unique combinations that sum up to <code>target</code> is less than <code>150</code> combinations for the given input.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> candidates = [2,3,6,7], target = 7
+<strong>Output:</strong> [[2,2,3],[7]]
+<strong>Explanation:</strong>
+2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.
+7 is a candidate, and 7 = 7.
+These are the only two combinations.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> candidates = [2,3,5], target = 8
+<strong>Output:</strong> [[2,2,2,2],[2,3,3],[3,5]]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> candidates = [2], target = 1
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= candidates.length &lt;= 30</code></li>
+	<li><code>2 &lt;= candidates[i] &lt;= 40</code></li>
+	<li>All elements of <code>candidates</code> are <strong>distinct</strong>.</li>
+	<li><code>1 &lt;= target &lt;= 40</code></li>
+</ul>
diff --git a/leetcode/leetcode/0040-combination-sum-ii/0040-combination-sum-ii.py b/leetcode/leetcode/0040-combination-sum-ii/0040-combination-sum-ii.py
new file mode 100644
index 0000000..66ba90e
--- /dev/null
+++ b/leetcode/leetcode/0040-combination-sum-ii/0040-combination-sum-ii.py
@@ -0,0 +1,20 @@
+class Solution:
+    def combinationSum2(self, arr: List[int], target: int) -> List[List[int]]:
+        arr.sort()
+        res = []
+        def dfs(index, curr, total):
+            if(total == target):
+                res.append(curr.copy())
+                return 
+            if(index==len(arr) or total>target):
+                return 
+            
+            curr.append(arr[index])
+            dfs(index+1,curr,total+arr[index])
+            curr.pop()
+            while(index+1<len(arr) and arr[index] == arr[index+1]):
+                index+=1
+            dfs(index+1,curr,total)
+
+        dfs(0,[],0)
+        return res
\ No newline at end of file
diff --git a/leetcode/leetcode/0040-combination-sum-ii/README.md b/leetcode/leetcode/0040-combination-sum-ii/README.md
new file mode 100644
index 0000000..326d74f
--- /dev/null
+++ b/leetcode/leetcode/0040-combination-sum-ii/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/combination-sum-ii">40. Combination Sum II</a></h2><h3>Medium</h3><hr><p>Given a collection of candidate numbers (<code>candidates</code>) and a target number (<code>target</code>), find all unique combinations in <code>candidates</code>&nbsp;where the candidate numbers sum to <code>target</code>.</p>
+
+<p>Each number in <code>candidates</code>&nbsp;may only be used <strong>once</strong> in the combination.</p>
+
+<p><strong>Note:</strong>&nbsp;The solution set must not contain duplicate combinations.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> candidates = [10,1,2,7,6,1,5], target = 8
+<strong>Output:</strong> 
+[
+[1,1,6],
+[1,2,5],
+[1,7],
+[2,6]
+]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> candidates = [2,5,2,1,2], target = 5
+<strong>Output:</strong> 
+[
+[1,2,2],
+[5]
+]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;=&nbsp;candidates.length &lt;= 100</code></li>
+	<li><code>1 &lt;=&nbsp;candidates[i] &lt;= 50</code></li>
+	<li><code>1 &lt;= target &lt;= 30</code></li>
+</ul>
diff --git a/leetcode/leetcode/0045-jump-game-ii/0045-jump-game-ii.java b/leetcode/leetcode/0045-jump-game-ii/0045-jump-game-ii.java
new file mode 100644
index 0000000..03f1908
--- /dev/null
+++ b/leetcode/leetcode/0045-jump-game-ii/0045-jump-game-ii.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int jump(int[] arr) {
+        if(arr.length == 1) return 0;
+        int totalJump = 0;
+        int index = 0;
+        while(index<=arr.length){
+            int maxRange = index + arr[index];
+            totalJump++;
+            if(maxRange>=arr.length-1) return totalJump;
+            int maxJumpIndex = index+1;
+            for(int i = index+1;i<=maxRange;i++){
+                if(i+arr[i]>=maxJumpIndex + arr[maxJumpIndex]) maxJumpIndex = i;
+            }
+            index = maxJumpIndex;
+        }
+        return totalJump;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0045-jump-game-ii/README.md b/leetcode/leetcode/0045-jump-game-ii/README.md
new file mode 100644
index 0000000..553a8bb
--- /dev/null
+++ b/leetcode/leetcode/0045-jump-game-ii/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/jump-game-ii">45. Jump Game II</a></h2><h3>Medium</h3><hr><p>You are given a <strong>0-indexed</strong> array of integers <code>nums</code> of length <code>n</code>. You are initially positioned at <code>nums[0]</code>.</p>
+
+<p>Each element <code>nums[i]</code> represents the maximum length of a forward jump from index <code>i</code>. In other words, if you are at <code>nums[i]</code>, you can jump to any <code>nums[i + j]</code> where:</p>
+
+<ul>
+	<li><code>0 &lt;= j &lt;= nums[i]</code> and</li>
+	<li><code>i + j &lt; n</code></li>
+</ul>
+
+<p>Return <em>the minimum number of jumps to reach </em><code>nums[n - 1]</code>. The test cases are generated such that you can reach <code>nums[n - 1]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,3,1,1,4]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,3,0,1,4]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 1000</code></li>
+	<li>It&#39;s guaranteed that you can reach <code>nums[n - 1]</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0046-permutations/0046-permutations.java b/leetcode/leetcode/0046-permutations/0046-permutations.java
new file mode 100644
index 0000000..9b640fd
--- /dev/null
+++ b/leetcode/leetcode/0046-permutations/0046-permutations.java
@@ -0,0 +1,29 @@
+class Solution {
+    List<List<Integer>> res = new ArrayList<>();
+    public void helper(int[] nums, int index){
+        if(index == nums.length-1){
+            List<Integer> list = new ArrayList<>();
+            list.add(nums[index]);
+            res.add(list);
+            return;
+        }
+        helper(nums, index+1);
+
+        List<List<Integer>> temp_res = new ArrayList<>();
+        for(int i = 0;i<res.size();i++){
+            List<Integer> arr = res.get(i);
+            for(int j = 0;j<=arr.size();j++){
+                arr.add(j,nums[index]);
+                List<Integer> temp =  new ArrayList<>(arr);
+                temp_res.add(temp);
+                arr.remove(j);
+            }
+        }
+        res = temp_res;
+        return;
+    }
+    public List<List<Integer>> permute(int[] nums) {
+        helper(nums,0);
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0046-permutations/README.md b/leetcode/leetcode/0046-permutations/README.md
new file mode 100644
index 0000000..2b8ea29
--- /dev/null
+++ b/leetcode/leetcode/0046-permutations/README.md
@@ -0,0 +1,21 @@
+<h2><a href="https://leetcode.com/problems/permutations">46. Permutations</a></h2><h3>Medium</h3><hr><p>Given an array <code>nums</code> of distinct integers, return all the possible <span data-keyword="permutation-array">permutations</span>. You can return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [0,1]
+<strong>Output:</strong> [[0,1],[1,0]]
+</pre><p><strong class="example">Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> [[1]]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 6</code></li>
+	<li><code>-10 &lt;= nums[i] &lt;= 10</code></li>
+	<li>All the integers of <code>nums</code> are <strong>unique</strong>.</li>
+</ul>
diff --git a/leetcode/leetcode/0048-rotate-image/0048-rotate-image.java b/leetcode/leetcode/0048-rotate-image/0048-rotate-image.java
new file mode 100644
index 0000000..f3c698c
--- /dev/null
+++ b/leetcode/leetcode/0048-rotate-image/0048-rotate-image.java
@@ -0,0 +1,34 @@
+class Solution {
+    public void swap(int[][] matrix, int row, int col){
+        int temp = matrix[row][col];
+        matrix[row][col] = matrix[col][row];
+        matrix[col][row] = temp;
+    }
+    public void rotateRow(int[][] matrix, int row){
+        int col = 0;
+        int lastCol = matrix[0].length-1;
+        while(col<lastCol){
+            int temp = matrix[row][col];
+            matrix[row][col] = matrix[row][lastCol];
+            matrix[row][lastCol] = temp;
+            col++;
+            lastCol--;
+        }
+    }
+    public void rotate(int[][] matrix) {
+        int row = 0;
+        int col = 0;
+        while(row<matrix.length && col < matrix[0].length){
+            while(col<matrix[0].length){
+                swap(matrix,row,col++);
+            }
+            row++;
+            col = row;
+        }
+
+        for(row = 0;row<matrix.length;row++){
+            rotateRow(matrix,row);
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0048-rotate-image/README.md b/leetcode/leetcode/0048-rotate-image/README.md
new file mode 100644
index 0000000..d88ff8b
--- /dev/null
+++ b/leetcode/leetcode/0048-rotate-image/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/rotate-image">48. Rotate Image</a></h2><h3>Medium</h3><hr><p>You are given an <code>n x n</code> 2D <code>matrix</code> representing an image, rotate the image by <strong>90</strong> degrees (clockwise).</p>
+
+<p>You have to rotate the image <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank"><strong>in-place</strong></a>, which means you have to modify the input 2D matrix directly. <strong>DO NOT</strong> allocate another 2D matrix and do the rotation.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/mat1.jpg" style="width: 500px; height: 188px;" />
+<pre>
+<strong>Input:</strong> matrix = [[1,2,3],[4,5,6],[7,8,9]]
+<strong>Output:</strong> [[7,4,1],[8,5,2],[9,6,3]]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/mat2.jpg" style="width: 500px; height: 201px;" />
+<pre>
+<strong>Input:</strong> matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
+<strong>Output:</strong> [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == matrix.length == matrix[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 20</code></li>
+	<li><code>-1000 &lt;= matrix[i][j] &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/0049-group-anagrams/0049-group-anagrams.java b/leetcode/leetcode/0049-group-anagrams/0049-group-anagrams.java
new file mode 100644
index 0000000..42b57e0
--- /dev/null
+++ b/leetcode/leetcode/0049-group-anagrams/0049-group-anagrams.java
@@ -0,0 +1,23 @@
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        // Optimized;
+        HashMap<String,List<String>> map = new HashMap<>();
+        for(int i = 0;i<strs.length;i++){
+            char[] arr = strs[i].toCharArray();
+            Arrays.sort(arr);
+            String sortedString = new String(arr);
+            if(!map.containsKey(sortedString)){
+                ArrayList<String> list = new ArrayList<>();
+                map.put(sortedString,list);
+            }
+            map.get(sortedString).add(strs[i]);
+        }
+
+        List<List<String>> result = new ArrayList<>();
+        for(List<String> list: map.values()){
+            result.add(list);
+        }
+        return result;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0049-group-anagrams/README.md b/leetcode/leetcode/0049-group-anagrams/README.md
new file mode 100644
index 0000000..9d4e57a
--- /dev/null
+++ b/leetcode/leetcode/0049-group-anagrams/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/group-anagrams">49. Group Anagrams</a></h2><h3>Medium</h3><hr><p>Given an array of strings <code>strs</code>, group the <span data-keyword="anagram">anagrams</span> together. You can return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">strs = [&quot;eat&quot;,&quot;tea&quot;,&quot;tan&quot;,&quot;ate&quot;,&quot;nat&quot;,&quot;bat&quot;]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[[&quot;bat&quot;],[&quot;nat&quot;,&quot;tan&quot;],[&quot;ate&quot;,&quot;eat&quot;,&quot;tea&quot;]]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<ul>
+	<li>There is no string in strs that can be rearranged to form <code>&quot;bat&quot;</code>.</li>
+	<li>The strings <code>&quot;nat&quot;</code> and <code>&quot;tan&quot;</code> are anagrams as they can be rearranged to form each other.</li>
+	<li>The strings <code>&quot;ate&quot;</code>, <code>&quot;eat&quot;</code>, and <code>&quot;tea&quot;</code> are anagrams as they can be rearranged to form each other.</li>
+</ul>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">strs = [&quot;&quot;]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[[&quot;&quot;]]</span></p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">strs = [&quot;a&quot;]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[[&quot;a&quot;]]</span></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= strs.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= strs[i].length &lt;= 100</code></li>
+	<li><code>strs[i]</code> consists of lowercase English letters.</li>
+</ul>
diff --git a/leetcode/leetcode/0050-powx-n/0050-powx-n.java b/leetcode/leetcode/0050-powx-n/0050-powx-n.java
new file mode 100644
index 0000000..c9880d0
--- /dev/null
+++ b/leetcode/leetcode/0050-powx-n/0050-powx-n.java
@@ -0,0 +1,16 @@
+class Solution {
+    public double myPow(double x, long n) {
+        if(n<0) {
+            n = -1*n;
+            x = 1/x;
+        }
+        double ans = 1;
+        while(n!=0){
+            int bit =(int) (n & 1);
+            if(bit==1) ans = ans*x;
+            x = x*x;
+            n = n >> 1;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0050-powx-n/NOTES.md b/leetcode/leetcode/0050-powx-n/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0050-powx-n/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0050-powx-n/README.md b/leetcode/leetcode/0050-powx-n/README.md
new file mode 100644
index 0000000..0e37c79
--- /dev/null
+++ b/leetcode/leetcode/0050-powx-n/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/powx-n">50. Pow(x, n)</a></h2><h3>Medium</h3><hr><p>Implement <a href="http://www.cplusplus.com/reference/valarray/pow/" target="_blank">pow(x, n)</a>, which calculates <code>x</code> raised to the power <code>n</code> (i.e., <code>x<sup>n</sup></code>).</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> x = 2.00000, n = 10
+<strong>Output:</strong> 1024.00000
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> x = 2.10000, n = 3
+<strong>Output:</strong> 9.26100
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> x = 2.00000, n = -2
+<strong>Output:</strong> 0.25000
+<strong>Explanation:</strong> 2<sup>-2</sup> = 1/2<sup>2</sup> = 1/4 = 0.25
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-100.0 &lt; x &lt; 100.0</code></li>
+	<li><code>-2<sup>31</sup> &lt;= n &lt;= 2<sup>31</sup>-1</code></li>
+	<li><code>n</code> is an integer.</li>
+	<li>Either <code>x</code> is not zero or <code>n &gt; 0</code>.</li>
+	<li><code>-10<sup>4</sup> &lt;= x<sup>n</sup> &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0053-maximum-subarray/0053-maximum-subarray.java b/leetcode/leetcode/0053-maximum-subarray/0053-maximum-subarray.java
new file mode 100644
index 0000000..6339ed2
--- /dev/null
+++ b/leetcode/leetcode/0053-maximum-subarray/0053-maximum-subarray.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int maxSum = Integer.MIN_VALUE;
+        int currSum = 0;
+        for(int num: nums){
+            currSum+=num;
+            maxSum = Math.max(maxSum,currSum);
+            if(currSum<0) currSum = 0;
+        }
+        return maxSum;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0053-maximum-subarray/README.md b/leetcode/leetcode/0053-maximum-subarray/README.md
new file mode 100644
index 0000000..d5a3ebb
--- /dev/null
+++ b/leetcode/leetcode/0053-maximum-subarray/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/maximum-subarray">53. Maximum Subarray</a></h2><h3>Medium</h3><hr><p>Given an integer array <code>nums</code>, find the <span data-keyword="subarray-nonempty">subarray</span> with the largest sum, and return <em>its sum</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [-2,1,-3,4,-1,2,1,-5,4]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The subarray [4,-1,2,1] has the largest sum 6.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The subarray [1] has the largest sum 1.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [5,4,-1,7,8]
+<strong>Output:</strong> 23
+<strong>Explanation:</strong> The subarray [5,4,-1,7,8] has the largest sum 23.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> If you have figured out the <code>O(n)</code> solution, try coding another solution using the <strong>divide and conquer</strong> approach, which is more subtle.</p>
diff --git a/leetcode/leetcode/0055-jump-game/0055-jump-game.java b/leetcode/leetcode/0055-jump-game/0055-jump-game.java
new file mode 100644
index 0000000..eeedd5f
--- /dev/null
+++ b/leetcode/leetcode/0055-jump-game/0055-jump-game.java
@@ -0,0 +1,21 @@
+class Solution {
+    public boolean canJump(int[] nums) {
+        if(nums.length==1) return true;
+        int curr = 0;
+        int currMax = nums[0];
+        int start = 0;
+        while(start<=currMax && start<=nums.length-1){
+            int nextMax = start+nums[start];
+            while(start<=currMax && start<=nums.length-1){
+                nextMax = Math.max(nextMax,start+nums[start]);
+                start++;
+            }
+            if(nextMax >= nums.length-1) return true;
+            if(currMax == nextMax) return false;
+            currMax = nextMax;
+            
+        }
+        return currMax>=nums.length-1;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0055-jump-game/README.md b/leetcode/leetcode/0055-jump-game/README.md
new file mode 100644
index 0000000..900dfed
--- /dev/null
+++ b/leetcode/leetcode/0055-jump-game/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/jump-game">55. Jump Game</a></h2><h3>Medium</h3><hr><p>You are given an integer array <code>nums</code>. You are initially positioned at the array&#39;s <strong>first index</strong>, and each element in the array represents your maximum jump length at that position.</p>
+
+<p>Return <code>true</code><em> if you can reach the last index, or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,3,1,1,4]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Jump 1 step from index 0 to 1, then 3 steps to the last index.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,2,1,0,4]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0056-merge-intervals/0056-merge-intervals.java b/leetcode/leetcode/0056-merge-intervals/0056-merge-intervals.java
new file mode 100644
index 0000000..69aeb5e
--- /dev/null
+++ b/leetcode/leetcode/0056-merge-intervals/0056-merge-intervals.java
@@ -0,0 +1,34 @@
+class Solution {
+    class Pair{
+        int start;
+        int end;
+        Pair(int start, int end){
+            this.start = start;
+            this.end   = end;
+        }
+    }
+    public int[][] merge(int[][] intervals) {
+        if(intervals.length < 2) return intervals;
+        Arrays.sort(intervals,(a,b)->Integer.compare(a[0],b[0]));
+        int index = 0;
+        List<Pair> list  = new ArrayList<>();
+        while(index<intervals.length){
+            int prev_start = intervals[index][0];
+            int prev_end   = intervals[index][1];
+            index++;
+            while(index<intervals.length && prev_end>=intervals[index][0]){
+                prev_end = Math.max(prev_end,intervals[index][1]);
+                index++;
+            }
+
+            list.add(new Pair(prev_start,prev_end));
+        }
+        int[][] result = new int[list.size()][2];
+        for(int i = 0;i<result.length;i++){
+            result[i][0] = list.get(i).start;
+            result[i][1] = list.get(i).end;
+        }
+        return result;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0056-merge-intervals/README.md b/leetcode/leetcode/0056-merge-intervals/README.md
new file mode 100644
index 0000000..88e7690
--- /dev/null
+++ b/leetcode/leetcode/0056-merge-intervals/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/merge-intervals">56. Merge Intervals</a></h2><h3>Medium</h3><hr><p>Given an array&nbsp;of <code>intervals</code>&nbsp;where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code>, merge all overlapping intervals, and return <em>an array of the non-overlapping intervals that cover all the intervals in the input</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> intervals = [[1,3],[2,6],[8,10],[15,18]]
+<strong>Output:</strong> [[1,6],[8,10],[15,18]]
+<strong>Explanation:</strong> Since intervals [1,3] and [2,6] overlap, merge them into [1,6].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> intervals = [[1,4],[4,5]]
+<strong>Output:</strong> [[1,5]]
+<strong>Explanation:</strong> Intervals [1,4] and [4,5] are considered overlapping.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= intervals.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>intervals[i].length == 2</code></li>
+	<li><code>0 &lt;= start<sub>i</sub> &lt;= end<sub>i</sub> &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0057-insert-interval/0057-insert-interval.java b/leetcode/leetcode/0057-insert-interval/0057-insert-interval.java
new file mode 100644
index 0000000..1027f34
--- /dev/null
+++ b/leetcode/leetcode/0057-insert-interval/0057-insert-interval.java
@@ -0,0 +1,71 @@
+class Solution {
+    // Returns true if the intervals a and b have a common element.
+    boolean doesIntervalsOverlap(int[] a, int[] b) {
+        return Math.min(a[1], b[1]) - Math.max(a[0], b[0]) >= 0;
+    }
+
+    // Return the interval having all the elements of intervals a and b.
+    int[] mergeIntervals(int[] a, int[] b) {
+        int[] newInterval = {Math.min(a[0], b[0]), Math.max(a[1], b[1])};
+        return newInterval;
+    }
+
+    int UpperBound(int[][] intervals, int[] newInterval) {
+        if (intervals.length == 0) {
+            // If the list is empty, just insert the newInterval at the 0th position.
+            return 0;
+        }
+
+        int start = 0, end = intervals.length - 1;
+        int ans = intervals.length;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+
+            // If the start value is greater than the newInterval
+            // This could be the position, so store it but keep looking on the left side.
+            if (intervals[mid][0] > newInterval[0]) {
+                ans = mid;
+                end = mid - 1;
+            } else {
+                // Search on the right side of mid.
+                start = mid + 1;
+            }
+        }
+
+        return ans;
+    }
+
+    // Insert the interval newInterval, into the list interval keeping the sorting order intact.
+    int[][] insertInterval(int[][] intervals, int[] newInterval) {
+        List<int[]> list = new ArrayList<>(Arrays.asList(intervals));
+        int index = UpperBound(intervals, newInterval);
+
+        if (index != intervals.length) {
+            list.add(index, newInterval);
+        } else {
+            list.add(newInterval);
+        }
+
+        return list.toArray(new int[list.size()][2]);
+    }
+
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        // Insert the interval first before merge processing.
+        intervals = insertInterval(intervals, newInterval);
+
+        List<int[]> answer = new ArrayList<>();
+        for (int i = 0; i < intervals.length; i++) {
+            int[] currInterval = {intervals[i][0], intervals[i][1]};
+            // Merge until the list gets exhausted or no overlap is found.
+            while (i < intervals.length && doesIntervalsOverlap(currInterval, intervals[i])) {
+                currInterval = mergeIntervals(currInterval, intervals[i]);
+                i++;
+            }
+            // Decrement to ensure we don't skip the interval due to outer for-loop incrementing.
+            i--;
+            answer.add(currInterval);
+        }
+
+        return answer.toArray(new int[answer.size()][2]);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0057-insert-interval/README.md b/leetcode/leetcode/0057-insert-interval/README.md
new file mode 100644
index 0000000..3805102
--- /dev/null
+++ b/leetcode/leetcode/0057-insert-interval/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/insert-interval/">57. Insert Interval</a></h2><h3>Medium</h3><hr><div><p>You are given an array of non-overlapping intervals <code>intervals</code> where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> represent the start and the end of the <code>i<sup>th</sup></code> interval and <code>intervals</code> is sorted in ascending order by <code>start<sub>i</sub></code>. You are also given an interval <code>newInterval = [start, end]</code> that represents the start and end of another interval.</p>
+
+<p>Insert <code>newInterval</code> into <code>intervals</code> such that <code>intervals</code> is still sorted in ascending order by <code>start<sub>i</sub></code> and <code>intervals</code> still does not have any overlapping intervals (merge overlapping intervals if necessary).</p>
+
+<p>Return <code>intervals</code><em> after the insertion</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> intervals = [[1,3],[6,9]], newInterval = [2,5]
+<strong>Output:</strong> [[1,5],[6,9]]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+<strong>Output:</strong> [[1,2],[3,10],[12,16]]
+<strong>Explanation:</strong> Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= intervals.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>intervals[i].length == 2</code></li>
+	<li><code>0 &lt;= start<sub>i</sub> &lt;= end<sub>i</sub> &lt;= 10<sup>5</sup></code></li>
+	<li><code>intervals</code> is sorted by <code>start<sub>i</sub></code> in <strong>ascending</strong> order.</li>
+	<li><code>newInterval.length == 2</code></li>
+	<li><code>0 &lt;= start &lt;= end &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0058-length-of-last-word/0058-length-of-last-word.java b/leetcode/leetcode/0058-length-of-last-word/0058-length-of-last-word.java
new file mode 100644
index 0000000..13a7436
--- /dev/null
+++ b/leetcode/leetcode/0058-length-of-last-word/0058-length-of-last-word.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int lengthOfLastWord(String s) {
+        int index = s.length()-1;
+        int size = 0;
+        for(int i = s.length()-1;i!=-1;i--){
+            if(s.charAt(i)==' '){
+                if(size!=0) return size;
+                continue;
+            }
+            size++;
+        }
+        return size;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0058-length-of-last-word/NOTES.md b/leetcode/leetcode/0058-length-of-last-word/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0058-length-of-last-word/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0058-length-of-last-word/README.md b/leetcode/leetcode/0058-length-of-last-word/README.md
new file mode 100644
index 0000000..f5d2873
--- /dev/null
+++ b/leetcode/leetcode/0058-length-of-last-word/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/length-of-last-word/">58. Length of Last Word</a></h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code> consisting of words and spaces, return <em>the length of the <strong>last</strong> word in the string.</em></p>
+
+<p>A <strong>word</strong> is a maximal <span data-keyword="substring-nonempty">substring</span> consisting of non-space characters only.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "Hello World"
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The last word is "World" with length 5.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "   fly me   to   the moon  "
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The last word is "moon" with length 4.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "luffy is still joyboy"
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The last word is "joyboy" with length 6.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of only English letters and spaces <code>' '</code>.</li>
+	<li>There will be at least one word in <code>s</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0061-rotate-list/0061-rotate-list.java b/leetcode/leetcode/0061-rotate-list/0061-rotate-list.java
new file mode 100644
index 0000000..ef9ad54
--- /dev/null
+++ b/leetcode/leetcode/0061-rotate-list/0061-rotate-list.java
@@ -0,0 +1,40 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode rotateRight(ListNode head, int k) {
+        if(k == 0) return head;
+        if(head == null|| head.next==null) return head;
+        int size = 0;
+        ListNode temp = head;
+        while(temp!=null){
+            size++;
+            temp = temp.next;
+        }
+        temp = head;
+        k = k%size;
+        if(k == 0) return head;
+        k = size - k;
+        for(int i = 0;i<k-1;i++){
+            temp = temp.next;
+        }
+        ListNode newHead = temp.next;
+        temp.next = null;
+        temp = head;
+        head = newHead;
+        ListNode temp2 = newHead;
+        while(temp2.next!=null){
+            temp2 = temp2.next;
+        }
+        temp2.next = temp;
+        return newHead;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0061-rotate-list/NOTES.md b/leetcode/leetcode/0061-rotate-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0061-rotate-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0061-rotate-list/README.md b/leetcode/leetcode/0061-rotate-list/README.md
new file mode 100644
index 0000000..65b7b86
--- /dev/null
+++ b/leetcode/leetcode/0061-rotate-list/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/rotate-list">61. Rotate List</a></h2><h3>Medium</h3><hr><p>Given the <code>head</code> of a linked&nbsp;list, rotate the list to the right by <code>k</code> places.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/rotate1.jpg" style="width: 450px; height: 191px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5], k = 2
+<strong>Output:</strong> [4,5,1,2,3]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/roate2.jpg" style="width: 305px; height: 350px;" />
+<pre>
+<strong>Input:</strong> head = [0,1,2], k = 4
+<strong>Output:</strong> [2,0,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 500]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li><code>0 &lt;= k &lt;= 2 * 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0062-unique-paths/0062-unique-paths.java b/leetcode/leetcode/0062-unique-paths/0062-unique-paths.java
new file mode 100644
index 0000000..ea02add
--- /dev/null
+++ b/leetcode/leetcode/0062-unique-paths/0062-unique-paths.java
@@ -0,0 +1,77 @@
+// Recursion: TLE
+// class Solution {
+//     public int helper(int m, int n, int i, int j){
+//         if(i ==  m-1 && j == n-1) return 1;
+//         if(i>= m || j>=n) return 0;
+//         return helper(m,n,i+1,j) + helper(m,n,i,j+1);    
+//     }
+//     public int uniquePaths(int m, int n) {
+//         return helper(m,n,0,0);
+//     }
+// }
+
+// Method: 2 Memoization
+// class Solution {
+//     public int helper(int m, int n, int i, int j, int[][] dp){
+//         if(i>= m || j>=n) return 0;
+//         if(dp[i][j]!=-1) return dp[i][j];
+//         if(i ==  m-1 && j == n-1) return 1;
+//         dp[i][j] =  helper(m,n,i+1,j,dp) + helper(m,n,i,j+1,dp);
+//         return dp[i][j];
+//     }
+//     public int uniquePaths(int m, int n) {
+//         int[][] dp = new int[m][n];
+//         for(int i = 0;i<m;i++){
+//             for(int j = 0;j<n;j++){
+//                 dp[i][j] = -1;
+//             }
+//         }
+//         return helper(m,n,0,0,dp);
+//     }
+// }
+
+// Method: 3 Dynammic Programming
+// Time Complexity  : O(m*n)
+// Space Complexity : O(m*n) 
+// class Solution {
+//     public int uniquePaths(int m, int n) {
+//         int[][] dp = new int[m][n];
+//         for(int i = 0;i<n;i++){
+//             dp[m-1][i] = 1;
+//         }
+//         for(int i = 0;i<m;i++){
+//             dp[i][n-1] = 1;
+//         }
+//         for(int i = m-2;i>=0;i--){
+//             for(int j = n-2;j>=0;j--){
+//                 dp[i][j] = dp[i+1][j] + dp[i][j+1];
+//             }
+//         }
+//         return dp[0][0];
+//     }
+// }
+
+
+
+class Solution{
+    public int helper(int currentRow, int currentCol, int m, int n, int[][] memo){
+
+        if(currentRow>=m || currentCol>=n) return 0;
+        if(currentRow == m-1  && currentCol == n-1) return 1;
+        if(memo[currentRow][currentCol] != -1) return memo[currentRow][currentCol];
+
+        int ans = helper(currentRow+1,currentCol,m,n,memo) + helper(currentRow, currentCol+1,m,n,memo);
+        memo[currentRow][currentCol] = ans;
+        return ans;
+        
+    }
+    public int uniquePaths(int m, int n) {
+        int[][] memo = new int[m][n];
+        for(int i = 0;i<m;i++){
+            for(int j = 0;j<n;j++){
+                memo[i][j] = -1;
+            }
+        }
+        return helper(0,0,m,n,memo);
+    }
+}
diff --git a/leetcode/leetcode/0062-unique-paths/README.md b/leetcode/leetcode/0062-unique-paths/README.md
new file mode 100644
index 0000000..b676820
--- /dev/null
+++ b/leetcode/leetcode/0062-unique-paths/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/unique-paths">62. Unique Paths</a></h2><h3>Medium</h3><hr><p>There is a robot on an <code>m x n</code> grid. The robot is initially located at the <strong>top-left corner</strong> (i.e., <code>grid[0][0]</code>). The robot tries to move to the <strong>bottom-right corner</strong> (i.e., <code>grid[m - 1][n - 1]</code>). The robot can only move either down or right at any point in time.</p>
+
+<p>Given the two integers <code>m</code> and <code>n</code>, return <em>the number of possible unique paths that the robot can take to reach the bottom-right corner</em>.</p>
+
+<p>The test cases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png" style="width: 400px; height: 183px;" />
+<pre>
+<strong>Input:</strong> m = 3, n = 7
+<strong>Output:</strong> 28
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> m = 3, n = 2
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
+1. Right -&gt; Down -&gt; Down
+2. Down -&gt; Down -&gt; Right
+3. Down -&gt; Right -&gt; Down
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= m, n &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0063-unique-paths-ii/0063-unique-paths-ii.java b/leetcode/leetcode/0063-unique-paths-ii/0063-unique-paths-ii.java
new file mode 100644
index 0000000..f0323e9
--- /dev/null
+++ b/leetcode/leetcode/0063-unique-paths-ii/0063-unique-paths-ii.java
@@ -0,0 +1,61 @@
+// Method: 1 Recursion (TLE)
+// class Solution {
+//     public int helper(int[][] obstacleGrid, int row, int col){
+//         if(row >= obstacleGrid.length || col >= obstacleGrid[0].length) return 0;
+//         if(row == obstacleGrid.length - 1 && col == obstacleGrid[0].length - 1) return 1;
+//         if(obstacleGrid[row][col] == 1) return 0;
+//         return helper(obstacleGrid,row+1,col) + helper(obstacleGrid,row,col+1);
+//     }
+//     public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+//         return helper(obstacleGrid,0,0);
+//     }
+// }
+
+// Method : 2 Memoization  
+// class Solution {
+//     public int helper(int[][] obstacleGrid, int row, int col, int[][] dp){
+//         if(row >= obstacleGrid.length || col >= obstacleGrid[0].length) return 0;
+//         if(row == obstacleGrid.length - 1 && col == obstacleGrid[0].length - 1) return 1;
+//         if(obstacleGrid[row][col] == 1) return 0;
+//         if(dp[row][col]!=-1) return dp[row][col];
+//         dp[row][col] = helper(obstacleGrid,row+1,col,dp) + helper(obstacleGrid,row,col+1,dp);
+//         return dp[row][col];
+//     }
+//     public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+//         if(obstacleGrid[obstacleGrid.length -1][obstacleGrid[0].length -1 ] == 1) return 0;
+
+//         int[][] dp = new int[obstacleGrid.length][obstacleGrid[0].length];
+//         for(int  i = 0;i<dp.length;i++){
+//             for(int j = 0;j<dp[0].length;j++){
+//                 dp[i][j]= -1;
+//             }
+//         }
+//         return helper(obstacleGrid,0,0,dp);
+//     }
+// }
+
+// Method: 1 Recursion (TLE)
+class Solution {
+    public int helper(int[][] grid, int[][] memo, int row, int col){
+        if(row >= grid.length || col >= grid[0].length) return 0;
+        if(grid[row][col] == 1) return 0;
+        if(memo[row][col]!=-1) return memo[row][col];
+        if(row ==  grid.length - 1 && col == grid[0].length -1) return 1;
+        int ans = helper(grid,memo,row+1,col) + helper(grid,memo,row,col+1);
+        memo[row][col] = ans;
+        return ans;
+    }
+    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+        int row = obstacleGrid.length;
+        int col = obstacleGrid[0].length;
+        int[][] memo = new int[row][col];
+        for(int i = 0;i<row;i++){
+            for(int j = 0;j<col;j++){
+                memo[i][j] = -1;
+            }
+        }
+        return helper(obstacleGrid,memo,0,0);
+    }
+}
+
+
diff --git a/leetcode/leetcode/0063-unique-paths-ii/README.md b/leetcode/leetcode/0063-unique-paths-ii/README.md
new file mode 100644
index 0000000..2b02424
--- /dev/null
+++ b/leetcode/leetcode/0063-unique-paths-ii/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/unique-paths-ii">63. Unique Paths II</a></h2><h3>Medium</h3><hr><p>You are given an <code>m x n</code> integer array <code>grid</code>. There is a robot initially located at the <b>top-left corner</b> (i.e., <code>grid[0][0]</code>). The robot tries to move to the <strong>bottom-right corner</strong> (i.e., <code>grid[m - 1][n - 1]</code>). The robot can only move either down or right at any point in time.</p>
+
+<p>An obstacle and space are marked as <code>1</code> or <code>0</code> respectively in <code>grid</code>. A path that the robot takes cannot include <strong>any</strong> square that is an obstacle.</p>
+
+<p>Return <em>the number of possible unique paths that the robot can take to reach the bottom-right corner</em>.</p>
+
+<p>The testcases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/robot1.jpg" style="width: 242px; height: 242px;" />
+<pre>
+<strong>Input:</strong> obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There is one obstacle in the middle of the 3x3 grid above.
+There are two ways to reach the bottom-right corner:
+1. Right -&gt; Right -&gt; Down -&gt; Down
+2. Down -&gt; Down -&gt; Right -&gt; Right
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg" style="width: 162px; height: 162px;" />
+<pre>
+<strong>Input:</strong> obstacleGrid = [[0,1],[0,0]]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == obstacleGrid.length</code></li>
+	<li><code>n == obstacleGrid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 100</code></li>
+	<li><code>obstacleGrid[i][j]</code> is <code>0</code> or <code>1</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0064-minimum-path-sum/0064-minimum-path-sum.java b/leetcode/leetcode/0064-minimum-path-sum/0064-minimum-path-sum.java
new file mode 100644
index 0000000..6971d8c
--- /dev/null
+++ b/leetcode/leetcode/0064-minimum-path-sum/0064-minimum-path-sum.java
@@ -0,0 +1,41 @@
+class Solution {
+    // Approach 1: Recursion - TLE
+    // TC        : O(2^(mxn))
+    // SC        : O(1) 
+    // public int helper(int[][] grid, int row, int col){
+    //     if(row == grid.length -1 && col ==  grid[0].length -1) return grid[row][col];
+    //     if(row>=grid.length || col>= grid[0].length) return Integer.MAX_VALUE;
+
+    //     int choice1 = helper(grid,row+1,col);
+    //     int choice2 = helper(grid, row, col+1);
+
+    //     return Math.min(choice1,choice2) + grid[row][col];
+    // }
+    // public int minPathSum(int[][] grid) {
+    //     return helper(grid,0,0);
+    // }
+
+    // Approach 2: Memoization
+
+    public int helper(int[][] grid, int[][] memo, int row, int col){
+        if(row == grid.length -1 && col ==  grid[0].length -1) return grid[row][col];
+        if(row>=grid.length || col>= grid[0].length) return Integer.MAX_VALUE;
+        if(memo[row][col]!=-1) return memo[row][col];
+
+        int choice1 = helper(grid,memo, row+1, col);
+        int choice2 = helper(grid,memo, row,   col+1);
+
+        memo[row][col] = Math.min(choice1,choice2) + grid[row][col];
+        return memo[row][col];
+    }
+
+    public int minPathSum(int[][] grid) {
+        int[][] memo = new int[grid.length][grid[0].length];
+        for(int i = 0;i<grid.length;i++){
+            for(int j = 0;j<grid[0].length;j++){
+                memo[i][j] = -1;
+            }
+        }
+        return helper(grid,memo,0,0);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0064-minimum-path-sum/README.md b/leetcode/leetcode/0064-minimum-path-sum/README.md
new file mode 100644
index 0000000..83eb5e5
--- /dev/null
+++ b/leetcode/leetcode/0064-minimum-path-sum/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/minimum-path-sum">64. Minimum Path Sum</a></h2><h3>Medium</h3><hr><p>Given a <code>m x n</code> <code>grid</code> filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.</p>
+
+<p><strong>Note:</strong> You can only move either down or right at any point in time.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/05/minpath.jpg" style="width: 242px; height: 242px;" />
+<pre>
+<strong>Input:</strong> grid = [[1,3,1],[1,5,1],[4,2,1]]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Because the path 1 &rarr; 3 &rarr; 1 &rarr; 1 &rarr; 1 minimizes the sum.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[1,2,3],[4,5,6]]
+<strong>Output:</strong> 12
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 200</code></li>
+	<li><code>0 &lt;= grid[i][j] &lt;= 200</code></li>
+</ul>
diff --git a/leetcode/leetcode/0069-sqrtx/0069-sqrtx.java b/leetcode/leetcode/0069-sqrtx/0069-sqrtx.java
new file mode 100644
index 0000000..12aaf14
--- /dev/null
+++ b/leetcode/leetcode/0069-sqrtx/0069-sqrtx.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int mySqrt(int x) {
+        int low = 0;
+        int high = x;
+        int mid = low + (high-low)/2;
+        int ans = mid;
+        while(low<=high){
+            mid = low + (high-low)/2;
+            if(1l*mid*mid<=x){
+                ans = mid;
+                low = mid+1;
+            }else{
+                high = mid-1;
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0069-sqrtx/README.md b/leetcode/leetcode/0069-sqrtx/README.md
new file mode 100644
index 0000000..7e5ae55
--- /dev/null
+++ b/leetcode/leetcode/0069-sqrtx/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/sqrtx">69. Sqrt(x)</a></h2><h3>Easy</h3><hr><p>Given a non-negative integer <code>x</code>, return <em>the square root of </em><code>x</code><em> rounded down to the nearest integer</em>. The returned integer should be <strong>non-negative</strong> as well.</p>
+
+<p>You <strong>must not use</strong> any built-in exponent function or operator.</p>
+
+<ul>
+	<li>For example, do not use <code>pow(x, 0.5)</code> in c++ or <code>x ** 0.5</code> in python.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> x = 4
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The square root of 4 is 2, so we return 2.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> x = 8
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The square root of 8 is 2.82842..., and since we round it down to the nearest integer, 2 is returned.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= x &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
diff --git a/leetcode/leetcode/0070-climbing-stairs/0070-climbing-stairs.java b/leetcode/leetcode/0070-climbing-stairs/0070-climbing-stairs.java
new file mode 100644
index 0000000..50e9857
--- /dev/null
+++ b/leetcode/leetcode/0070-climbing-stairs/0070-climbing-stairs.java
@@ -0,0 +1,50 @@
+class Solution {
+    // Approach: 4
+    //
+    public int climbStairs(int n) {
+        if(n == 1) return 1;
+        if(n == 2) return 2;
+        int prev = 1;
+        int lastPrev = 2;
+        int ans = prev+lastPrev;
+        for(int i = 3;i<=n;i++){
+            ans = prev+lastPrev;
+            prev = lastPrev;
+            lastPrev = ans;
+        }
+        return ans;
+    }
+
+    // // Approach 3: Dynammic Programming
+    // public int climbStairs(int n) {
+    //     int[] dp = new int[n+1];
+    //     dp[1] = 1;
+    //     dp[2] = 2;
+    //     for(int i = 3;i<=n;i++){
+    //         dp[i] = dp[i-1]+dp[i-2];
+    //     }
+    //     return dp[n];
+
+    // }
+
+
+
+    // Approach 2: Memoization with HashMap
+    // HashMap<Integer,Integer> map = new HashMap<>();
+    // public int climbStairs(int n) {
+    //     if(n == 1) return 1;
+    //     if(n == 2) return 2;
+    //     if(map.containsKey(n)) return map.get(n);
+    //     int nAns = climbStairs(n-1) + climbStairs(n-2);
+    //     map.put(n,nAns);
+    //     return nAns;
+    // }
+    
+    // Approach 1: Recursion (TLE)
+    // public int climbStairs(int n) {
+    //     if(n == 1) return 1;
+    //     if(n == 2) return 2;
+    //     return climbStairs(n-1) + climbStairs(n-2);
+
+    // }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0070-climbing-stairs/README.md b/leetcode/leetcode/0070-climbing-stairs/README.md
new file mode 100644
index 0000000..0c59768
--- /dev/null
+++ b/leetcode/leetcode/0070-climbing-stairs/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/climbing-stairs">70. Climbing Stairs</a></h2><h3>Easy</h3><hr><p>You are climbing a staircase. It takes <code>n</code> steps to reach the top.</p>
+
+<p>Each time you can either climb <code>1</code> or <code>2</code> steps. In how many distinct ways can you climb to the top?</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 2
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There are two ways to climb to the top.
+1. 1 step + 1 step
+2. 2 steps
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> There are three ways to climb to the top.
+1. 1 step + 1 step + 1 step
+2. 1 step + 2 steps
+3. 2 steps + 1 step
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 45</code></li>
+</ul>
diff --git a/leetcode/leetcode/0073-set-matrix-zeroes/0073-set-matrix-zeroes.java b/leetcode/leetcode/0073-set-matrix-zeroes/0073-set-matrix-zeroes.java
new file mode 100644
index 0000000..e8102c5
--- /dev/null
+++ b/leetcode/leetcode/0073-set-matrix-zeroes/0073-set-matrix-zeroes.java
@@ -0,0 +1,68 @@
+class Solution {
+    public void setZeroes(int[][] matrix) {
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+
+        boolean first_row_has_zero = false;
+        boolean first_col_has_zero = false;
+
+        // check if first row has any zero
+        for(int c = 0;c<cols;c++){
+            if(matrix[0][c] == 0){
+                first_row_has_zero = true;
+                break;
+            }
+        }
+
+        // check if first col has any zero
+        for(int r = 0;r<rows;r++){
+            if(matrix[r][0] == 0){
+                first_col_has_zero = true;
+                break;
+            }
+        }
+        // checking for zero elsewhere and keeping track of it in the first row and first column
+        for(int r = 1;r<rows;r++){
+            for(int c = 1;c<cols;c++){
+                if(matrix[r][c] == 0){
+                    matrix[r][0] = 0;
+                    matrix[0][c] = 0;
+                }
+            }
+        }
+
+        // checking and setting respcted row to zero
+        for(int c = 1;c<cols; c++){
+            if(matrix[0][c] == 0){
+                for(int r = 0;r<rows;r++){
+                    matrix[r][c] = 0;
+                }
+            }
+        }
+
+        // checking and setting respcted cols to zero
+        for(int r = 1;r<rows; r++){
+            if(matrix[r][0] == 0){
+                for(int c = 0;c<cols;c++){
+                    matrix[r][c] = 0;
+                }
+            }
+        }
+
+        if(first_row_has_zero == true){
+            for(int c = 0;c<cols;c++){
+                matrix[0][c] = 0;
+            }
+        }
+
+        if(first_col_has_zero == true){
+            for(int r = 0;r<rows;r++){
+                matrix[r][0] = 0;
+            }
+        }
+
+
+        
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0073-set-matrix-zeroes/NOTES.md b/leetcode/leetcode/0073-set-matrix-zeroes/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0073-set-matrix-zeroes/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0073-set-matrix-zeroes/README.md b/leetcode/leetcode/0073-set-matrix-zeroes/README.md
new file mode 100644
index 0000000..090588b
--- /dev/null
+++ b/leetcode/leetcode/0073-set-matrix-zeroes/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/set-matrix-zeroes">73. Set Matrix Zeroes</a></h2><h3>Medium</h3><hr><p>Given an <code>m x n</code> integer matrix <code>matrix</code>, if an element is <code>0</code>, set its entire row and column to <code>0</code>&#39;s.</p>
+
+<p>You must do it <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in place</a>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/17/mat1.jpg" style="width: 450px; height: 169px;" />
+<pre>
+<strong>Input:</strong> matrix = [[1,1,1],[1,0,1],[1,1,1]]
+<strong>Output:</strong> [[1,0,1],[0,0,0],[1,0,1]]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/17/mat2.jpg" style="width: 450px; height: 137px;" />
+<pre>
+<strong>Input:</strong> matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+<strong>Output:</strong> [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == matrix.length</code></li>
+	<li><code>n == matrix[0].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 200</code></li>
+	<li><code>-2<sup>31</sup> &lt;= matrix[i][j] &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>A straightforward solution using <code>O(mn)</code> space is probably a bad idea.</li>
+	<li>A simple improvement uses <code>O(m + n)</code> space, but still not the best solution.</li>
+	<li>Could you devise a constant space solution?</li>
+</ul>
diff --git a/leetcode/leetcode/0075-sort-colors/0075-sort-colors.java b/leetcode/leetcode/0075-sort-colors/0075-sort-colors.java
new file mode 100644
index 0000000..153dbc2
--- /dev/null
+++ b/leetcode/leetcode/0075-sort-colors/0075-sort-colors.java
@@ -0,0 +1,24 @@
+class Solution {
+    public void swap(int [] arr, int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    public void sortColors(int[] arr) {
+        int low = 0;
+        int mid = 0;
+        int high = arr.length-1;
+        while(mid<=high){
+            if(arr[mid] == 0){
+                swap(arr,low,mid);
+                mid++;
+                low++;
+            }else if(arr[mid] == 1){
+                mid++;
+            }else{
+                swap(arr,mid,high);
+                high--;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0075-sort-colors/README.md b/leetcode/leetcode/0075-sort-colors/README.md
new file mode 100644
index 0000000..4288266
--- /dev/null
+++ b/leetcode/leetcode/0075-sort-colors/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/sort-colors">75. Sort Colors</a></h2><h3>Medium</h3><hr><p>Given an array <code>nums</code> with <code>n</code> objects colored red, white, or blue, sort them <strong><a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> </strong>so that objects of the same color are adjacent, with the colors in the order red, white, and blue.</p>
+
+<p>We will use the integers <code>0</code>, <code>1</code>, and <code>2</code> to represent the color red, white, and blue, respectively.</p>
+
+<p>You must solve this problem without using the library&#39;s sort function.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,0,2,1,1,0]
+<strong>Output:</strong> [0,0,1,1,2,2]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,0,1]
+<strong>Output:</strong> [0,1,2]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 300</code></li>
+	<li><code>nums[i]</code> is either <code>0</code>, <code>1</code>, or <code>2</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong>&nbsp;Could you come up with a one-pass algorithm using only&nbsp;constant extra space?</p>
diff --git a/leetcode/leetcode/0076-minimum-window-substring/0076-minimum-window-substring.java b/leetcode/leetcode/0076-minimum-window-substring/0076-minimum-window-substring.java
new file mode 100644
index 0000000..5b325e2
--- /dev/null
+++ b/leetcode/leetcode/0076-minimum-window-substring/0076-minimum-window-substring.java
@@ -0,0 +1,37 @@
+class Solution {
+    public boolean equals(int[] freq, int[] currFreq){
+        for(int i = 0;i<freq.length;i++){
+            if(freq[i]>currFreq[i]) return false;
+        }
+        return true;
+    }
+    public String minWindow(String s, String t) {
+        if(t.length()>s.length()) return "";
+        int[] freqT = new int[128];
+        for(int i = 0;i<t.length();i++){
+            freqT[(int) t.charAt(i)]++;
+        }
+        int[] freqCurrentWindow = new int[128];
+        int currentStart = 0;
+        int currentEnd   = Integer.MAX_VALUE;
+        int start = 0;
+        int end   = 0;
+        freqCurrentWindow[s.charAt(start)]++;
+        while(end<s.length()){
+            if(equals(freqT,freqCurrentWindow)){
+                if(currentEnd - currentStart>end-start){
+                    currentEnd = end;
+                    currentStart = start;
+                }
+                freqCurrentWindow[(int) s.charAt(start)]--;
+                start++;               
+            }else if(end<s.length()-1){
+                end++;
+                freqCurrentWindow[(int) s.charAt(end)]++;
+            }else break;
+        }
+        if(currentEnd == Integer.MAX_VALUE ) return "";
+        return s.substring(currentStart,currentEnd+1);
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0076-minimum-window-substring/README.md b/leetcode/leetcode/0076-minimum-window-substring/README.md
new file mode 100644
index 0000000..4e4e993
--- /dev/null
+++ b/leetcode/leetcode/0076-minimum-window-substring/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/minimum-window-substring">76. Minimum Window Substring</a></h2><h3>Hard</h3><hr><p>Given two strings <code>s</code> and <code>t</code> of lengths <code>m</code> and <code>n</code> respectively, return <em>the <strong>minimum window</strong></em> <span data-keyword="substring-nonempty"><strong><em>substring</em></strong></span><em> of </em><code>s</code><em> such that every character in </em><code>t</code><em> (<strong>including duplicates</strong>) is included in the window</em>. If there is no such substring, return <em>the empty string </em><code>&quot;&quot;</code>.</p>
+
+<p>The testcases will be generated such that the answer is <strong>unique</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;ADOBECODEBANC&quot;, t = &quot;ABC&quot;
+<strong>Output:</strong> &quot;BANC&quot;
+<strong>Explanation:</strong> The minimum window substring &quot;BANC&quot; includes &#39;A&#39;, &#39;B&#39;, and &#39;C&#39; from string t.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;a&quot;, t = &quot;a&quot;
+<strong>Output:</strong> &quot;a&quot;
+<strong>Explanation:</strong> The entire string s is the minimum window.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;a&quot;, t = &quot;aa&quot;
+<strong>Output:</strong> &quot;&quot;
+<strong>Explanation:</strong> Both &#39;a&#39;s from t must be included in the window.
+Since the largest window of s only has one &#39;a&#39;, return empty string.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == s.length</code></li>
+	<li><code>n == t.length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> and <code>t</code> consist of uppercase and lowercase English letters.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you find an algorithm that runs in <code>O(m + n)</code> time?</p>
diff --git a/leetcode/leetcode/0078-subsets/0078-subsets.java b/leetcode/leetcode/0078-subsets/0078-subsets.java
new file mode 100644
index 0000000..0153bf6
--- /dev/null
+++ b/leetcode/leetcode/0078-subsets/0078-subsets.java
@@ -0,0 +1,26 @@
+class Solution {
+    public List<List<Integer>> generateSubSet(int[] nums, int currentIndex){
+        List<List<Integer>> result = new ArrayList<>();
+         System.out.println(currentIndex);
+        if(currentIndex == 0){
+            List<Integer> list = new ArrayList<>();
+            result.add(list);
+            return result;
+        }
+        result = generateSubSet(nums,--currentIndex);
+       
+        List<List<Integer>> finalResult = new ArrayList<>(result);
+
+        for(int i = 0;i<result.size();i++){
+            List<Integer> temp = new ArrayList<>(result.get(i));
+            // finalResult.add(temp);
+            temp.add(nums[currentIndex]);
+            finalResult.add(temp);
+        }
+        return finalResult;
+
+    }
+    public List<List<Integer>> subsets(int[] nums) {
+        return generateSubSet(nums,nums.length);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0078-subsets/0078-subsets.py b/leetcode/leetcode/0078-subsets/0078-subsets.py
new file mode 100644
index 0000000..353d253
--- /dev/null
+++ b/leetcode/leetcode/0078-subsets/0078-subsets.py
@@ -0,0 +1,16 @@
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        res = []
+        curr_path = []
+
+        def dfs(index):
+            if(index==len(nums)):
+                res.append(curr_path[:])
+                return
+            
+            curr_path.append(nums[index])
+            dfs(index+1)
+            curr_path.pop()
+            dfs(index+1)
+        dfs(0)
+        return res
\ No newline at end of file
diff --git a/leetcode/leetcode/0078-subsets/README.md b/leetcode/leetcode/0078-subsets/README.md
new file mode 100644
index 0000000..fb4b5a7
--- /dev/null
+++ b/leetcode/leetcode/0078-subsets/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/subsets">78. Subsets</a></h2><h3>Medium</h3><hr><p>Given an integer array <code>nums</code> of <strong>unique</strong> elements, return <em>all possible</em> <span data-keyword="subset"><em>subsets</em></span> <em>(the power set)</em>.</p>
+
+<p>The solution set <strong>must not</strong> contain duplicate subsets. Return the solution in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0]
+<strong>Output:</strong> [[],[0]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10</code></li>
+	<li><code>-10 &lt;= nums[i] &lt;= 10</code></li>
+	<li>All the numbers of&nbsp;<code>nums</code> are <strong>unique</strong>.</li>
+</ul>
diff --git a/leetcode/leetcode/0082-remove-duplicates-from-sorted-list-ii/0082-remove-duplicates-from-sorted-list-ii.cpp b/leetcode/leetcode/0082-remove-duplicates-from-sorted-list-ii/0082-remove-duplicates-from-sorted-list-ii.cpp
new file mode 100644
index 0000000..c5253aa
--- /dev/null
+++ b/leetcode/leetcode/0082-remove-duplicates-from-sorted-list-ii/0082-remove-duplicates-from-sorted-list-ii.cpp
@@ -0,0 +1,41 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* deleteDuplicates(ListNode* head) {
+
+        if(!head||!head->next){
+            return head;
+        }
+        ListNode* first = head, * second = head->next;
+
+        if(first->val==second->val){
+
+            int curr = first->val;
+
+            ListNode* temp = second;
+            while(temp&&(temp->val==curr)){
+                temp=temp->next;
+            }
+
+            return deleteDuplicates(temp);
+
+        }else{
+            head -> next = deleteDuplicates(head->next);
+
+        }
+
+        return head;
+
+        
+        
+    }
+};
\ No newline at end of file
diff --git a/leetcode/leetcode/0082-remove-duplicates-from-sorted-list-ii/README.md b/leetcode/leetcode/0082-remove-duplicates-from-sorted-list-ii/README.md
new file mode 100644
index 0000000..6a04b7a
--- /dev/null
+++ b/leetcode/leetcode/0082-remove-duplicates-from-sorted-list-ii/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii">82. Remove Duplicates from Sorted List II</a></h2><h3>Medium</h3><hr><p>Given the <code>head</code> of a sorted linked list, <em>delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list</em>. Return <em>the linked list <strong>sorted</strong> as well</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist1.jpg" style="width: 500px; height: 142px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,3,4,4,5]
+<strong>Output:</strong> [1,2,5]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist2.jpg" style="width: 500px; height: 205px;" />
+<pre>
+<strong>Input:</strong> head = [1,1,1,2,3]
+<strong>Output:</strong> [2,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 300]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li>The list is guaranteed to be <strong>sorted</strong> in ascending order.</li>
+</ul>
diff --git a/leetcode/leetcode/0083-remove-duplicates-from-sorted-list/0083-remove-duplicates-from-sorted-list.java b/leetcode/leetcode/0083-remove-duplicates-from-sorted-list/0083-remove-duplicates-from-sorted-list.java
new file mode 100644
index 0000000..400d086
--- /dev/null
+++ b/leetcode/leetcode/0083-remove-duplicates-from-sorted-list/0083-remove-duplicates-from-sorted-list.java
@@ -0,0 +1,26 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        if(head == null || head.next == null){
+            return head;
+        }
+        ListNode current = head;
+        while(current.next != null){
+            if(current.val == current.next.val){
+                current.next = current.next.next;
+            }else{
+                current = current.next;
+            }
+        }
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0083-remove-duplicates-from-sorted-list/README.md b/leetcode/leetcode/0083-remove-duplicates-from-sorted-list/README.md
new file mode 100644
index 0000000..9e0949f
--- /dev/null
+++ b/leetcode/leetcode/0083-remove-duplicates-from-sorted-list/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/remove-duplicates-from-sorted-list">83. Remove Duplicates from Sorted List</a></h2><h3>Easy</h3><hr><p>Given the <code>head</code> of a sorted linked list, <em>delete all duplicates such that each element appears only once</em>. Return <em>the linked list <strong>sorted</strong> as well</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/list1.jpg" style="width: 302px; height: 242px;" />
+<pre>
+<strong>Input:</strong> head = [1,1,2]
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/list2.jpg" style="width: 542px; height: 222px;" />
+<pre>
+<strong>Input:</strong> head = [1,1,2,3,3]
+<strong>Output:</strong> [1,2,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 300]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li>The list is guaranteed to be <strong>sorted</strong> in ascending order.</li>
+</ul>
diff --git a/leetcode/leetcode/0088-merge-sorted-array/0088-merge-sorted-array.java b/leetcode/leetcode/0088-merge-sorted-array/0088-merge-sorted-array.java
new file mode 100644
index 0000000..678d901
--- /dev/null
+++ b/leetcode/leetcode/0088-merge-sorted-array/0088-merge-sorted-array.java
@@ -0,0 +1,44 @@
+class Solution {
+    public void swap(int[] arr, int indx1, int indx2){
+        int temp = arr[indx1];
+        arr[indx1] = arr[indx2];
+        arr[indx2] = temp;
+    }
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+        if(m==0){
+            for(int i =0;i<nums2.length;i++){
+                nums1[i] = nums2[i];
+            }
+            return;
+        }
+        if(n==0){
+            return;
+        }
+        int end = nums1.length - 1;
+        int start = m-1;
+        while(start!=-1){
+            swap(nums1,end,start);
+            end--;
+            start--;
+        }
+        int currentIndex = 0;
+        int indx1 = nums1.length-m;
+        int indx2 = 0;
+        while(currentIndex<nums1.length){
+            if(indx2 == nums2.length){
+                nums1[currentIndex++] = nums1[indx1++];
+                continue;
+            }else if(indx1== nums1.length){
+                nums1[currentIndex++] = nums2[indx2++];
+                continue;
+            }
+
+            if(nums1[indx1]>=nums2[indx2]){
+                nums1[currentIndex++] = nums2[indx2++];
+            }else{
+                nums1[currentIndex++] = nums1[indx1++];
+            }
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0088-merge-sorted-array/NOTES.md b/leetcode/leetcode/0088-merge-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0088-merge-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0088-merge-sorted-array/README.md b/leetcode/leetcode/0088-merge-sorted-array/README.md
new file mode 100644
index 0000000..50730b6
--- /dev/null
+++ b/leetcode/leetcode/0088-merge-sorted-array/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/merge-sorted-array">88. Merge Sorted Array</a></h2><h3>Easy</h3><hr><p>You are given two integer arrays <code>nums1</code> and <code>nums2</code>, sorted in <strong>non-decreasing order</strong>, and two integers <code>m</code> and <code>n</code>, representing the number of elements in <code>nums1</code> and <code>nums2</code> respectively.</p>
+
+<p><strong>Merge</strong> <code>nums1</code> and <code>nums2</code> into a single array sorted in <strong>non-decreasing order</strong>.</p>
+
+<p>The final sorted array should not be returned by the function, but instead be <em>stored inside the array </em><code>nums1</code>. To accommodate this, <code>nums1</code> has a length of <code>m + n</code>, where the first <code>m</code> elements denote the elements that should be merged, and the last <code>n</code> elements are set to <code>0</code> and should be ignored. <code>nums2</code> has a length of <code>n</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+<strong>Output:</strong> [1,2,2,3,5,6]
+<strong>Explanation:</strong> The arrays we are merging are [1,2,3] and [2,5,6].
+The result of the merge is [<u>1</u>,<u>2</u>,2,<u>3</u>,5,6] with the underlined elements coming from nums1.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [1], m = 1, nums2 = [], n = 0
+<strong>Output:</strong> [1]
+<strong>Explanation:</strong> The arrays we are merging are [1] and [].
+The result of the merge is [1].
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [0], m = 0, nums2 = [1], n = 1
+<strong>Output:</strong> [1]
+<strong>Explanation:</strong> The arrays we are merging are [] and [1].
+The result of the merge is [1].
+Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>nums1.length == m + n</code></li>
+	<li><code>nums2.length == n</code></li>
+	<li><code>0 &lt;= m, n &lt;= 200</code></li>
+	<li><code>1 &lt;= m + n &lt;= 200</code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums1[i], nums2[j] &lt;= 10<sup>9</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up: </strong>Can you come up with an algorithm that runs in <code>O(m + n)</code> time?</p>
diff --git a/leetcode/leetcode/0092-reverse-linked-list-ii/0092-reverse-linked-list-ii.java b/leetcode/leetcode/0092-reverse-linked-list-ii/0092-reverse-linked-list-ii.java
new file mode 100644
index 0000000..015cf69
--- /dev/null
+++ b/leetcode/leetcode/0092-reverse-linked-list-ii/0092-reverse-linked-list-ii.java
@@ -0,0 +1,61 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode reverse(ListNode head){
+        ListNode prev = null;
+        ListNode curr = head;
+        ListNode next = head.next;
+        while(next!=null){
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+            next = next.next;
+        }
+        curr.next = prev;
+        return curr;
+    }
+    public ListNode reverseBetween(ListNode head, int left, int right) {
+        if(head == null || head.next == null) return head;
+        if(left == right) return head;
+        ListNode headPrev = null;
+        ListNode head1 = null;
+        ListNode tail1 = null;
+        ListNode tailNext = null;
+        ListNode temp = head;
+        int index =1;
+        while(temp!=null){
+            if(index+1 == left){
+                headPrev = temp;
+
+            }else if(index == left){
+                head1 = temp;
+            }else if(index == right){
+                tail1 = temp;
+            }else if(index == right+1){
+                tailNext = temp;
+                break;
+            }
+            temp = temp.next;
+            index++;
+        }
+        tail1.next = null;
+        if(headPrev == null){
+            head = reverse(head);
+        }else{
+            headPrev.next = null;
+            headPrev.next = reverse(head1);
+        }
+        head1.next = tailNext;
+        return head;
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0092-reverse-linked-list-ii/README.md b/leetcode/leetcode/0092-reverse-linked-list-ii/README.md
new file mode 100644
index 0000000..ef7393e
--- /dev/null
+++ b/leetcode/leetcode/0092-reverse-linked-list-ii/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/reverse-linked-list-ii">92. Reverse Linked List II</a></h2><h3>Medium</h3><hr><p>Given the <code>head</code> of a singly linked list and two integers <code>left</code> and <code>right</code> where <code>left &lt;= right</code>, reverse the nodes of the list from position <code>left</code> to position <code>right</code>, and return <em>the reversed list</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/rev2ex2.jpg" style="width: 542px; height: 222px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5], left = 2, right = 4
+<strong>Output:</strong> [1,4,3,2,5]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> head = [5], left = 1, right = 1
+<strong>Output:</strong> [5]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is <code>n</code>.</li>
+	<li><code>1 &lt;= n &lt;= 500</code></li>
+	<li><code>-500 &lt;= Node.val &lt;= 500</code></li>
+	<li><code>1 &lt;= left &lt;= right &lt;= n</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you do it in one pass?
\ No newline at end of file
diff --git a/leetcode/leetcode/0094-binary-tree-inorder-traversal/0094-binary-tree-inorder-traversal.java b/leetcode/leetcode/0094-binary-tree-inorder-traversal/0094-binary-tree-inorder-traversal.java
new file mode 100644
index 0000000..75d8815
--- /dev/null
+++ b/leetcode/leetcode/0094-binary-tree-inorder-traversal/0094-binary-tree-inorder-traversal.java
@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    List<Integer> result = new ArrayList<>();
+
+    public void helper(TreeNode root){
+        if(root == null) return;
+        helper(root.left);
+        result.add(root.val);
+        helper(root.right);
+
+    }
+    
+    public List<Integer> inorderTraversal(TreeNode root) {
+        helper(root);
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0094-binary-tree-inorder-traversal/0094-binary-tree-inorder-traversal.py b/leetcode/leetcode/0094-binary-tree-inorder-traversal/0094-binary-tree-inorder-traversal.py
new file mode 100644
index 0000000..281bbf6
--- /dev/null
+++ b/leetcode/leetcode/0094-binary-tree-inorder-traversal/0094-binary-tree-inorder-traversal.py
@@ -0,0 +1,15 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        if(root == None): return []
+
+        result = []
+        left = self.inorderTraversal(root.left)
+        right = self.inorderTraversal(root.right)
+
+        return left + [root.val] + right
\ No newline at end of file
diff --git a/leetcode/leetcode/0094-binary-tree-inorder-traversal/README.md b/leetcode/leetcode/0094-binary-tree-inorder-traversal/README.md
new file mode 100644
index 0000000..bd34dc7
--- /dev/null
+++ b/leetcode/leetcode/0094-binary-tree-inorder-traversal/README.md
@@ -0,0 +1,53 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-inorder-traversal">94. Binary Tree Inorder Traversal</a></h2><h3>Easy</h3><hr><p>Given the <code>root</code> of a binary tree, return <em>the inorder traversal of its nodes&#39; values</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1,null,2,3]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1,3,2]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png" style="width: 200px; height: 264px;" /></p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1,2,3,4,5,null,8,null,null,6,7,9]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[4,2,6,5,7,1,3,9,8]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/tree_2.png" style="width: 350px; height: 286px;" /></p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = []</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[]</span></p>
+</div>
+
+<p><strong class="example">Example 4:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1]</span></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?
\ No newline at end of file
diff --git a/leetcode/leetcode/0098-validate-binary-search-tree/0098-validate-binary-search-tree.java b/leetcode/leetcode/0098-validate-binary-search-tree/0098-validate-binary-search-tree.java
new file mode 100644
index 0000000..5e9fcfd
--- /dev/null
+++ b/leetcode/leetcode/0098-validate-binary-search-tree/0098-validate-binary-search-tree.java
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+
+    public boolean helper(TreeNode root, long min, long max){
+        if(root == null) return true;
+
+        if(root.val>min && root.val<max){
+            return helper(root.left,min,root.val) && helper(root.right,root.val,max);
+        }else{
+            return false;
+        }
+    }
+
+
+
+
+    public boolean isValidBST(TreeNode root) {
+        return helper(root,Long.MIN_VALUE, Long.MAX_VALUE);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0098-validate-binary-search-tree/0098-validate-binary-search-tree.py b/leetcode/leetcode/0098-validate-binary-search-tree/0098-validate-binary-search-tree.py
new file mode 100644
index 0000000..1929b35
--- /dev/null
+++ b/leetcode/leetcode/0098-validate-binary-search-tree/0098-validate-binary-search-tree.py
@@ -0,0 +1,17 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def helper(self,root,min_val,max_val):
+        if(root == None): return True
+
+        if(min_val<root.val<max_val):
+            return self.helper(root.left,min_val,root.val) and self.helper(root.right,root.val,max_val)
+        else:
+            return False    
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        return self.helper(root, float('-inf'), float('inf'))
+
diff --git a/leetcode/leetcode/0098-validate-binary-search-tree/README.md b/leetcode/leetcode/0098-validate-binary-search-tree/README.md
new file mode 100644
index 0000000..957fcdb
--- /dev/null
+++ b/leetcode/leetcode/0098-validate-binary-search-tree/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/validate-binary-search-tree">98. Validate Binary Search Tree</a></h2><h3>Medium</h3><hr><p>Given the <code>root</code> of a binary tree, <em>determine if it is a valid binary search tree (BST)</em>.</p>
+
+<p>A <strong>valid BST</strong> is defined as follows:</p>
+
+<ul>
+	<li>The left <span data-keyword="subtree">subtree</span> of a node contains only nodes with keys <strong>less than</strong> the node&#39;s key.</li>
+	<li>The right subtree of a node contains only nodes with keys <strong>greater than</strong> the node&#39;s key.</li>
+	<li>Both the left and right subtrees must also be binary search trees.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/01/tree1.jpg" style="width: 302px; height: 182px;" />
+<pre>
+<strong>Input:</strong> root = [2,1,3]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/01/tree2.jpg" style="width: 422px; height: 292px;" />
+<pre>
+<strong>Input:</strong> root = [5,1,4,null,null,3,6]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The root node&#39;s value is 5 but its right child&#39;s value is 4.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-2<sup>31</sup> &lt;= Node.val &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
diff --git a/leetcode/leetcode/0100-same-tree/0100-same-tree.java b/leetcode/leetcode/0100-same-tree/0100-same-tree.java
new file mode 100644
index 0000000..9c926f6
--- /dev/null
+++ b/leetcode/leetcode/0100-same-tree/0100-same-tree.java
@@ -0,0 +1,22 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        if(p==null && q == null) return true;
+        if(p==null || q == null) return false;
+        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right) && p.val == q.val;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0100-same-tree/NOTES.md b/leetcode/leetcode/0100-same-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0100-same-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0100-same-tree/README.md b/leetcode/leetcode/0100-same-tree/README.md
new file mode 100644
index 0000000..e68046f
--- /dev/null
+++ b/leetcode/leetcode/0100-same-tree/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/same-tree">100. Same Tree</a></h2><h3>Easy</h3><hr><p>Given the roots of two binary trees <code>p</code> and <code>q</code>, write a function to check if they are the same or not.</p>
+
+<p>Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg" style="width: 622px; height: 182px;" />
+<pre>
+<strong>Input:</strong> p = [1,2,3], q = [1,2,3]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg" style="width: 382px; height: 182px;" />
+<pre>
+<strong>Input:</strong> p = [1,2], q = [1,null,2]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex3.jpg" style="width: 622px; height: 182px;" />
+<pre>
+<strong>Input:</strong> p = [1,2,1], q = [1,1,2]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in both trees is in the range <code>[0, 100]</code>.</li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0102-binary-tree-level-order-traversal/0102-binary-tree-level-order-traversal.java b/leetcode/leetcode/0102-binary-tree-level-order-traversal/0102-binary-tree-level-order-traversal.java
new file mode 100644
index 0000000..5ffcc18
--- /dev/null
+++ b/leetcode/leetcode/0102-binary-tree-level-order-traversal/0102-binary-tree-level-order-traversal.java
@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        
+        List<List<Integer>> result = new ArrayList<>();
+        if(root == null) return result;
+        Queue<TreeNode> q = new LinkedList<>();
+
+        q.add(root);
+
+        while(!q.isEmpty()){
+
+            List<Integer> level = new ArrayList<>();
+
+            for(int i = q.size();i!=0;i--){
+                TreeNode node = q.poll();
+
+                level.add(node.val);
+
+                if(node.left!=null) q.add(node.left);
+
+                if(node.right!=null) q.add(node.right);
+
+            }
+            result.add(level);
+
+
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0102-binary-tree-level-order-traversal/README.md b/leetcode/leetcode/0102-binary-tree-level-order-traversal/README.md
new file mode 100644
index 0000000..01b65fd
--- /dev/null
+++ b/leetcode/leetcode/0102-binary-tree-level-order-traversal/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-level-order-traversal">102. Binary Tree Level Order Traversal</a></h2><h3>Medium</h3><hr><p>Given the <code>root</code> of a binary tree, return <em>the level order traversal of its nodes&#39; values</em>. (i.e., from left to right, level by level).</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
+<pre>
+<strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> [[3],[9,20],[15,7]]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [1]
+<strong>Output:</strong> [[1]]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/0103-binary-tree-zigzag-level-order-traversal/0103-binary-tree-zigzag-level-order-traversal.java b/leetcode/leetcode/0103-binary-tree-zigzag-level-order-traversal/0103-binary-tree-zigzag-level-order-traversal.java
new file mode 100644
index 0000000..194d96c
--- /dev/null
+++ b/leetcode/leetcode/0103-binary-tree-zigzag-level-order-traversal/0103-binary-tree-zigzag-level-order-traversal.java
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        if(root == null) return result;
+
+        Queue<TreeNode> q =new LinkedList<>();
+        q.add(root);
+        boolean zigzag = true;
+
+        while(!q.isEmpty()){
+            int n = q.size();
+            List<Integer> level = new ArrayList<>();
+
+            // traverssing one level
+            for(int i = 0;i<n;i++){
+                root = q.poll();
+
+                if(root.left!=null) q.add(root.left);
+                if(root.right!=null) q.add(root.right);
+                if(zigzag){
+                    level.add(root.val);
+                }else{
+                    level.add(0,root.val);
+                }
+
+            }
+            result.add(level);
+            zigzag = !zigzag;
+
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0103-binary-tree-zigzag-level-order-traversal/README.md b/leetcode/leetcode/0103-binary-tree-zigzag-level-order-traversal/README.md
new file mode 100644
index 0000000..fcd20aa
--- /dev/null
+++ b/leetcode/leetcode/0103-binary-tree-zigzag-level-order-traversal/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal">103. Binary Tree Zigzag Level Order Traversal</a></h2><h3>Medium</h3><hr><p>Given the <code>root</code> of a binary tree, return <em>the zigzag level order traversal of its nodes&#39; values</em>. (i.e., from left to right, then right to left for the next level and alternate between).</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;" />
+<pre>
+<strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> [[3],[20,9],[15,7]]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [1]
+<strong>Output:</strong> [[1]]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0104-maximum-depth-of-binary-tree/0104-maximum-depth-of-binary-tree.java b/leetcode/leetcode/0104-maximum-depth-of-binary-tree/0104-maximum-depth-of-binary-tree.java
new file mode 100644
index 0000000..cbfd5c6
--- /dev/null
+++ b/leetcode/leetcode/0104-maximum-depth-of-binary-tree/0104-maximum-depth-of-binary-tree.java
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if(root == null) return 0;
+
+        int lH = maxDepth(root.left);
+        int rH = maxDepth(root.right);
+
+        return Math.max(lH,rH) + 1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0104-maximum-depth-of-binary-tree/README.md b/leetcode/leetcode/0104-maximum-depth-of-binary-tree/README.md
new file mode 100644
index 0000000..3e88d40
--- /dev/null
+++ b/leetcode/leetcode/0104-maximum-depth-of-binary-tree/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/maximum-depth-of-binary-tree">104. Maximum Depth of Binary Tree</a></h2><h3>Easy</h3><hr><p>Given the <code>root</code> of a binary tree, return <em>its maximum depth</em>.</p>
+
+<p>A binary tree&#39;s <strong>maximum depth</strong>&nbsp;is the number of nodes along the longest path from the root node down to the farthest leaf node.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg" style="width: 400px; height: 277px;" />
+<pre>
+<strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [1,null,2]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0106-construct-binary-tree-from-inorder-and-postorder-traversal/0106-construct-binary-tree-from-inorder-and-postorder-traversal.cpp b/leetcode/leetcode/0106-construct-binary-tree-from-inorder-and-postorder-traversal/0106-construct-binary-tree-from-inorder-and-postorder-traversal.cpp
new file mode 100644
index 0000000..23a4edf
--- /dev/null
+++ b/leetcode/leetcode/0106-construct-binary-tree-from-inorder-and-postorder-traversal/0106-construct-binary-tree-from-inorder-and-postorder-traversal.cpp
@@ -0,0 +1,50 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+//inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
+
+    TreeNode* build(vector<int>& inorder, vector<int>& postorder,int inS, int inE, int pS, int pE,unordered_map<int,int>& mp ){
+        if(inS>inE||pS>pE){
+            return NULL;
+        }
+
+
+        int rootV = postorder[pE];
+
+        int inIdx = mp[rootV];
+
+        TreeNode* root= new TreeNode(rootV);
+
+        int leftTreeSize = inIdx - inS;
+        int rightTreeSize = inE - inIdx;
+        root->left = build(inorder,postorder,inS,inIdx-1,pS,pS+leftTreeSize-1,mp);
+        root->right = build(inorder,postorder,inIdx+1,inE,pE-rightTreeSize,pE-1,mp);
+
+        return root;
+
+    }
+
+    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
+
+
+        unordered_map<int,int> mp;
+        int n = inorder.size();
+
+        for(int i=0;i<n;i++){
+            mp[inorder[i]]=i;
+        }
+
+        return build(inorder,postorder,0,n-1,0,n-1,mp);
+        
+    }
+};
\ No newline at end of file
diff --git a/leetcode/leetcode/0106-construct-binary-tree-from-inorder-and-postorder-traversal/README.md b/leetcode/leetcode/0106-construct-binary-tree-from-inorder-and-postorder-traversal/README.md
new file mode 100644
index 0000000..8169bc7
--- /dev/null
+++ b/leetcode/leetcode/0106-construct-binary-tree-from-inorder-and-postorder-traversal/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal">106. Construct Binary Tree from Inorder and Postorder Traversal</a></h2><h3>Medium</h3><hr><p>Given two integer arrays <code>inorder</code> and <code>postorder</code> where <code>inorder</code> is the inorder traversal of a binary tree and <code>postorder</code> is the postorder traversal of the same tree, construct and return <em>the binary tree</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree.jpg" style="width: 277px; height: 302px;" />
+<pre>
+<strong>Input:</strong> inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
+<strong>Output:</strong> [3,9,20,null,null,15,7]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> inorder = [-1], postorder = [-1]
+<strong>Output:</strong> [-1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= inorder.length &lt;= 3000</code></li>
+	<li><code>postorder.length == inorder.length</code></li>
+	<li><code>-3000 &lt;= inorder[i], postorder[i] &lt;= 3000</code></li>
+	<li><code>inorder</code> and <code>postorder</code> consist of <strong>unique</strong> values.</li>
+	<li>Each value of <code>postorder</code> also appears in <code>inorder</code>.</li>
+	<li><code>inorder</code> is <strong>guaranteed</strong> to be the inorder traversal of the tree.</li>
+	<li><code>postorder</code> is <strong>guaranteed</strong> to be the postorder traversal of the tree.</li>
+</ul>
diff --git a/leetcode/leetcode/0108-convert-sorted-array-to-binary-search-tree/0108-convert-sorted-array-to-binary-search-tree.java b/leetcode/leetcode/0108-convert-sorted-array-to-binary-search-tree/0108-convert-sorted-array-to-binary-search-tree.java
new file mode 100644
index 0000000..0d60392
--- /dev/null
+++ b/leetcode/leetcode/0108-convert-sorted-array-to-binary-search-tree/0108-convert-sorted-array-to-binary-search-tree.java
@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode helper(int[] nums, int startIndex, int endIndex){
+        if(startIndex>endIndex) return null;
+        if(startIndex==endIndex) return new TreeNode(nums[startIndex]);
+
+        int mid = (startIndex+endIndex)/2;
+
+        TreeNode root = new TreeNode(nums[mid]);
+
+        root.left = helper(nums,startIndex,mid-1);
+        root.right = helper(nums,mid+1,endIndex);
+        return root;
+    }
+    public TreeNode sortedArrayToBST(int[] nums) {
+        return helper(nums,0,nums.length-1);
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0108-convert-sorted-array-to-binary-search-tree/README.md b/leetcode/leetcode/0108-convert-sorted-array-to-binary-search-tree/README.md
new file mode 100644
index 0000000..243a285
--- /dev/null
+++ b/leetcode/leetcode/0108-convert-sorted-array-to-binary-search-tree/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree">108. Convert Sorted Array to Binary Search Tree</a></h2><h3>Easy</h3><hr><p>Given an integer array <code>nums</code> where the elements are sorted in <strong>ascending order</strong>, convert <em>it to a </em><span data-keyword="height-balanced"><strong><em>height-balanced</em></strong></span> <em>binary search tree</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree1.jpg" style="width: 302px; height: 222px;" />
+<pre>
+<strong>Input:</strong> nums = [-10,-3,0,5,9]
+<strong>Output:</strong> [0,-3,9,-10,null,5]
+<strong>Explanation:</strong> [0,-10,5,null,-3,null,9] is also accepted:
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree2.jpg" style="width: 302px; height: 222px;" />
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree.jpg" style="width: 342px; height: 142px;" />
+<pre>
+<strong>Input:</strong> nums = [1,3]
+<strong>Output:</strong> [3,1]
+<strong>Explanation:</strong> [1,null,3] and [3,1] are both height-balanced BSTs.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+	<li><code>nums</code> is sorted in a <strong>strictly increasing</strong> order.</li>
+</ul>
diff --git a/leetcode/leetcode/0110-balanced-binary-tree/0110-balanced-binary-tree.java b/leetcode/leetcode/0110-balanced-binary-tree/0110-balanced-binary-tree.java
new file mode 100644
index 0000000..9b77fb8
--- /dev/null
+++ b/leetcode/leetcode/0110-balanced-binary-tree/0110-balanced-binary-tree.java
@@ -0,0 +1,43 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public class Pair{
+        int height;
+        boolean balanced;
+        Pair(int height, boolean balanced){
+            this.height = height;
+            this.balanced = balanced;
+        }
+    }
+
+    public Pair helper(TreeNode root){
+        if(root == null){
+            return new Pair(0,true);
+        }
+
+        Pair left = helper(root.left);
+        Pair right = helper(root.right);
+
+
+        if(left.balanced == true && right.balanced == true && Math.abs(left.height - right.height) <= 1){
+            return new Pair(Math.max(left.height,right.height)+1, true);
+        }
+        return new Pair(Math.max(left.height,right.height)+1, false);
+    }
+    public boolean isBalanced(TreeNode root) {
+        return helper(root).balanced;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0110-balanced-binary-tree/README.md b/leetcode/leetcode/0110-balanced-binary-tree/README.md
new file mode 100644
index 0000000..1496517
--- /dev/null
+++ b/leetcode/leetcode/0110-balanced-binary-tree/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/balanced-binary-tree">110. Balanced Binary Tree</a></h2><h3>Easy</h3><hr><p>Given a binary tree, determine if it is <span data-keyword="height-balanced"><strong>height-balanced</strong></span>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_1.jpg" style="width: 342px; height: 221px;" />
+<pre>
+<strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_2.jpg" style="width: 452px; height: 301px;" />
+<pre>
+<strong>Input:</strong> root = [1,2,2,3,3,null,null,4,4]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = []
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 5000]</code>.</li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0112-path-sum/0112-path-sum.java b/leetcode/leetcode/0112-path-sum/0112-path-sum.java
new file mode 100644
index 0000000..ed212a4
--- /dev/null
+++ b/leetcode/leetcode/0112-path-sum/0112-path-sum.java
@@ -0,0 +1,24 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean hasPathSum(TreeNode root, int targetSum) {
+        if(root == null) return false;
+
+        if(targetSum == root.val && root.left == null && root.right == null ) return true;
+
+        return hasPathSum(root.left,targetSum-root.val) || hasPathSum(root.right, targetSum-root.val);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0112-path-sum/README.md b/leetcode/leetcode/0112-path-sum/README.md
new file mode 100644
index 0000000..98772e5
--- /dev/null
+++ b/leetcode/leetcode/0112-path-sum/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/path-sum">112. Path Sum</a></h2><h3>Easy</h3><hr><p>Given the <code>root</code> of a binary tree and an integer <code>targetSum</code>, return <code>true</code> if the tree has a <strong>root-to-leaf</strong> path such that adding up all the values along the path equals <code>targetSum</code>.</p>
+
+<p>A <strong>leaf</strong> is a node with no children.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum1.jpg" style="width: 500px; height: 356px;" />
+<pre>
+<strong>Input:</strong> root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The root-to-leaf path with the target sum is shown.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg" />
+<pre>
+<strong>Input:</strong> root = [1,2,3], targetSum = 5
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There are two root-to-leaf paths in the tree:
+(1 --&gt; 2): The sum is 3.
+(1 --&gt; 3): The sum is 4.
+There is no root-to-leaf path with sum = 5.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [], targetSum = 0
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Since the tree is empty, there are no root-to-leaf paths.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 5000]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+	<li><code>-1000 &lt;= targetSum &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/0114-flatten-binary-tree-to-linked-list/0114-flatten-binary-tree-to-linked-list.java b/leetcode/leetcode/0114-flatten-binary-tree-to-linked-list/0114-flatten-binary-tree-to-linked-list.java
new file mode 100644
index 0000000..23ee3bb
--- /dev/null
+++ b/leetcode/leetcode/0114-flatten-binary-tree-to-linked-list/0114-flatten-binary-tree-to-linked-list.java
@@ -0,0 +1,38 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public void flatten(TreeNode root) {
+        if(root == null) return;
+
+        flatten(root.left);
+        flatten(root.right);
+
+        TreeNode leftTemp = root.left;
+        root.left = null;
+        TreeNode rightTemp = root.right;
+
+        if(leftTemp==null){
+            return;
+        }else{
+            root.right = leftTemp;
+            while(root.right!=null){
+                root = root.right;
+
+            }
+            root.right= rightTemp;
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0114-flatten-binary-tree-to-linked-list/README.md b/leetcode/leetcode/0114-flatten-binary-tree-to-linked-list/README.md
new file mode 100644
index 0000000..581431b
--- /dev/null
+++ b/leetcode/leetcode/0114-flatten-binary-tree-to-linked-list/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/flatten-binary-tree-to-linked-list">114. Flatten Binary Tree to Linked List</a></h2><h3>Medium</h3><hr><p>Given the <code>root</code> of a binary tree, flatten the tree into a &quot;linked list&quot;:</p>
+
+<ul>
+	<li>The &quot;linked list&quot; should use the same <code>TreeNode</code> class where the <code>right</code> child pointer points to the next node in the list and the <code>left</code> child pointer is always <code>null</code>.</li>
+	<li>The &quot;linked list&quot; should be in the same order as a <a href="https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR" target="_blank"><strong>pre-order</strong><strong> traversal</strong></a> of the binary tree.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/14/flaten.jpg" style="width: 500px; height: 226px;" />
+<pre>
+<strong>Input:</strong> root = [1,2,5,3,4,null,6]
+<strong>Output:</strong> [1,null,2,null,3,null,4,null,5,null,6]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [0]
+<strong>Output:</strong> [0]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Can you flatten the tree in-place (with <code>O(1)</code> extra space)?
\ No newline at end of file
diff --git a/leetcode/leetcode/0116-populating-next-right-pointers-in-each-node/0116-populating-next-right-pointers-in-each-node.java b/leetcode/leetcode/0116-populating-next-right-pointers-in-each-node/0116-populating-next-right-pointers-in-each-node.java
new file mode 100644
index 0000000..3a063e9
--- /dev/null
+++ b/leetcode/leetcode/0116-populating-next-right-pointers-in-each-node/0116-populating-next-right-pointers-in-each-node.java
@@ -0,0 +1,51 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() {}
+    
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+};
+*/
+
+class Solution {
+    public Node connect(Node root) {
+        if(root == null) return root;
+
+        Queue<Node> q = new LinkedList<>();
+        Node temp = root;
+        q.add(root);
+        while(!q.isEmpty()){
+
+            int n = q.size();
+
+            for(int i = n;i!=0;i--){
+                root = q.poll();
+                if(i==1){
+                    root.next = null;
+                }else{
+                    root.next = q.peek();
+                }
+
+                if(root.left!=null) q.add(root.left);
+                if(root.right!=null) q.add(root.right);
+            }
+
+        }
+        return temp;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0116-populating-next-right-pointers-in-each-node/README.md b/leetcode/leetcode/0116-populating-next-right-pointers-in-each-node/README.md
new file mode 100644
index 0000000..04fdf61
--- /dev/null
+++ b/leetcode/leetcode/0116-populating-next-right-pointers-in-each-node/README.md
@@ -0,0 +1,46 @@
+<h2><a href="https://leetcode.com/problems/populating-next-right-pointers-in-each-node">116. Populating Next Right Pointers in Each Node</a></h2><h3>Medium</h3><hr><p>You are given a <strong>perfect binary tree</strong> where all leaves are on the same level, and every parent has two children. The binary tree has the following definition:</p>
+
+<pre>
+struct Node {
+  int val;
+  Node *left;
+  Node *right;
+  Node *next;
+}
+</pre>
+
+<p>Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to <code>NULL</code>.</p>
+
+<p>Initially, all next pointers are set to <code>NULL</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/02/14/116_sample.png" style="width: 500px; height: 171px;" />
+<pre>
+<strong>Input:</strong> root = [1,2,3,4,5,6,7]
+<strong>Output:</strong> [1,#,2,3,#,4,5,6,7,#]
+<strong>Explanation: </strong>Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with &#39;#&#39; signifying the end of each level.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 2<sup>12</sup> - 1]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong></p>
+
+<ul>
+	<li>You may only use constant extra space.</li>
+	<li>The recursive approach is fine. You may assume implicit stack space does not count as extra space for this problem.</li>
+</ul>
diff --git a/leetcode/leetcode/0118-pascals-triangle/0118-pascals-triangle.java b/leetcode/leetcode/0118-pascals-triangle/0118-pascals-triangle.java
new file mode 100644
index 0000000..c8862bd
--- /dev/null
+++ b/leetcode/leetcode/0118-pascals-triangle/0118-pascals-triangle.java
@@ -0,0 +1,31 @@
+class Solution {
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> result = new ArrayList<>();
+        List<Integer> one = new ArrayList<>();
+        one.add(1);
+        result.add(one);
+
+        if(numRows == 1) return result;
+
+        List<Integer> two = new ArrayList<>();
+        two.add(1);
+        two.add(1);
+        result.add(two);
+
+
+        if(numRows == 2) return result;
+
+
+        for(int i = 2;i<numRows;i++){
+            List<Integer> prev = result.get(i-1);
+            List<Integer> next = new ArrayList<>();
+            next.add(1);
+            for(int j = 1;j<prev.size();j++){
+                next.add(prev.get(j-1)+ prev.get(j));
+            }
+            next.add(1);
+            result.add(next);
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0118-pascals-triangle/README.md b/leetcode/leetcode/0118-pascals-triangle/README.md
new file mode 100644
index 0000000..549ce27
--- /dev/null
+++ b/leetcode/leetcode/0118-pascals-triangle/README.md
@@ -0,0 +1,18 @@
+<h2><a href="https://leetcode.com/problems/pascals-triangle">118. Pascal's Triangle</a></h2><h3>Easy</h3><hr><p>Given an integer <code>numRows</code>, return the first numRows of <strong>Pascal&#39;s triangle</strong>.</p>
+
+<p>In <strong>Pascal&#39;s triangle</strong>, each number is the sum of the two numbers directly above it as shown:</p>
+<img alt="" src="https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif" style="height:240px; width:260px" />
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> numRows = 5
+<strong>Output:</strong> [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> numRows = 1
+<strong>Output:</strong> [[1]]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= numRows &lt;= 30</code></li>
+</ul>
diff --git a/leetcode/leetcode/0119-pascals-triangle-ii/0119-pascals-triangle-ii.java b/leetcode/leetcode/0119-pascals-triangle-ii/0119-pascals-triangle-ii.java
new file mode 100644
index 0000000..aaa089e
--- /dev/null
+++ b/leetcode/leetcode/0119-pascals-triangle-ii/0119-pascals-triangle-ii.java
@@ -0,0 +1,23 @@
+class Solution {
+    public List<Integer> getRow(int rowIndex) {
+        if(rowIndex == 0){
+            List<Integer> list = new ArrayList<>();
+            list.add(1);
+            return list;
+        }
+        if(rowIndex == 1){
+            List<Integer> list = new ArrayList<>();
+            list.add(1);
+            list.add(1);
+            return list;
+        }
+        List<Integer> prev = getRow(rowIndex-1);
+        List<Integer> list = new ArrayList<>();
+        list.add(1);
+        for(int i = 1;i<prev.size();i++){
+            list.add(prev.get(i-1)+prev.get(i));
+        }
+        list.add(1);
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0119-pascals-triangle-ii/NOTES.md b/leetcode/leetcode/0119-pascals-triangle-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0119-pascals-triangle-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0119-pascals-triangle-ii/README.md b/leetcode/leetcode/0119-pascals-triangle-ii/README.md
new file mode 100644
index 0000000..b5fb956
--- /dev/null
+++ b/leetcode/leetcode/0119-pascals-triangle-ii/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/pascals-triangle-ii/">119. Pascal's Triangle II</a></h2><h3>Easy</h3><hr><div><p>Given an integer <code>rowIndex</code>, return the <code>rowIndex<sup>th</sup></code> (<strong>0-indexed</strong>) row of the <strong>Pascal's triangle</strong>.</p>
+
+<p>In <strong>Pascal's triangle</strong>, each number is the sum of the two numbers directly above it as shown:</p>
+<img alt="" src="https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif" style="height:240px; width:260px">
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> rowIndex = 3
+<strong>Output:</strong> [1,3,3,1]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> rowIndex = 0
+<strong>Output:</strong> [1]
+</pre><p><strong class="example">Example 3:</strong></p>
+<pre><strong>Input:</strong> rowIndex = 1
+<strong>Output:</strong> [1,1]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= rowIndex &lt;= 33</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you optimize your algorithm to use only <code>O(rowIndex)</code> extra space?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0120-triangle/0120-triangle.java b/leetcode/leetcode/0120-triangle/0120-triangle.java
new file mode 100644
index 0000000..d2fca90
--- /dev/null
+++ b/leetcode/leetcode/0120-triangle/0120-triangle.java
@@ -0,0 +1,54 @@
+// Approach: 1 Recursion: TLE
+// class Solution {
+//     public int helper(List<List<Integer>> traingle, int currentRow, int currentCol){
+//         if(currentRow>=traingle.size() || currentCol>=traingle.get(currentRow).size()) return 0;
+//         return traingle.get(currentRow).get(currentCol) + Math.min(
+//                         helper(traingle,currentRow+1,currentCol),
+//                         helper(traingle,currentRow+1,currentCol+1)
+//                     );
+//     }
+//     public int minimumTotal(List<List<Integer>> triangle) {
+//         return helper(triangle,0,0);
+//     }
+// }
+
+// Approach 2: Memoization
+// class Solution {
+//     public int helper(List<List<Integer>> traingle,int[][] memo, int currentRow, int currentCol){
+//         if(currentRow>=traingle.size() || currentCol>=traingle.get(currentRow).size()) return 0;
+//         if(memo[currentRow][currentCol]!=-1) return memo[currentRow][currentCol];
+//         memo[currentRow][currentCol]  = traingle.get(currentRow).get(currentCol) + Math.min(
+//                         helper(traingle,memo,currentRow+1,currentCol),
+//                         helper(traingle,memo,currentRow+1,currentCol+1)
+//                     );
+//         return memo[currentRow][currentCol];
+//     }
+//     public int minimumTotal(List<List<Integer>> triangle) {
+//         int[][] memo = new int[triangle.size()][triangle.size()];
+//         for(int i = 0;i<memo.length;i++){
+//             for(int j = 0;j<memo.length;j++){
+//                 memo[i][j] = -1;
+//             }
+//         }
+//         return helper(triangle,memo,0,0);
+//     }
+// }
+
+// Approach 3: Dyannamic Programming
+class Solution {
+
+    public int minimumTotal(List<List<Integer>> triangle) {
+        int[][] dp = new int[triangle.size()+1][triangle.size()+1];
+
+        for(int i = triangle.size() - 1;i!=-1;i--){
+            for(int j = triangle.get(i).size()-1;j!=-1;j--){
+                dp[i][j]  = triangle.get(i).get(j) + Math.min(
+                        dp[i+1][j],
+                        dp[i+1][j+1]
+                );
+            }
+        }
+
+        return dp[0][0];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0120-triangle/README.md b/leetcode/leetcode/0120-triangle/README.md
new file mode 100644
index 0000000..041b5f2
--- /dev/null
+++ b/leetcode/leetcode/0120-triangle/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/triangle">120. Triangle</a></h2><h3>Medium</h3><hr><p>Given a <code>triangle</code> array, return <em>the minimum path sum from top to bottom</em>.</p>
+
+<p>For each step, you may move to an adjacent number of the row below. More formally, if you are on index <code>i</code> on the current row, you may move to either index <code>i</code> or index <code>i + 1</code> on the next row.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
+<strong>Output:</strong> 11
+<strong>Explanation:</strong> The triangle looks like:
+   <u>2</u>
+  <u>3</u> 4
+ 6 <u>5</u> 7
+4 <u>1</u> 8 3
+The minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above).
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> triangle = [[-10]]
+<strong>Output:</strong> -10
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= triangle.length &lt;= 200</code></li>
+	<li><code>triangle[0].length == 1</code></li>
+	<li><code>triangle[i].length == triangle[i - 1].length + 1</code></li>
+	<li><code>-10<sup>4</sup> &lt;= triangle[i][j] &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you&nbsp;do this using only <code>O(n)</code> extra space, where <code>n</code> is the total number of rows in the triangle?
\ No newline at end of file
diff --git a/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/0121-best-time-to-buy-and-sell-stock.java b/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/0121-best-time-to-buy-and-sell-stock.java
new file mode 100644
index 0000000..895d0a1
--- /dev/null
+++ b/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/0121-best-time-to-buy-and-sell-stock.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        int ans = 0;
+        int n = prices.length;
+        int maxTillNow = prices[n-1];
+        for(int i = n-2;i!=-1;i--){
+            ans = Math.max(ans,maxTillNow - prices[i]);
+            maxTillNow = Math.max(maxTillNow,prices[i]);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/0121-best-time-to-buy-and-sell-stock.py b/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/0121-best-time-to-buy-and-sell-stock.py
new file mode 100644
index 0000000..95f04f8
--- /dev/null
+++ b/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/0121-best-time-to-buy-and-sell-stock.py
@@ -0,0 +1,8 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        ans = 0
+        m = prices[0]
+        for p in prices:
+            ans = max(ans, p - m)
+            m = min(m,p)
+        return ans
\ No newline at end of file
diff --git a/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/NOTES.md b/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/README.md b/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/README.md
new file mode 100644
index 0000000..c985d4a
--- /dev/null
+++ b/leetcode/leetcode/0121-best-time-to-buy-and-sell-stock/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/best-time-to-buy-and-sell-stock">121. Best Time to Buy and Sell Stock</a></h2><h3>Easy</h3><hr><p>You are given an array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day.</p>
+
+<p>You want to maximize your profit by choosing a <strong>single day</strong> to buy one stock and choosing a <strong>different day in the future</strong> to sell that stock.</p>
+
+<p>Return <em>the maximum profit you can achieve from this transaction</em>. If you cannot achieve any profit, return <code>0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> prices = [7,1,5,3,6,4]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> prices = [7,6,4,3,1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> In this case, no transactions are done and the max profit = 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= prices.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= prices[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0124-binary-tree-maximum-path-sum/0124-binary-tree-maximum-path-sum.java b/leetcode/leetcode/0124-binary-tree-maximum-path-sum/0124-binary-tree-maximum-path-sum.java
new file mode 100644
index 0000000..7def5ce
--- /dev/null
+++ b/leetcode/leetcode/0124-binary-tree-maximum-path-sum/0124-binary-tree-maximum-path-sum.java
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    int max = Integer.MIN_VALUE;
+
+    public int helper(TreeNode root){
+        if(root == null) return 0;
+
+        int left = helper(root.left);
+        int right = helper(root.right);
+
+        max = Math.max(Math.max(max,left+right+root.val),Math.max(left+root.val,right+root.val));
+        max = Math.max(max,root.val);
+        return Math.max(root.val,Math.max(root.val+left,root.val+right));
+
+    }
+    
+    public int maxPathSum(TreeNode root) {
+        helper(root);
+        return max;
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0124-binary-tree-maximum-path-sum/README.md b/leetcode/leetcode/0124-binary-tree-maximum-path-sum/README.md
new file mode 100644
index 0000000..ffa0bc8
--- /dev/null
+++ b/leetcode/leetcode/0124-binary-tree-maximum-path-sum/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-maximum-path-sum">124. Binary Tree Maximum Path Sum</a></h2><h3>Hard</h3><hr><p>A <strong>path</strong> in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence <strong>at most once</strong>. Note that the path does not need to pass through the root.</p>
+
+<p>The <strong>path sum</strong> of a path is the sum of the node&#39;s values in the path.</p>
+
+<p>Given the <code>root</code> of a binary tree, return <em>the maximum <strong>path sum</strong> of any <strong>non-empty</strong> path</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx1.jpg" style="width: 322px; height: 182px;" />
+<pre>
+<strong>Input:</strong> root = [1,2,3]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The optimal path is 2 -&gt; 1 -&gt; 3 with a path sum of 2 + 1 + 3 = 6.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx2.jpg" />
+<pre>
+<strong>Input:</strong> root = [-10,9,20,null,null,15,7]
+<strong>Output:</strong> 42
+<strong>Explanation:</strong> The optimal path is 15 -&gt; 20 -&gt; 7 with a path sum of 15 + 20 + 7 = 42.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 3 * 10<sup>4</sup>]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/0125-valid-palindrome/0125-valid-palindrome.java b/leetcode/leetcode/0125-valid-palindrome/0125-valid-palindrome.java
new file mode 100644
index 0000000..6b4a066
--- /dev/null
+++ b/leetcode/leetcode/0125-valid-palindrome/0125-valid-palindrome.java
@@ -0,0 +1,22 @@
+class Solution {
+    public boolean isPalindrome(String s) {
+        int low = 0;
+        int high = s.length() - 1;
+        while(low<high){
+            int code1 = Character.toLowerCase(s.charAt(low));
+            if(!((code1>96 && code1 <123) || (code1 >47 && code1<58))){
+                low++;
+                continue;
+            }
+            int code2 = Character.toLowerCase(s.charAt(high));
+            if(!((code2>96 && code2<123) || (code2 >47 && code2<58))){
+                high--;
+                continue;
+            }
+            if(code1!=code2) return false;
+            low++;
+            high--;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0125-valid-palindrome/NOTES.md b/leetcode/leetcode/0125-valid-palindrome/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0125-valid-palindrome/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0125-valid-palindrome/README.md b/leetcode/leetcode/0125-valid-palindrome/README.md
new file mode 100644
index 0000000..b2217a0
--- /dev/null
+++ b/leetcode/leetcode/0125-valid-palindrome/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/valid-palindrome/">125. Valid Palindrome</a></h2><h3>Easy</h3><hr><div><p>A phrase is a <strong>palindrome</strong> if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.</p>
+
+<p>Given a string <code>s</code>, return <code>true</code><em> if it is a <strong>palindrome</strong>, or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "A man, a plan, a canal: Panama"
+<strong>Output:</strong> true
+<strong>Explanation:</strong> "amanaplanacanalpanama" is a palindrome.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "race a car"
+<strong>Output:</strong> false
+<strong>Explanation:</strong> "raceacar" is not a palindrome.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = " "
+<strong>Output:</strong> true
+<strong>Explanation:</strong> s is an empty string "" after removing non-alphanumeric characters.
+Since an empty string reads the same forward and backward, it is a palindrome.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 2 * 10<sup>5</sup></code></li>
+	<li><code>s</code> consists only of printable ASCII characters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0128-longest-consecutive-sequence/0128-longest-consecutive-sequence.java b/leetcode/leetcode/0128-longest-consecutive-sequence/0128-longest-consecutive-sequence.java
new file mode 100644
index 0000000..ad92ff2
--- /dev/null
+++ b/leetcode/leetcode/0128-longest-consecutive-sequence/0128-longest-consecutive-sequence.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int longestConsecutive(int[] arr) {
+        HashSet<Integer> set = new HashSet<>();
+        for(int num: arr){
+            set.add(num);
+        }
+
+        int streak = 0;
+        for(int num: set){
+            if(!set.contains(num-1)){
+                int currentStreak = 1;
+                int currentNum = num;
+                while(set.contains(currentNum+1)){
+                    currentStreak++;
+                    currentNum++;
+                }
+                streak = Math.max(streak,currentStreak);
+            }
+        }
+        return streak;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0128-longest-consecutive-sequence/README.md b/leetcode/leetcode/0128-longest-consecutive-sequence/README.md
new file mode 100644
index 0000000..bc9f29c
--- /dev/null
+++ b/leetcode/leetcode/0128-longest-consecutive-sequence/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/longest-consecutive-sequence">128. Longest Consecutive Sequence</a></h2><h3>Medium</h3><hr><p>Given an unsorted array of integers <code>nums</code>, return <em>the length of the longest consecutive elements sequence.</em></p>
+
+<p>You must write an algorithm that runs in&nbsp;<code>O(n)</code>&nbsp;time.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [100,4,200,1,3,2]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The longest consecutive elements sequence is <code>[1, 2, 3, 4]</code>. Therefore its length is 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,3,7,2,5,8,4,6,0,1]
+<strong>Output:</strong> 9
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,0,1,2]
+<strong>Output:</strong> 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0129-sum-root-to-leaf-numbers/0129-sum-root-to-leaf-numbers.java b/leetcode/leetcode/0129-sum-root-to-leaf-numbers/0129-sum-root-to-leaf-numbers.java
new file mode 100644
index 0000000..003c4cb
--- /dev/null
+++ b/leetcode/leetcode/0129-sum-root-to-leaf-numbers/0129-sum-root-to-leaf-numbers.java
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int helper(TreeNode root, int currentNum){
+        if(root == null) return 0;
+        currentNum = currentNum*10+root.val;
+        if(root.left == null && root.right == null) return currentNum;
+        return helper(root.left,currentNum) + helper(root.right,currentNum);
+    }
+    public int sumNumbers(TreeNode root) {
+        return helper(root,0);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0129-sum-root-to-leaf-numbers/README.md b/leetcode/leetcode/0129-sum-root-to-leaf-numbers/README.md
new file mode 100644
index 0000000..abefe7f
--- /dev/null
+++ b/leetcode/leetcode/0129-sum-root-to-leaf-numbers/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/sum-root-to-leaf-numbers/">129. Sum Root to Leaf Numbers</a></h2><h3>Medium</h3><hr><div><p>You are given the <code>root</code> of a binary tree containing digits from <code>0</code> to <code>9</code> only.</p>
+
+<p>Each root-to-leaf path in the tree represents a number.</p>
+
+<ul>
+	<li>For example, the root-to-leaf path <code>1 -&gt; 2 -&gt; 3</code> represents the number <code>123</code>.</li>
+</ul>
+
+<p>Return <em>the total sum of all root-to-leaf numbers</em>. Test cases are generated so that the answer will fit in a <strong>32-bit</strong> integer.</p>
+
+<p>A <strong>leaf</strong> node is a node with no children.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/num1tree.jpg" style="width: 212px; height: 182px;">
+<pre><strong>Input:</strong> root = [1,2,3]
+<strong>Output:</strong> 25
+<strong>Explanation:</strong>
+The root-to-leaf path <code>1-&gt;2</code> represents the number <code>12</code>.
+The root-to-leaf path <code>1-&gt;3</code> represents the number <code>13</code>.
+Therefore, sum = 12 + 13 = <code>25</code>.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/num2tree.jpg" style="width: 292px; height: 302px;">
+<pre><strong>Input:</strong> root = [4,9,0,5,1]
+<strong>Output:</strong> 1026
+<strong>Explanation:</strong>
+The root-to-leaf path <code>4-&gt;9-&gt;5</code> represents the number 495.
+The root-to-leaf path <code>4-&gt;9-&gt;1</code> represents the number 491.
+The root-to-leaf path <code>4-&gt;0</code> represents the number 40.
+Therefore, sum = 495 + 491 + 40 = <code>1026</code>.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 1000]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 9</code></li>
+	<li>The depth of the tree will not exceed <code>10</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0131-palindrome-partitioning/0131-palindrome-partitioning.py b/leetcode/leetcode/0131-palindrome-partitioning/0131-palindrome-partitioning.py
new file mode 100644
index 0000000..caf4a29
--- /dev/null
+++ b/leetcode/leetcode/0131-palindrome-partitioning/0131-palindrome-partitioning.py
@@ -0,0 +1,18 @@
+class Solution:
+    def partition(self, s: str) -> List[List[str]]:
+        res = []
+        curr_part = []
+
+        def helper(s):
+            if not s:
+                res.append(curr_part[:])
+                return
+            for i in range(len(s)):
+                temp = s[0:i+1]
+                if(temp == temp[::-1]):
+
+                    curr_part.append(temp)
+                    helper(s[i+1:])
+                    curr_part.pop()
+        helper(s)
+        return res
\ No newline at end of file
diff --git a/leetcode/leetcode/0131-palindrome-partitioning/README.md b/leetcode/leetcode/0131-palindrome-partitioning/README.md
new file mode 100644
index 0000000..8d1193b
--- /dev/null
+++ b/leetcode/leetcode/0131-palindrome-partitioning/README.md
@@ -0,0 +1,17 @@
+<h2><a href="https://leetcode.com/problems/palindrome-partitioning">131. Palindrome Partitioning</a></h2><h3>Medium</h3><hr><p>Given a string <code>s</code>, partition <code>s</code> such that every <span data-keyword="substring-nonempty">substring</span> of the partition is a <span data-keyword="palindrome-string"><strong>palindrome</strong></span>. Return <em>all possible palindrome partitioning of </em><code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "aab"
+<strong>Output:</strong> [["a","a","b"],["aa","b"]]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "a"
+<strong>Output:</strong> [["a"]]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 16</code></li>
+	<li><code>s</code> contains only lowercase English letters.</li>
+</ul>
diff --git a/leetcode/leetcode/0133-clone-graph/0133-clone-graph.java b/leetcode/leetcode/0133-clone-graph/0133-clone-graph.java
new file mode 100644
index 0000000..b82ba8a
--- /dev/null
+++ b/leetcode/leetcode/0133-clone-graph/0133-clone-graph.java
@@ -0,0 +1,37 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> neighbors;
+    public Node() {
+        val = 0;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val) {
+        val = _val;
+        neighbors = new ArrayList<Node>();
+    }
+    public Node(int _val, ArrayList<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+}
+*/
+
+class Solution {
+    public Node cloneHelper(Node node, HashMap<Node,Node> visited){
+        if(node == null) return node;
+        if(visited.containsKey(node)) return visited.get(node);
+
+        Node cloned = new Node(node.val);
+        visited.put(node,cloned);
+        for(int i = 0;i<node.neighbors.size();i++){
+            cloned.neighbors.add(cloneHelper(node.neighbors.get(i),visited));
+        }
+        return cloned;
+    }
+    public Node cloneGraph(Node node) {
+        HashMap<Node,Node> map = new HashMap<>();
+        return cloneHelper(node,map);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0133-clone-graph/README.md b/leetcode/leetcode/0133-clone-graph/README.md
new file mode 100644
index 0000000..38fdb5a
--- /dev/null
+++ b/leetcode/leetcode/0133-clone-graph/README.md
@@ -0,0 +1,62 @@
+<h2><a href="https://leetcode.com/problems/clone-graph">133. Clone Graph</a></h2><h3>Medium</h3><hr><p>Given a reference of a node in a <strong><a href="https://en.wikipedia.org/wiki/Connectivity_(graph_theory)#Connected_graph" target="_blank">connected</a></strong> undirected graph.</p>
+
+<p>Return a <a href="https://en.wikipedia.org/wiki/Object_copying#Deep_copy" target="_blank"><strong>deep copy</strong></a> (clone) of the graph.</p>
+
+<p>Each node in the graph contains a value (<code>int</code>) and a list (<code>List[Node]</code>) of its neighbors.</p>
+
+<pre>
+class Node {
+    public int val;
+    public List&lt;Node&gt; neighbors;
+}
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>Test case format:</strong></p>
+
+<p>For simplicity, each node&#39;s value is the same as the node&#39;s index (1-indexed). For example, the first node with <code>val == 1</code>, the second node with <code>val == 2</code>, and so on. The graph is represented in the test case using an adjacency list.</p>
+
+<p><b>An adjacency list</b> is a collection of unordered <b>lists</b> used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.</p>
+
+<p>The given node will always be the first node with <code>val = 1</code>. You must return the <strong>copy of the given node</strong> as a reference to the cloned graph.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/04/133_clone_graph_question.png" style="width: 454px; height: 500px;" />
+<pre>
+<strong>Input:</strong> adjList = [[2,4],[1,3],[2,4],[1,3]]
+<strong>Output:</strong> [[2,4],[1,3],[2,4],[1,3]]
+<strong>Explanation:</strong> There are 4 nodes in the graph.
+1st node (val = 1)&#39;s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+2nd node (val = 2)&#39;s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+3rd node (val = 3)&#39;s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+4th node (val = 4)&#39;s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/01/07/graph.png" style="width: 163px; height: 148px;" />
+<pre>
+<strong>Input:</strong> adjList = [[]]
+<strong>Output:</strong> [[]]
+<strong>Explanation:</strong> Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> adjList = []
+<strong>Output:</strong> []
+<strong>Explanation:</strong> This an empty graph, it does not have any nodes.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the graph is in the range <code>[0, 100]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 100</code></li>
+	<li><code>Node.val</code> is unique for each node.</li>
+	<li>There are no repeated edges and no self-loops in the graph.</li>
+	<li>The Graph is connected and all nodes can be visited starting from the given node.</li>
+</ul>
diff --git a/leetcode/leetcode/0134-gas-station/0134-gas-station.java b/leetcode/leetcode/0134-gas-station/0134-gas-station.java
new file mode 100644
index 0000000..74c453d
--- /dev/null
+++ b/leetcode/leetcode/0134-gas-station/0134-gas-station.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int canCompleteCircuit(int[] gas, int[] cost) {
+        int totalGas = 0;
+        int currentGas = 0;
+        int start = -1;
+        for(int i = 0;i<gas.length;i++){
+            totalGas = totalGas+gas[i]-cost[i];
+            currentGas = currentGas + gas[i]-cost[i];
+            if(currentGas<0){
+                currentGas = 0;
+                start = -1;
+                continue;
+            }
+            if(start==-1) start = i;
+            
+        }
+        if(totalGas<0) start = -1;
+        return start;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0134-gas-station/README.md b/leetcode/leetcode/0134-gas-station/README.md
new file mode 100644
index 0000000..24e2f2e
--- /dev/null
+++ b/leetcode/leetcode/0134-gas-station/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/gas-station/">134. Gas Station</a></h2><h3>Medium</h3><hr><div><p>There are <code>n</code> gas stations along a circular route, where the amount of gas at the <code>i<sup>th</sup></code> station is <code>gas[i]</code>.</p>
+
+<p>You have a car with an unlimited gas tank and it costs <code>cost[i]</code> of gas to travel from the <code>i<sup>th</sup></code> station to its next <code>(i + 1)<sup>th</sup></code> station. You begin the journey with an empty tank at one of the gas stations.</p>
+
+<p>Given two integer arrays <code>gas</code> and <code>cost</code>, return <em>the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return</em> <code>-1</code>. If there exists a solution, it is <strong>guaranteed</strong> to be <strong>unique</strong></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> gas = [1,2,3,4,5], cost = [3,4,5,1,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+Start at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
+Travel to station 4. Your tank = 4 - 1 + 5 = 8
+Travel to station 0. Your tank = 8 - 2 + 1 = 7
+Travel to station 1. Your tank = 7 - 3 + 2 = 6
+Travel to station 2. Your tank = 6 - 4 + 3 = 5
+Travel to station 3. The cost is 5. Your gas is just enough to travel back to station 3.
+Therefore, return 3 as the starting index.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> gas = [2,3,4], cost = [3,4,3]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong>
+You can't start at station 0 or 1, as there is not enough gas to travel to the next station.
+Let's start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
+Travel to station 0. Your tank = 4 - 3 + 2 = 3
+Travel to station 1. Your tank = 3 - 3 + 3 = 3
+You cannot travel back to station 2, as it requires 4 unit of gas but you only have 3.
+Therefore, you can't travel around the circuit once no matter where you start.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == gas.length == cost.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= gas[i], cost[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0138-copy-list-with-random-pointer/0138-copy-list-with-random-pointer.java b/leetcode/leetcode/0138-copy-list-with-random-pointer/0138-copy-list-with-random-pointer.java
new file mode 100644
index 0000000..6b26a56
--- /dev/null
+++ b/leetcode/leetcode/0138-copy-list-with-random-pointer/0138-copy-list-with-random-pointer.java
@@ -0,0 +1,40 @@
+/*
+// Definition for a Node.
+class Node {
+    int val;
+    Node next;
+    Node random;
+
+    public Node(int val) {
+        this.val = val;
+        this.next = null;
+        this.random = null;
+    }
+}
+*/
+
+class Solution {
+    public Node copyRandomList(Node head) {
+        // Approach 1: HashMap
+
+        HashMap<Node,Node> map = new HashMap<>();
+        Node temp = head;  
+        Node res = new Node(0);
+        Node temp2 = res;
+        while(temp!=null){
+           res.next = new Node(temp.val);
+           res = res.next;
+           map.put(temp,res);
+           temp = temp.next;
+        }
+        temp = head;
+        res = temp2.next;
+        while(temp!=null){
+            res.random = map.get(temp.random);
+            temp = temp.next;
+            res = res.next;
+        }
+        return temp2.next;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0138-copy-list-with-random-pointer/NOTES.md b/leetcode/leetcode/0138-copy-list-with-random-pointer/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0138-copy-list-with-random-pointer/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0138-copy-list-with-random-pointer/README.md b/leetcode/leetcode/0138-copy-list-with-random-pointer/README.md
new file mode 100644
index 0000000..e428e5a
--- /dev/null
+++ b/leetcode/leetcode/0138-copy-list-with-random-pointer/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/copy-list-with-random-pointer">138. Copy List with Random Pointer</a></h2><h3>Medium</h3><hr><p>A linked list of length <code>n</code> is given such that each node contains an additional random pointer, which could point to any node in the list, or <code>null</code>.</p>
+
+<p>Construct a <a href="https://en.wikipedia.org/wiki/Object_copying#Deep_copy" target="_blank"><strong>deep copy</strong></a> of the list. The deep copy should consist of exactly <code>n</code> <strong>brand new</strong> nodes, where each new node has its value set to the value of its corresponding original node. Both the <code>next</code> and <code>random</code> pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. <strong>None of the pointers in the new list should point to nodes in the original list</strong>.</p>
+
+<p>For example, if there are two nodes <code>X</code> and <code>Y</code> in the original list, where <code>X.random --&gt; Y</code>, then for the corresponding two nodes <code>x</code> and <code>y</code> in the copied list, <code>x.random --&gt; y</code>.</p>
+
+<p>Return <em>the head of the copied linked list</em>.</p>
+
+<p>The linked list is represented in the input/output as a list of <code>n</code> nodes. Each node is represented as a pair of <code>[val, random_index]</code> where:</p>
+
+<ul>
+	<li><code>val</code>: an integer representing <code>Node.val</code></li>
+	<li><code>random_index</code>: the index of the node (range from <code>0</code> to <code>n-1</code>) that the <code>random</code> pointer points to, or <code>null</code> if it does not point to any node.</li>
+</ul>
+
+<p>Your code will <strong>only</strong> be given the <code>head</code> of the original linked list.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/e1.png" style="width: 700px; height: 142px;" />
+<pre>
+<strong>Input:</strong> head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
+<strong>Output:</strong> [[7,null],[13,0],[11,4],[10,2],[1,0]]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/e2.png" style="width: 700px; height: 114px;" />
+<pre>
+<strong>Input:</strong> head = [[1,1],[2,1]]
+<strong>Output:</strong> [[1,1],[2,1]]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/e3.png" style="width: 700px; height: 122px;" /></strong></p>
+
+<pre>
+<strong>Input:</strong> head = [[3,null],[3,0],[3,null]]
+<strong>Output:</strong> [[3,null],[3,0],[3,null]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 1000</code></li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li><code>Node.random</code> is <code>null</code> or is pointing to some node in the linked list.</li>
+</ul>
diff --git a/leetcode/leetcode/0141-linked-list-cycle/0141-linked-list-cycle.java b/leetcode/leetcode/0141-linked-list-cycle/0141-linked-list-cycle.java
new file mode 100644
index 0000000..44833e5
--- /dev/null
+++ b/leetcode/leetcode/0141-linked-list-cycle/0141-linked-list-cycle.java
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        if(head == null || head.next == null) return false;
+
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast!=null && fast.next!=null){
+            slow = slow.next;
+            fast = fast.next.next;
+            if(slow == fast){ return true;}
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0141-linked-list-cycle/NOTES.md b/leetcode/leetcode/0141-linked-list-cycle/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0141-linked-list-cycle/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0141-linked-list-cycle/README.md b/leetcode/leetcode/0141-linked-list-cycle/README.md
new file mode 100644
index 0000000..c5ab825
--- /dev/null
+++ b/leetcode/leetcode/0141-linked-list-cycle/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/linked-list-cycle">141. Linked List Cycle</a></h2><h3>Easy</h3><hr><p>Given <code>head</code>, the head of a linked list, determine if the linked list has a cycle in it.</p>
+
+<p>There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the&nbsp;<code>next</code>&nbsp;pointer. Internally, <code>pos</code>&nbsp;is used to denote the index of the node that&nbsp;tail&#39;s&nbsp;<code>next</code>&nbsp;pointer is connected to.&nbsp;<strong>Note that&nbsp;<code>pos</code>&nbsp;is not passed as a parameter</strong>.</p>
+
+<p>Return&nbsp;<code>true</code><em> if there is a cycle in the linked list</em>. Otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png" style="width: 300px; height: 97px; margin-top: 8px; margin-bottom: 8px;" />
+<pre>
+<strong>Input:</strong> head = [3,2,0,-4], pos = 1
+<strong>Output:</strong> true
+<strong>Explanation:</strong> There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png" style="width: 141px; height: 74px;" />
+<pre>
+<strong>Input:</strong> head = [1,2], pos = 0
+<strong>Output:</strong> true
+<strong>Explanation:</strong> There is a cycle in the linked list, where the tail connects to the 0th node.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png" style="width: 45px; height: 45px;" />
+<pre>
+<strong>Input:</strong> head = [1], pos = -1
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There is no cycle in the linked list.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li><code>pos</code> is <code>-1</code> or a <strong>valid index</strong> in the linked-list.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Can you solve it using <code>O(1)</code> (i.e. constant) memory?</p>
diff --git a/leetcode/leetcode/0142-linked-list-cycle-ii/0142-linked-list-cycle-ii.java b/leetcode/leetcode/0142-linked-list-cycle-ii/0142-linked-list-cycle-ii.java
new file mode 100644
index 0000000..fd8e9fc
--- /dev/null
+++ b/leetcode/leetcode/0142-linked-list-cycle-ii/0142-linked-list-cycle-ii.java
@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode detectCycle(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast!=null && fast.next!=null){
+            slow = slow.next;
+            fast = fast.next.next;
+            if(slow==fast){
+                slow = head;
+                while(slow!=fast){
+                    slow = slow.next;
+                    fast = fast.next;
+                }
+                return slow;
+            }
+        }
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0142-linked-list-cycle-ii/README.md b/leetcode/leetcode/0142-linked-list-cycle-ii/README.md
new file mode 100644
index 0000000..5542812
--- /dev/null
+++ b/leetcode/leetcode/0142-linked-list-cycle-ii/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/linked-list-cycle-ii">142. Linked List Cycle II</a></h2><h3>Medium</h3><hr><p>Given the <code>head</code> of a linked list, return <em>the node where the cycle begins. If there is no cycle, return </em><code>null</code>.</p>
+
+<p>There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the <code>next</code> pointer. Internally, <code>pos</code> is used to denote the index of the node that tail&#39;s <code>next</code> pointer is connected to (<strong>0-indexed</strong>). It is <code>-1</code> if there is no cycle. <strong>Note that</strong> <code>pos</code> <strong>is not passed as a parameter</strong>.</p>
+
+<p><strong>Do not modify</strong> the linked list.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png" style="height: 145px; width: 450px;" />
+<pre>
+<strong>Input:</strong> head = [3,2,0,-4], pos = 1
+<strong>Output:</strong> tail connects to node index 1
+<strong>Explanation:</strong> There is a cycle in the linked list, where tail connects to the second node.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png" style="height: 105px; width: 201px;" />
+<pre>
+<strong>Input:</strong> head = [1,2], pos = 0
+<strong>Output:</strong> tail connects to node index 0
+<strong>Explanation:</strong> There is a cycle in the linked list, where tail connects to the first node.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png" style="height: 65px; width: 65px;" />
+<pre>
+<strong>Input:</strong> head = [1], pos = -1
+<strong>Output:</strong> no cycle
+<strong>Explanation:</strong> There is no cycle in the linked list.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li><code>pos</code> is <code>-1</code> or a <strong>valid index</strong> in the linked-list.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Can you solve it using <code>O(1)</code> (i.e. constant) memory?</p>
diff --git a/leetcode/leetcode/0143-reorder-list/0143-reorder-list.java b/leetcode/leetcode/0143-reorder-list/0143-reorder-list.java
new file mode 100644
index 0000000..f366c3b
--- /dev/null
+++ b/leetcode/leetcode/0143-reorder-list/0143-reorder-list.java
@@ -0,0 +1,54 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode reverse(ListNode head){
+        ListNode prev = null;
+        ListNode curr = head;
+        ListNode next = head.next;
+        while(next!=null){
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+            next = next.next;
+        }
+        curr.next = prev;
+        return curr;
+    }
+    public void reorderList(ListNode head) {
+        if(head == null || head.next == null ) return;
+        // use turtle rabbit method, slow-fast pointer to find middle of the linkedlist 
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while(fast!=null && fast.next!=null){
+            slow = slow.next; // move once
+            fast = fast.next.next; // move twice faster 
+        }
+        // Divide the linkedList into two parts;
+        ListNode secondHalf = slow.next;
+        // Set first half next to null to deattach the flist 
+        slow.next = null;
+        // reverse the second half
+        secondHalf = reverse(secondHalf);
+        ListNode firstHalf  = head;
+        ListNode temp = secondHalf;
+        // combinig both list
+        while(secondHalf!=null){
+            temp = temp.next;
+            secondHalf.next = firstHalf.next;
+            firstHalf.next  = secondHalf;
+            firstHalf = secondHalf.next;
+            secondHalf = temp;
+        }
+        return;
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0143-reorder-list/README.md b/leetcode/leetcode/0143-reorder-list/README.md
new file mode 100644
index 0000000..de26a46
--- /dev/null
+++ b/leetcode/leetcode/0143-reorder-list/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/reorder-list">143. Reorder List</a></h2><h3>Medium</h3><hr><p>You are given the head of a singly linked-list. The list can be represented as:</p>
+
+<pre>
+L<sub>0</sub> &rarr; L<sub>1</sub> &rarr; &hellip; &rarr; L<sub>n - 1</sub> &rarr; L<sub>n</sub>
+</pre>
+
+<p><em>Reorder the list to be on the following form:</em></p>
+
+<pre>
+L<sub>0</sub> &rarr; L<sub>n</sub> &rarr; L<sub>1</sub> &rarr; L<sub>n - 1</sub> &rarr; L<sub>2</sub> &rarr; L<sub>n - 2</sub> &rarr; &hellip;
+</pre>
+
+<p>You may not modify the values in the list&#39;s nodes. Only nodes themselves may be changed.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/04/reorder1linked-list.jpg" style="width: 422px; height: 222px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4]
+<strong>Output:</strong> [1,4,2,3]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/reorder2-linked-list.jpg" style="width: 542px; height: 222px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5]
+<strong>Output:</strong> [1,5,2,4,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 5 * 10<sup>4</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.java b/leetcode/leetcode/0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.java
new file mode 100644
index 0000000..eba91d1
--- /dev/null
+++ b/leetcode/leetcode/0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.java
@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    List<Integer> result = new ArrayList<>();
+
+    public void preOrder(TreeNode root){
+        if(root == null) return;
+
+        result.add(root.val);
+
+        preOrder(root.left);
+        preOrder(root.right);
+        
+
+    }
+
+
+
+    public List<Integer> preorderTraversal(TreeNode root) {
+        preOrder(root);
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.py b/leetcode/leetcode/0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.py
new file mode 100644
index 0000000..2a28860
--- /dev/null
+++ b/leetcode/leetcode/0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.py
@@ -0,0 +1,13 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
+        if(root == None):
+            return []
+        left = self.preorderTraversal(root.left)
+        right = self.preorderTraversal(root.right)
+        return [root.val] + left + right
diff --git a/leetcode/leetcode/0144-binary-tree-preorder-traversal/README.md b/leetcode/leetcode/0144-binary-tree-preorder-traversal/README.md
new file mode 100644
index 0000000..2a9e1c4
--- /dev/null
+++ b/leetcode/leetcode/0144-binary-tree-preorder-traversal/README.md
@@ -0,0 +1,53 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-preorder-traversal">144. Binary Tree Preorder Traversal</a></h2><h3>Easy</h3><hr><p>Given the <code>root</code> of a binary tree, return <em>the preorder traversal of its nodes&#39; values</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1,null,2,3]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1,2,3]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png" style="width: 200px; height: 264px;" /></p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1,2,3,4,5,null,8,null,null,6,7,9]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1,2,4,5,6,7,3,8,9]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/tree_2.png" style="width: 350px; height: 286px;" /></p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = []</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[]</span></p>
+</div>
+
+<p><strong class="example">Example 4:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1]</span></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</p>
diff --git a/leetcode/leetcode/0145-binary-tree-postorder-traversal/0145-binary-tree-postorder-traversal.java b/leetcode/leetcode/0145-binary-tree-postorder-traversal/0145-binary-tree-postorder-traversal.java
new file mode 100644
index 0000000..71bf2b6
--- /dev/null
+++ b/leetcode/leetcode/0145-binary-tree-postorder-traversal/0145-binary-tree-postorder-traversal.java
@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> postorderTraversal(TreeNode root) {
+        if(root == null) return new ArrayList<Integer>();
+        List<Integer> list = new ArrayList<>();
+        list.addAll(postorderTraversal(root.left));
+        list.addAll(postorderTraversal(root.right));
+        list.add(root.val);
+        return list;
+
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0145-binary-tree-postorder-traversal/NOTES.md b/leetcode/leetcode/0145-binary-tree-postorder-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0145-binary-tree-postorder-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0145-binary-tree-postorder-traversal/README.md b/leetcode/leetcode/0145-binary-tree-postorder-traversal/README.md
new file mode 100644
index 0000000..ac6ce4d
--- /dev/null
+++ b/leetcode/leetcode/0145-binary-tree-postorder-traversal/README.md
@@ -0,0 +1,53 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-postorder-traversal">145. Binary Tree Postorder Traversal</a></h2><h3>Easy</h3><hr><p>Given the <code>root</code> of a&nbsp;binary tree, return <em>the postorder traversal of its nodes&#39; values</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1,null,2,3]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[3,2,1]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png" style="width: 200px; height: 264px;" /></p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1,2,3,4,5,null,8,null,null,6,7,9]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[4,6,7,5,2,9,8,3,1]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/29/tree_2.png" style="width: 350px; height: 286px;" /></p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = []</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[]</span></p>
+</div>
+
+<p><strong class="example">Example 4:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1]</span></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of the nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?
\ No newline at end of file
diff --git a/leetcode/leetcode/0146-lru-cache/0146-lru-cache.java b/leetcode/leetcode/0146-lru-cache/0146-lru-cache.java
new file mode 100644
index 0000000..2884050
--- /dev/null
+++ b/leetcode/leetcode/0146-lru-cache/0146-lru-cache.java
@@ -0,0 +1,100 @@
+class LRUCache {
+    
+    class Node{
+        Node next;
+        Node prev;
+        int val;
+        int key;
+        Node(int key,int data){
+            this.key = key;
+            this.val = data;
+            next = null;
+            prev = null;
+        }
+    }
+    HashMap<Integer,Node> map;
+    Node head;
+    Node tail;
+    int size;
+    int currentSize;
+    /* add after head */
+    private void add(Node node){
+        Node prev = head;
+        Node next = head.next;
+
+        node.next = next;
+        node.prev = prev;
+
+        prev.next = node;
+        next.prev = node;
+    }
+    /* remove before tail */
+    private void remove(){
+        Node node = tail.prev;
+        Node prev = node.prev;
+
+        tail.prev = prev;
+        prev.next = tail;
+        
+    }
+    private void remove(Node node){
+        Node next = node.next;
+        Node prev = node.prev;
+
+        node.next = null;
+        node.prev = null;
+
+        prev.next = next;
+        next.prev = prev;
+
+    }
+    
+
+
+    public LRUCache(int capacity) {
+        map = new HashMap<>();
+        head = new Node(-11,-11);
+        tail = new Node(-11,-11);
+        head.next = tail;
+        tail.prev = head;
+        size = capacity;
+        currentSize = 0;
+    }
+    
+    public int get(int key) {
+        if(!map.containsKey(key)) return -1;
+        Node node = map.get(key);
+        int val = node.val;
+        remove(node);
+        map.remove(key);
+        currentSize--;
+        put(key,val);
+        return val;
+    }
+    
+    public void put(int key, int value) {
+        if(map.containsKey(key)){
+            Node node = map.get(key);
+            map.remove(key);
+            remove(node);
+            currentSize--;
+        }
+        if(currentSize==size){
+            currentSize--;
+            int key2 = tail.prev.key;
+            remove();
+            map.remove(key2);
+        }
+        Node node = new Node(key,value);
+        map.put(key,node);
+        currentSize++;
+        add(node);
+    }
+}
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * LRUCache obj = new LRUCache(capacity);
+ * int param_1 = obj.get(key);
+ * obj.put(key,value);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/0146-lru-cache/README.md b/leetcode/leetcode/0146-lru-cache/README.md
new file mode 100644
index 0000000..ae892bc
--- /dev/null
+++ b/leetcode/leetcode/0146-lru-cache/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/lru-cache/">146. LRU Cache</a></h2><h3>Medium</h3><hr><div><p>Design a data structure that follows the constraints of a <strong><a href="https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU" target="_blank">Least Recently Used (LRU) cache</a></strong>.</p>
+
+<p>Implement the <code>LRUCache</code> class:</p>
+
+<ul>
+	<li><code>LRUCache(int capacity)</code> Initialize the LRU cache with <strong>positive</strong> size <code>capacity</code>.</li>
+	<li><code>int get(int key)</code> Return the value of the <code>key</code> if the key exists, otherwise return <code>-1</code>.</li>
+	<li><code>void put(int key, int value)</code> Update the value of the <code>key</code> if the <code>key</code> exists. Otherwise, add the <code>key-value</code> pair to the cache. If the number of keys exceeds the <code>capacity</code> from this operation, <strong>evict</strong> the least recently used key.</li>
+</ul>
+
+<p>The functions <code>get</code> and <code>put</code> must each run in <code>O(1)</code> average time complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
+[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+<strong>Output</strong>
+[null, null, null, 1, null, -1, null, -1, 3, 4]
+
+<strong>Explanation</strong>
+LRUCache lRUCache = new LRUCache(2);
+lRUCache.put(1, 1); // cache is {1=1}
+lRUCache.put(2, 2); // cache is {1=1, 2=2}
+lRUCache.get(1);    // return 1
+lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3}
+lRUCache.get(2);    // returns -1 (not found)
+lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
+lRUCache.get(1);    // return -1 (not found)
+lRUCache.get(3);    // return 3
+lRUCache.get(4);    // return 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= capacity &lt;= 3000</code></li>
+	<li><code>0 &lt;= key &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= value &lt;= 10<sup>5</sup></code></li>
+	<li>At most <code>2 * 10<sup>5</sup></code> calls will be made to <code>get</code> and <code>put</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0149-max-points-on-a-line/0149-max-points-on-a-line.java b/leetcode/leetcode/0149-max-points-on-a-line/0149-max-points-on-a-line.java
new file mode 100644
index 0000000..96b1d89
--- /dev/null
+++ b/leetcode/leetcode/0149-max-points-on-a-line/0149-max-points-on-a-line.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int maxPoints(int[][] points) {
+        int ans = 0;
+        for(int i = 0;i<points.length;i++){
+            HashMap<Double,Integer> map = new HashMap<>();
+            for(int j = 0;j<points.length;j++){
+                if(i == j) continue;
+
+                int dy = points[j][1] - points[i][1];
+                int dx = points[j][0] - points[i][0];
+                double slope = 0.0;
+                if(dx == 0){
+                    slope = Double.MAX_VALUE;
+                }else{
+                    slope = (dy*1.0)/dx;
+                }
+                map.put(slope,map.getOrDefault(slope,0)+1);
+                ans = Math.max(ans,map.get(slope));
+            }
+        }
+        return ans+1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0149-max-points-on-a-line/NOTES.md b/leetcode/leetcode/0149-max-points-on-a-line/NOTES.md
new file mode 100644
index 0000000..2c4756f
--- /dev/null
+++ b/leetcode/leetcode/0149-max-points-on-a-line/NOTES.md
@@ -0,0 +1 @@
+Slope of a line.
\ No newline at end of file
diff --git a/leetcode/leetcode/0149-max-points-on-a-line/README.md b/leetcode/leetcode/0149-max-points-on-a-line/README.md
new file mode 100644
index 0000000..336c348
--- /dev/null
+++ b/leetcode/leetcode/0149-max-points-on-a-line/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/max-points-on-a-line">149. Max Points on a Line</a></h2><h3>Hard</h3><hr><p>Given an array of <code>points</code> where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the <strong>X-Y</strong> plane, return <em>the maximum number of points that lie on the same straight line</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/25/plane1.jpg" style="width: 300px; height: 294px;" />
+<pre>
+<strong>Input:</strong> points = [[1,1],[2,2],[3,3]]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/25/plane2.jpg" style="width: 300px; height: 294px;" />
+<pre>
+<strong>Input:</strong> points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
+<strong>Output:</strong> 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= points.length &lt;= 300</code></li>
+	<li><code>points[i].length == 2</code></li>
+	<li><code>-10<sup>4</sup> &lt;= x<sub>i</sub>, y<sub>i</sub> &lt;= 10<sup>4</sup></code></li>
+	<li>All the <code>points</code> are <strong>unique</strong>.</li>
+</ul>
diff --git a/leetcode/leetcode/0150-evaluate-reverse-polish-notation/0150-evaluate-reverse-polish-notation.java b/leetcode/leetcode/0150-evaluate-reverse-polish-notation/0150-evaluate-reverse-polish-notation.java
new file mode 100644
index 0000000..e565186
--- /dev/null
+++ b/leetcode/leetcode/0150-evaluate-reverse-polish-notation/0150-evaluate-reverse-polish-notation.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int evalRPN(String[] tokens) {
+        Stack<Integer> s = new Stack<>();
+        int ans = 0;
+        for(int i = 0;i<tokens.length;i++){
+            int first,second;
+            if(tokens[i].equals("+")){
+                first = s.pop();
+                second = s.pop();
+                s.push(first+second);
+            }else if(tokens[i].equals("-")){
+                first = s.pop();
+                second = s.pop();
+                s.push(second-first);
+            }else if(tokens[i].equals("*")){
+                first = s.pop();
+                second = s.pop();
+                s.push(second*first);
+            }else if(tokens[i].equals("/")){
+                first = s.pop();
+                second = s.pop();
+                s.push(second/first);
+            }else{
+                s.push(Integer.parseInt(tokens[i]));
+            }
+        }
+        return s.pop();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0150-evaluate-reverse-polish-notation/NOTES.md b/leetcode/leetcode/0150-evaluate-reverse-polish-notation/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0150-evaluate-reverse-polish-notation/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0150-evaluate-reverse-polish-notation/README.md b/leetcode/leetcode/0150-evaluate-reverse-polish-notation/README.md
new file mode 100644
index 0000000..4a26fcc
--- /dev/null
+++ b/leetcode/leetcode/0150-evaluate-reverse-polish-notation/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/evaluate-reverse-polish-notation/">150. Evaluate Reverse Polish Notation</a></h2><h3>Medium</h3><hr><div><p>You are given an array of strings <code>tokens</code> that represents an arithmetic expression in a <a href="http://en.wikipedia.org/wiki/Reverse_Polish_notation" target="_blank">Reverse Polish Notation</a>.</p>
+
+<p>Evaluate the expression. Return <em>an integer that represents the value of the expression</em>.</p>
+
+<p><strong>Note</strong> that:</p>
+
+<ul>
+	<li>The valid operators are <code>'+'</code>, <code>'-'</code>, <code>'*'</code>, and <code>'/'</code>.</li>
+	<li>Each operand may be an integer or another expression.</li>
+	<li>The division between two integers always <strong>truncates toward zero</strong>.</li>
+	<li>There will not be any division by zero.</li>
+	<li>The input represents a valid arithmetic expression in a reverse polish notation.</li>
+	<li>The answer and all the intermediate calculations can be represented in a <strong>32-bit</strong> integer.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> tokens = ["2","1","+","3","*"]
+<strong>Output:</strong> 9
+<strong>Explanation:</strong> ((2 + 1) * 3) = 9
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> tokens = ["4","13","5","/","+"]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> (4 + (13 / 5)) = 6
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
+<strong>Output:</strong> 22
+<strong>Explanation:</strong> ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
+= ((10 * (6 / (12 * -11))) + 17) + 5
+= ((10 * (6 / -132)) + 17) + 5
+= ((10 * 0) + 17) + 5
+= (0 + 17) + 5
+= 17 + 5
+= 22
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= tokens.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>tokens[i]</code> is either an operator: <code>"+"</code>, <code>"-"</code>, <code>"*"</code>, or <code>"/"</code>, or an integer in the range <code>[-200, 200]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0151-reverse-words-in-a-string/0151-reverse-words-in-a-string.java b/leetcode/leetcode/0151-reverse-words-in-a-string/0151-reverse-words-in-a-string.java
new file mode 100644
index 0000000..dbb6631
--- /dev/null
+++ b/leetcode/leetcode/0151-reverse-words-in-a-string/0151-reverse-words-in-a-string.java
@@ -0,0 +1,22 @@
+class Solution {
+    public String reverseWords(String s) {
+        int i = s.length() -1;
+        StringBuilder res = new StringBuilder();
+        while(i>=0){
+            while(i>=0 && s.charAt(i)==' ') i--;
+            int j = i;
+            if(i<0) break;
+            while(i>=0 && s.charAt(i)!=' ') i--;
+            if(res.length() == 0){
+                res.append(s.substring(i+1,j+1));
+            }
+            else{
+                res.append(" ");
+                res.append(s.substring(i+1,j+1));
+            }
+        }
+        
+        return res.toString();
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0151-reverse-words-in-a-string/NOTES.md b/leetcode/leetcode/0151-reverse-words-in-a-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0151-reverse-words-in-a-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0151-reverse-words-in-a-string/README.md b/leetcode/leetcode/0151-reverse-words-in-a-string/README.md
new file mode 100644
index 0000000..87b8c94
--- /dev/null
+++ b/leetcode/leetcode/0151-reverse-words-in-a-string/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/reverse-words-in-a-string/">151. Reverse Words in a String</a></h2><h3>Medium</h3><hr><div><p>Given an input string <code>s</code>, reverse the order of the <strong>words</strong>.</p>
+
+<p>A <strong>word</strong> is defined as a sequence of non-space characters. The <strong>words</strong> in <code>s</code> will be separated by at least one space.</p>
+
+<p>Return <em>a string of the words in reverse order concatenated by a single space.</em></p>
+
+<p><b>Note</b> that <code>s</code> may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "the sky is blue"
+<strong>Output:</strong> "blue is sky the"
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "  hello world  "
+<strong>Output:</strong> "world hello"
+<strong>Explanation:</strong> Your reversed string should not contain leading or trailing spaces.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "a good   example"
+<strong>Output:</strong> "example good a"
+<strong>Explanation:</strong> You need to reduce multiple spaces between two words to a single space in the reversed string.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> contains English letters (upper-case and lower-case), digits, and spaces <code>' '</code>.</li>
+	<li>There is <strong>at least one</strong> word in <code>s</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><b data-stringify-type="bold">Follow-up:&nbsp;</b>If the string data type is mutable in your language, can&nbsp;you solve it&nbsp;<b data-stringify-type="bold">in-place</b>&nbsp;with&nbsp;<code data-stringify-type="code">O(1)</code>&nbsp;extra space?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0152-maximum-product-subarray/0152-maximum-product-subarray.java b/leetcode/leetcode/0152-maximum-product-subarray/0152-maximum-product-subarray.java
new file mode 100644
index 0000000..5d0d38d
--- /dev/null
+++ b/leetcode/leetcode/0152-maximum-product-subarray/0152-maximum-product-subarray.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int maxProduct(int[] nums) {
+        int ans = Integer.MIN_VALUE;
+        int prefix = 1;
+        int suffix  = 1;
+        for(int i = 0;i<nums.length;i++){
+            prefix = prefix*nums[i];
+            suffix = suffix*nums[nums.length - i -1];
+
+            ans = Math.max(ans,Math.max(prefix,suffix));
+            if(prefix == 0) prefix = 1;
+            if(suffix == 0) suffix = 1;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0152-maximum-product-subarray/README.md b/leetcode/leetcode/0152-maximum-product-subarray/README.md
new file mode 100644
index 0000000..40a8574
--- /dev/null
+++ b/leetcode/leetcode/0152-maximum-product-subarray/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/maximum-product-subarray">152. Maximum Product Subarray</a></h2><h3>Medium</h3><hr><p>Given an integer array <code>nums</code>, find a <span data-keyword="subarray-nonempty">subarray</span> that has the largest product, and return <em>the product</em>.</p>
+
+<p>The test cases are generated so that the answer will fit in a <strong>32-bit</strong> integer.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,3,-2,4]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> [2,3] has the largest product 6.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [-2,0,-1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The result cannot be 2, because [-2,-1] is not a subarray.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>-10 &lt;= nums[i] &lt;= 10</code></li>
+	<li>The product of any subarray of <code>nums</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</li>
+</ul>
diff --git a/leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/0153-find-minimum-in-rotated-sorted-array.java b/leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/0153-find-minimum-in-rotated-sorted-array.java
new file mode 100644
index 0000000..0566f12
--- /dev/null
+++ b/leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/0153-find-minimum-in-rotated-sorted-array.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int findMin(int[] nums) {
+        int low = 0;
+        int high = nums.length - 1;
+
+        while(low<high){
+            int mid = low + (high-low)/2;
+
+            if(nums[mid]>nums[high]){
+                low = mid+1;
+            }else {
+                high = mid;
+            }
+        }
+        return nums[low];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/0153-find-minimum-in-rotated-sorted-array.py b/leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/0153-find-minimum-in-rotated-sorted-array.py
new file mode 100644
index 0000000..1ef4ae6
--- /dev/null
+++ b/leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/0153-find-minimum-in-rotated-sorted-array.py
@@ -0,0 +1,13 @@
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        left = 0
+        right = len(nums) - 1
+        while(left<right):
+            mid = (left+right) // 2
+            if( nums[mid]<=nums[right]):
+                right = mid
+            else:
+                left = mid+1
+        return nums[left]
+
+        
\ No newline at end of file
diff --git a/leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/README.md b/leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/README.md
new file mode 100644
index 0000000..600ad5a
--- /dev/null
+++ b/leetcode/leetcode/0153-find-minimum-in-rotated-sorted-array/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/find-minimum-in-rotated-sorted-array">153. Find Minimum in Rotated Sorted Array</a></h2><h3>Medium</h3><hr><p>Suppose an array of length <code>n</code> sorted in ascending order is <strong>rotated</strong> between <code>1</code> and <code>n</code> times. For example, the array <code>nums = [0,1,2,4,5,6,7]</code> might become:</p>
+
+<ul>
+	<li><code>[4,5,6,7,0,1,2]</code> if it was rotated <code>4</code> times.</li>
+	<li><code>[0,1,2,4,5,6,7]</code> if it was rotated <code>7</code> times.</li>
+</ul>
+
+<p>Notice that <strong>rotating</strong> an array <code>[a[0], a[1], a[2], ..., a[n-1]]</code> 1 time results in the array <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code>.</p>
+
+<p>Given the sorted rotated array <code>nums</code> of <strong>unique</strong> elements, return <em>the minimum element of this array</em>.</p>
+
+<p>You must write an algorithm that runs in&nbsp;<code>O(log n) time</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,4,5,1,2]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The original array was [1,2,3,4,5] rotated 3 times.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [4,5,6,7,0,1,2]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [11,13,15,17]
+<strong>Output:</strong> 11
+<strong>Explanation:</strong> The original array was [11,13,15,17] and it was rotated 4 times. 
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 5000</code></li>
+	<li><code>-5000 &lt;= nums[i] &lt;= 5000</code></li>
+	<li>All the integers of <code>nums</code> are <strong>unique</strong>.</li>
+	<li><code>nums</code> is sorted and rotated between <code>1</code> and <code>n</code> times.</li>
+</ul>
diff --git a/leetcode/leetcode/0155-min-stack/0155-min-stack.java b/leetcode/leetcode/0155-min-stack/0155-min-stack.java
new file mode 100644
index 0000000..ebf3a86
--- /dev/null
+++ b/leetcode/leetcode/0155-min-stack/0155-min-stack.java
@@ -0,0 +1,51 @@
+class MinStack {
+
+    class Pair{
+        int value;
+        int min;
+
+        Pair(int v, int m){
+            this.value = v;
+            this.min   = m;
+        }
+    }
+
+    Stack<Pair> s;
+
+    // first val -  value
+    // second value  -  min
+    public MinStack() {
+        s = new Stack<>();
+    }
+    
+    public void push(int val) {
+        if(s.isEmpty()){
+            s.push(new Pair(val,val));
+        }else{
+            Pair p = new Pair(val, Math.min(s.peek().min,val));
+            s.push(p);
+        }
+        
+    }
+    
+    public void pop() {
+        s.pop();
+    }
+    
+    public int top() {
+        return s.peek().value;
+    }
+    
+    public int getMin() {
+        return s.peek().min;
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack obj = new MinStack();
+ * obj.push(val);
+ * obj.pop();
+ * int param_3 = obj.top();
+ * int param_4 = obj.getMin();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/0155-min-stack/NOTES.md b/leetcode/leetcode/0155-min-stack/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0155-min-stack/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0155-min-stack/README.md b/leetcode/leetcode/0155-min-stack/README.md
new file mode 100644
index 0000000..3902f5d
--- /dev/null
+++ b/leetcode/leetcode/0155-min-stack/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/min-stack">155. Min Stack</a></h2><h3>Medium</h3><hr><p>Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.</p>
+
+<p>Implement the <code>MinStack</code> class:</p>
+
+<ul>
+	<li><code>MinStack()</code> initializes the stack object.</li>
+	<li><code>void push(int val)</code> pushes the element <code>val</code> onto the stack.</li>
+	<li><code>void pop()</code> removes the element on the top of the stack.</li>
+	<li><code>int top()</code> gets the top element of the stack.</li>
+	<li><code>int getMin()</code> retrieves the minimum element in the stack.</li>
+</ul>
+
+<p>You must implement a solution with <code>O(1)</code> time complexity for each function.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input</strong>
+[&quot;MinStack&quot;,&quot;push&quot;,&quot;push&quot;,&quot;push&quot;,&quot;getMin&quot;,&quot;pop&quot;,&quot;top&quot;,&quot;getMin&quot;]
+[[],[-2],[0],[-3],[],[],[],[]]
+
+<strong>Output</strong>
+[null,null,null,null,-3,null,0,-2]
+
+<strong>Explanation</strong>
+MinStack minStack = new MinStack();
+minStack.push(-2);
+minStack.push(0);
+minStack.push(-3);
+minStack.getMin(); // return -3
+minStack.pop();
+minStack.top();    // return 0
+minStack.getMin(); // return -2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= val &lt;= 2<sup>31</sup> - 1</code></li>
+	<li>Methods <code>pop</code>, <code>top</code> and <code>getMin</code> operations will always be called on <strong>non-empty</strong> stacks.</li>
+	<li>At most <code>3 * 10<sup>4</sup></code> calls will be made to <code>push</code>, <code>pop</code>, <code>top</code>, and <code>getMin</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0160-intersection-of-two-linked-lists/0160-intersection-of-two-linked-lists.java b/leetcode/leetcode/0160-intersection-of-two-linked-lists/0160-intersection-of-two-linked-lists.java
new file mode 100644
index 0000000..fa89ad9
--- /dev/null
+++ b/leetcode/leetcode/0160-intersection-of-two-linked-lists/0160-intersection-of-two-linked-lists.java
@@ -0,0 +1,59 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public int getSize(ListNode head){
+        int size = 0;
+        ListNode temp = head;
+        while(temp!=null){
+            size++;
+            temp = temp.next;
+        }
+        return size;
+    }
+
+    public ListNode getNthNode(ListNode head, int index){
+        ListNode temp = head;
+        while(index!=0){
+            temp = temp.next;
+            index--;
+        }
+        return temp;
+    }
+    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+        // int size1 = getSize(headA);
+        // int size2 = getSize(headB);
+
+        // int diff = Math.abs(size1 - size2);
+
+        // if(size1>size2){
+        //     headA = getNthNode(headA, diff);
+        // }else{
+        //     headB = getNthNode(headB, diff);
+        // }
+
+        // while(headA!=null && headB != null && headA!=headB){
+        //     headA = headA.next;
+        //     headB = headB.next;
+        // }
+
+        // return headA;
+
+
+        ListNode temp1 = headA;
+        ListNode temp2 = headB;
+        while(temp1!=temp2){
+            temp1 = temp1==null  ? headA : temp1.next;
+            temp2 = temp2 == null? headB : temp2.next;
+        }
+        return temp1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0160-intersection-of-two-linked-lists/README.md b/leetcode/leetcode/0160-intersection-of-two-linked-lists/README.md
new file mode 100644
index 0000000..2ea40f7
--- /dev/null
+++ b/leetcode/leetcode/0160-intersection-of-two-linked-lists/README.md
@@ -0,0 +1,67 @@
+<h2><a href="https://leetcode.com/problems/intersection-of-two-linked-lists">160. Intersection of Two Linked Lists</a></h2><h3>Easy</h3><hr><p>Given the heads of two singly linked-lists <code>headA</code> and <code>headB</code>, return <em>the node at which the two lists intersect</em>. If the two linked lists have no intersection at all, return <code>null</code>.</p>
+
+<p>For example, the following two linked lists begin to intersect at node <code>c1</code>:</p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/05/160_statement.png" style="width: 500px; height: 162px;" />
+<p>The test cases are generated such that there are no cycles anywhere in the entire linked structure.</p>
+
+<p><strong>Note</strong> that the linked lists must <strong>retain their original structure</strong> after the function returns.</p>
+
+<p><strong>Custom Judge:</strong></p>
+
+<p>The inputs to the <strong>judge</strong> are given as follows (your program is <strong>not</strong> given these inputs):</p>
+
+<ul>
+	<li><code>intersectVal</code> - The value of the node where the intersection occurs. This is <code>0</code> if there is no intersected node.</li>
+	<li><code>listA</code> - The first linked list.</li>
+	<li><code>listB</code> - The second linked list.</li>
+	<li><code>skipA</code> - The number of nodes to skip ahead in <code>listA</code> (starting from the head) to get to the intersected node.</li>
+	<li><code>skipB</code> - The number of nodes to skip ahead in <code>listB</code> (starting from the head) to get to the intersected node.</li>
+</ul>
+
+<p>The judge will then create the linked structure based on these inputs and pass the two heads, <code>headA</code> and <code>headB</code> to your program. If you correctly return the intersected node, then your solution will be <strong>accepted</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/05/160_example_1_1.png" style="width: 500px; height: 162px;" />
+<pre>
+<strong>Input:</strong> intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
+<strong>Output:</strong> Intersected at &#39;8&#39;
+<strong>Explanation:</strong> The intersected node&#39;s value is 8 (note that this must not be 0 if the two lists intersect).
+From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.
+- Note that the intersected node&#39;s value is not 1 because the nodes with value 1 in A and B (2<sup>nd</sup> node in A and 3<sup>rd</sup> node in B) are different node references. In other words, they point to two different locations in memory, while the nodes with value 8 in A and B (3<sup>rd</sup> node in A and 4<sup>th</sup> node in B) point to the same location in memory.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/05/160_example_2.png" style="width: 500px; height: 194px;" />
+<pre>
+<strong>Input:</strong> intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+<strong>Output:</strong> Intersected at &#39;2&#39;
+<strong>Explanation:</strong> The intersected node&#39;s value is 2 (note that this must not be 0 if the two lists intersect).
+From the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/05/160_example_3.png" style="width: 300px; height: 189px;" />
+<pre>
+<strong>Input:</strong> intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+<strong>Output:</strong> No intersection
+<strong>Explanation:</strong> From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.
+Explanation: The two lists do not intersect, so return null.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes of <code>listA</code> is in the <code>m</code>.</li>
+	<li>The number of nodes of <code>listB</code> is in the <code>n</code>.</li>
+	<li><code>1 &lt;= m, n &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= skipA &lt;= m</code></li>
+	<li><code>0 &lt;= skipB &lt;= n</code></li>
+	<li><code>intersectVal</code> is <code>0</code> if <code>listA</code> and <code>listB</code> do not intersect.</li>
+	<li><code>intersectVal == listA[skipA] == listB[skipB]</code> if <code>listA</code> and <code>listB</code> intersect.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you write a solution that runs in <code>O(m + n)</code> time and use only <code>O(1)</code> memory?
\ No newline at end of file
diff --git a/leetcode/leetcode/0162-find-peak-element/0162-find-peak-element.java b/leetcode/leetcode/0162-find-peak-element/0162-find-peak-element.java
new file mode 100644
index 0000000..04d5c59
--- /dev/null
+++ b/leetcode/leetcode/0162-find-peak-element/0162-find-peak-element.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int findPeakElement(int[] nums) {
+        int N = nums.length;
+
+        if(N == 1) return 0;
+        if(nums[0]>nums[1]) return 0;
+        if(nums[N-1]>nums[N-2]) return N-1;
+
+        int low = 1;
+        int high = N-2;
+
+        while(low<=high){
+            int mid = low + (high - low)/2;
+
+            if(nums[mid]>nums[mid-1] && nums[mid]>nums[mid+1]) return mid;
+            else if(nums[mid]>nums[mid-1]) low = mid+1;
+            else high = mid - 1;
+
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0162-find-peak-element/README.md b/leetcode/leetcode/0162-find-peak-element/README.md
new file mode 100644
index 0000000..511544c
--- /dev/null
+++ b/leetcode/leetcode/0162-find-peak-element/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/find-peak-element">162. Find Peak Element</a></h2><h3>Medium</h3><hr><p>A peak element is an element that is strictly greater than its neighbors.</p>
+
+<p>Given a <strong>0-indexed</strong> integer array <code>nums</code>, find a peak element, and return its index. If the array contains multiple peaks, return the index to <strong>any of the peaks</strong>.</p>
+
+<p>You may imagine that <code>nums[-1] = nums[n] = -&infin;</code>. In other words, an element is always considered to be strictly greater than a neighbor that is outside the array.</p>
+
+<p>You must write an algorithm that runs in <code>O(log n)</code> time.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 3 is a peak element and your function should return the index number 2.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,1,3,5,6,4]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> Your function can return either index number 1 where the peak element is 2, or index number 5 where the peak element is 6.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>nums[i] != nums[i + 1]</code> for all valid <code>i</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/0167-two-sum-ii-input-array-is-sorted.java b/leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/0167-two-sum-ii-input-array-is-sorted.java
new file mode 100644
index 0000000..fa71809
--- /dev/null
+++ b/leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/0167-two-sum-ii-input-array-is-sorted.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int[] twoSum(int[] numbers, int target) {
+        int low = 0;
+        int high = numbers.length - 1;
+        int sum = numbers[low]+numbers[high];
+        while(sum!=target){
+    
+            if(sum>target){
+                high--;
+            }else{
+                low++;
+            }
+            sum = numbers[low]+numbers[high];
+        }
+        int[] ans = {low+1,high+1};
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/NOTES.md b/leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/README.md b/leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/README.md
new file mode 100644
index 0000000..9cace0e
--- /dev/null
+++ b/leetcode/leetcode/0167-two-sum-ii-input-array-is-sorted/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/two-sum-ii-input-array-is-sorted">167. Two Sum II - Input Array Is Sorted</a></h2><h3>Medium</h3><hr><p>Given a <strong>1-indexed</strong> array of integers <code>numbers</code> that is already <strong><em>sorted in non-decreasing order</em></strong>, find two numbers such that they add up to a specific <code>target</code> number. Let these two numbers be <code>numbers[index<sub>1</sub>]</code> and <code>numbers[index<sub>2</sub>]</code> where <code>1 &lt;= index<sub>1</sub> &lt; index<sub>2</sub> &lt;= numbers.length</code>.</p>
+
+<p>Return<em> the indices of the two numbers, </em><code>index<sub>1</sub></code><em> and </em><code>index<sub>2</sub></code><em>, <strong>added by one</strong> as an integer array </em><code>[index<sub>1</sub>, index<sub>2</sub>]</code><em> of length 2.</em></p>
+
+<p>The tests are generated such that there is <strong>exactly one solution</strong>. You <strong>may not</strong> use the same element twice.</p>
+
+<p>Your solution must use only constant extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> numbers = [<u>2</u>,<u>7</u>,11,15], target = 9
+<strong>Output:</strong> [1,2]
+<strong>Explanation:</strong> The sum of 2 and 7 is 9. Therefore, index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> numbers = [<u>2</u>,3,<u>4</u>], target = 6
+<strong>Output:</strong> [1,3]
+<strong>Explanation:</strong> The sum of 2 and 4 is 6. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 3. We return [1, 3].
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> numbers = [<u>-1</u>,<u>0</u>], target = -1
+<strong>Output:</strong> [1,2]
+<strong>Explanation:</strong> The sum of -1 and 0 is -1. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= numbers.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= numbers[i] &lt;= 1000</code></li>
+	<li><code>numbers</code> is sorted in <strong>non-decreasing order</strong>.</li>
+	<li><code>-1000 &lt;= target &lt;= 1000</code></li>
+	<li>The tests are generated such that there is <strong>exactly one solution</strong>.</li>
+</ul>
diff --git a/leetcode/leetcode/0169-majority-element/0169-majority-element.java b/leetcode/leetcode/0169-majority-element/0169-majority-element.java
new file mode 100644
index 0000000..9e6fb70
--- /dev/null
+++ b/leetcode/leetcode/0169-majority-element/0169-majority-element.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int majorityElement(int[] nums) {
+        int element = nums[0];
+        int count = 1;
+        for(int i  = 1;i<nums.length;i++){
+            if(count == 0){
+                element = nums[i];
+                count++;
+            }else if(element == nums[i]) count++;
+            else count--;
+        }
+        return element;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0169-majority-element/NOTES.md b/leetcode/leetcode/0169-majority-element/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0169-majority-element/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0169-majority-element/README.md b/leetcode/leetcode/0169-majority-element/README.md
new file mode 100644
index 0000000..641edd3
--- /dev/null
+++ b/leetcode/leetcode/0169-majority-element/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/majority-element">169. Majority Element</a></h2><h3>Easy</h3><hr><p>Given an array <code>nums</code> of size <code>n</code>, return <em>the majority element</em>.</p>
+
+<p>The majority element is the element that appears more than <code>&lfloor;n / 2&rfloor;</code> times. You may assume that the majority element always exists in the array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,3]
+<strong>Output:</strong> 3
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,1,1,1,2,2]
+<strong>Output:</strong> 2
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow-up:</strong> Could you solve the problem in linear time and in <code>O(1)</code> space?
\ No newline at end of file
diff --git a/leetcode/leetcode/0175-combine-two-tables/0175-combine-two-tables.sql b/leetcode/leetcode/0175-combine-two-tables/0175-combine-two-tables.sql
new file mode 100644
index 0000000..85cbbea
--- /dev/null
+++ b/leetcode/leetcode/0175-combine-two-tables/0175-combine-two-tables.sql
@@ -0,0 +1,3 @@
+# Write your MySQL query statement below
+# Write your MySQL query statement below
+SELECT p.firstName, p.lastName, a.city, a.state FROM Person p LEFT JOIN Address a ON p.personID = a.personID;
\ No newline at end of file
diff --git a/leetcode/leetcode/0175-combine-two-tables/NOTES.md b/leetcode/leetcode/0175-combine-two-tables/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0175-combine-two-tables/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0176-second-highest-salary/0176-second-highest-salary.sql b/leetcode/leetcode/0176-second-highest-salary/0176-second-highest-salary.sql
new file mode 100644
index 0000000..c74d1a7
--- /dev/null
+++ b/leetcode/leetcode/0176-second-highest-salary/0176-second-highest-salary.sql
@@ -0,0 +1,3 @@
+SELECT max(Salary) SecondHighestSalary
+FROM Employee
+WHERE Salary < (SELECT max(Salary) FROM Employee)
\ No newline at end of file
diff --git a/leetcode/leetcode/0176-second-highest-salary/README.md b/leetcode/leetcode/0176-second-highest-salary/README.md
new file mode 100644
index 0000000..aef209c
--- /dev/null
+++ b/leetcode/leetcode/0176-second-highest-salary/README.md
@@ -0,0 +1,55 @@
+<h2><a href="https://leetcode.com/problems/second-highest-salary/">176. Second Highest Salary</a></h2><h3>Medium</h3><hr><div class="sql-schema-wrapper__3VBi"><a class="sql-schema-link__3cEg">SQL Schema<svg viewBox="0 0 24 24" width="1em" height="1em" class="icon__1Md2"><path fill-rule="evenodd" d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></svg></a></div><div><p>Table: <code>Employee</code></p>
+
+<pre>+-------------+------+
+| Column Name | Type |
++-------------+------+
+| id          | int  |
+| salary      | int  |
++-------------+------+
+id is the primary key (column with unique values) for this table.
+Each row of this table contains information about the salary of an employee.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write a solution to find&nbsp;the second highest <strong>distinct</strong> salary from the <code>Employee</code> table. If there is no second highest salary,&nbsp;return&nbsp;<code>null (return&nbsp;None in Pandas)</code>.</p>
+
+<p>The result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> 
+Employee table:
++----+--------+
+| id | salary |
++----+--------+
+| 1  | 100    |
+| 2  | 200    |
+| 3  | 300    |
++----+--------+
+<strong>Output:</strong> 
++---------------------+
+| SecondHighestSalary |
++---------------------+
+| 200                 |
++---------------------+
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> 
+Employee table:
++----+--------+
+| id | salary |
++----+--------+
+| 1  | 100    |
++----+--------+
+<strong>Output:</strong> 
++---------------------+
+| SecondHighestSalary |
++---------------------+
+| null                |
++---------------------+
+</pre>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0177-nth-highest-salary/README.md b/leetcode/leetcode/0177-nth-highest-salary/README.md
new file mode 100644
index 0000000..26cbcd0
--- /dev/null
+++ b/leetcode/leetcode/0177-nth-highest-salary/README.md
@@ -0,0 +1,57 @@
+<h2><a href="https://leetcode.com/problems/nth-highest-salary/">177. Nth Highest Salary</a></h2><h3>Medium</h3><hr><div class="sql-schema-wrapper__3VBi"><a class="sql-schema-link__3cEg">SQL Schema<svg viewBox="0 0 24 24" width="1em" height="1em" class="icon__1Md2"><path fill-rule="evenodd" d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></svg></a></div><div><p>Table: <code>Employee</code></p>
+
+<pre>+-------------+------+
+| Column Name | Type |
++-------------+------+
+| id          | int  |
+| salary      | int  |
++-------------+------+
+id is the primary key (column with unique values) for this table.
+Each row of this table contains information about the salary of an employee.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write a solution to find the <code>n<sup>th</sup></code> highest salary from the <code>Employee</code> table. If there is no <code>n<sup>th</sup></code> highest salary, return&nbsp;<code>null</code>.</p>
+
+<p>The result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> 
+Employee table:
++----+--------+
+| id | salary |
++----+--------+
+| 1  | 100    |
+| 2  | 200    |
+| 3  | 300    |
++----+--------+
+n = 2
+<strong>Output:</strong> 
++------------------------+
+| getNthHighestSalary(2) |
++------------------------+
+| 200                    |
++------------------------+
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> 
+Employee table:
++----+--------+
+| id | salary |
++----+--------+
+| 1  | 100    |
++----+--------+
+n = 2
+<strong>Output:</strong> 
++------------------------+
+| getNthHighestSalary(2) |
++------------------------+
+| null                   |
++------------------------+
+</pre>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0179-largest-number/0179-largest-number.java b/leetcode/leetcode/0179-largest-number/0179-largest-number.java
new file mode 100644
index 0000000..ac904f2
--- /dev/null
+++ b/leetcode/leetcode/0179-largest-number/0179-largest-number.java
@@ -0,0 +1,19 @@
+class Solution {
+    public String largestNumber(int[] nums) {
+        String[] arr = new String[nums.length];
+        for(int i=0;i<nums.length;i++){
+            arr[i] = Integer.toString(nums[i]);
+        }
+        Arrays.sort(arr, (a, b) -> (b + a).compareTo(a + b));
+
+        if (arr[0].equals("0")) {
+            return "0";
+        }
+        StringBuilder largestNum = new StringBuilder();
+        for (String numStr : arr) {
+            largestNum.append(numStr);
+        }
+
+        return largestNum.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0179-largest-number/NOTES.md b/leetcode/leetcode/0179-largest-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0179-largest-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0179-largest-number/README.md b/leetcode/leetcode/0179-largest-number/README.md
new file mode 100644
index 0000000..2d1671b
--- /dev/null
+++ b/leetcode/leetcode/0179-largest-number/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/largest-number/">179. Largest Number</a></h2><h3>Medium</h3><hr><div><p>Given a list of non-negative integers <code>nums</code>, arrange them such that they form the largest number and return it.</p>
+
+<p>Since the result may be very large, so you need to return a string instead of an integer.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [10,2]
+<strong>Output:</strong> "210"
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,30,34,5,9]
+<strong>Output:</strong> "9534330"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0187-repeated-dna-sequences/0187-repeated-dna-sequences.java b/leetcode/leetcode/0187-repeated-dna-sequences/0187-repeated-dna-sequences.java
new file mode 100644
index 0000000..245aba1
--- /dev/null
+++ b/leetcode/leetcode/0187-repeated-dna-sequences/0187-repeated-dna-sequences.java
@@ -0,0 +1,31 @@
+class Solution {
+    public List<String> findRepeatedDnaSequences(String s) {
+        List<String> result = new ArrayList<>();
+        if(s.length()<10) return result;
+        HashMap<Long,Integer> map = new HashMap<>();
+        int MOD                = 1000000000 + 7;
+        int P                  = 7;
+        int M                  = s.length();
+        long d                 = 1;
+        long rollingHashValue  = 0;
+        for(int i = 0;i<10;i++){
+            rollingHashValue = (rollingHashValue * P + (int) s.charAt(i)) % MOD;
+            d = (d * P) % MOD;
+        }
+        
+        map.put(rollingHashValue,1);
+        for(int i = 0; i+10 < s.length();i++){
+        
+            rollingHashValue = (rollingHashValue * P + s.charAt(i+10) - s.charAt(i)*d) % MOD;
+            if(rollingHashValue<0){
+                rollingHashValue+=MOD;
+            }
+            map.put(rollingHashValue,map.getOrDefault(rollingHashValue,0)+1);
+            if(map.getOrDefault(rollingHashValue,0) == 2){ // very less possibility of hash collision hence adding blindly without checking
+                result.add(s.substring(i+1,i+11));
+            }
+        }
+        return result;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0187-repeated-dna-sequences/README.md b/leetcode/leetcode/0187-repeated-dna-sequences/README.md
new file mode 100644
index 0000000..90f8069
--- /dev/null
+++ b/leetcode/leetcode/0187-repeated-dna-sequences/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/repeated-dna-sequences">187. Repeated DNA Sequences</a></h2><h3>Medium</h3><hr><p>The <strong>DNA sequence</strong> is composed of a series of nucleotides abbreviated as <code>&#39;A&#39;</code>, <code>&#39;C&#39;</code>, <code>&#39;G&#39;</code>, and <code>&#39;T&#39;</code>.</p>
+
+<ul>
+	<li>For example, <code>&quot;ACGAATTCCG&quot;</code> is a <strong>DNA sequence</strong>.</li>
+</ul>
+
+<p>When studying <strong>DNA</strong>, it is useful to identify repeated sequences within the DNA.</p>
+
+<p>Given a string <code>s</code> that represents a <strong>DNA sequence</strong>, return all the <strong><code>10</code>-letter-long</strong> sequences (substrings) that occur more than once in a DNA molecule. You may return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
+<strong>Output:</strong> ["AAAAACCCCC","CCCCCAAAAA"]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "AAAAAAAAAAAAA"
+<strong>Output:</strong> ["AAAAAAAAAA"]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s[i]</code> is either <code>&#39;A&#39;</code>, <code>&#39;C&#39;</code>, <code>&#39;G&#39;</code>, or <code>&#39;T&#39;</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0189-rotate-array/0189-rotate-array.java b/leetcode/leetcode/0189-rotate-array/0189-rotate-array.java
new file mode 100644
index 0000000..97c4092
--- /dev/null
+++ b/leetcode/leetcode/0189-rotate-array/0189-rotate-array.java
@@ -0,0 +1,19 @@
+class Solution {
+    public void swap(int [] nums, int i, int j){
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+    public void reverse(int[] nums, int start, int end){
+        while(start<end){
+            swap(nums,start++,end--);
+        }
+    }
+    public void rotate(int[] nums, int k) {
+        if(k>=nums.length) k = k%nums.length;
+        if(k==0) return;
+        reverse(nums,0,nums.length-1);
+        reverse(nums,0,k-1);
+        reverse(nums,k,nums.length-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0189-rotate-array/NOTES.md b/leetcode/leetcode/0189-rotate-array/NOTES.md
new file mode 100644
index 0000000..c2f63e9
--- /dev/null
+++ b/leetcode/leetcode/0189-rotate-array/NOTES.md
@@ -0,0 +1 @@
+reverse
\ No newline at end of file
diff --git a/leetcode/leetcode/0189-rotate-array/README.md b/leetcode/leetcode/0189-rotate-array/README.md
new file mode 100644
index 0000000..0f1538d
--- /dev/null
+++ b/leetcode/leetcode/0189-rotate-array/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/rotate-array/">189. Rotate Array</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, rotate the array to the right by <code>k</code> steps, where <code>k</code> is non-negative.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,5,6,7], k = 3
+<strong>Output:</strong> [5,6,7,1,2,3,4]
+<strong>Explanation:</strong>
+rotate 1 steps to the right: [7,1,2,3,4,5,6]
+rotate 2 steps to the right: [6,7,1,2,3,4,5]
+rotate 3 steps to the right: [5,6,7,1,2,3,4]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,-100,3,99], k = 2
+<strong>Output:</strong> [3,99,-1,-100]
+<strong>Explanation:</strong> 
+rotate 1 steps to the right: [99,-1,-100,3]
+rotate 2 steps to the right: [3,99,-1,-100]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>0 &lt;= k &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>Try to come up with as many solutions as you can. There are at least <strong>three</strong> different ways to solve this problem.</li>
+	<li>Could you do it in-place with <code>O(1)</code> extra space?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0191-number-of-1-bits/0191-number-of-1-bits.java b/leetcode/leetcode/0191-number-of-1-bits/0191-number-of-1-bits.java
new file mode 100644
index 0000000..4ae471e
--- /dev/null
+++ b/leetcode/leetcode/0191-number-of-1-bits/0191-number-of-1-bits.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int hammingWeight(int n) {
+       int ans =0;
+       while(n!=0){
+        if(n%2==1){
+            ans++;
+        }
+        n = n/2;
+       }
+       return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0191-number-of-1-bits/README.md b/leetcode/leetcode/0191-number-of-1-bits/README.md
new file mode 100644
index 0000000..d530441
--- /dev/null
+++ b/leetcode/leetcode/0191-number-of-1-bits/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/number-of-1-bits">191. Number of 1 Bits</a></h2><h3>Easy</h3><hr><p>Given a positive integer <code>n</code>, write a function that returns the number of <span data-keyword="set-bit">set bits</span> in its binary representation (also known as the <a href="http://en.wikipedia.org/wiki/Hamming_weight" target="_blank">Hamming weight</a>).</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 11</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">3</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The input binary string <strong>1011</strong> has a total of three set bits.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 128</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">1</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The input binary string <strong>10000000</strong> has a total of one set bit.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 2147483645</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">30</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The input binary string <strong>1111111111111111111111111111101</strong> has a total of thirty set bits.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> If this function is called many times, how would you optimize it?
\ No newline at end of file
diff --git a/leetcode/leetcode/0196-delete-duplicate-emails/0196-delete-duplicate-emails.sql b/leetcode/leetcode/0196-delete-duplicate-emails/0196-delete-duplicate-emails.sql
new file mode 100644
index 0000000..eee706b
--- /dev/null
+++ b/leetcode/leetcode/0196-delete-duplicate-emails/0196-delete-duplicate-emails.sql
@@ -0,0 +1,2 @@
+delete p1 from person p1,person p2 
+where p1.email=p2.email and p1.id>p2.id;
\ No newline at end of file
diff --git a/leetcode/leetcode/0196-delete-duplicate-emails/NOTES.md b/leetcode/leetcode/0196-delete-duplicate-emails/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0196-delete-duplicate-emails/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0198-house-robber/0198-house-robber.java b/leetcode/leetcode/0198-house-robber/0198-house-robber.java
new file mode 100644
index 0000000..ba5317d
--- /dev/null
+++ b/leetcode/leetcode/0198-house-robber/0198-house-robber.java
@@ -0,0 +1,66 @@
+
+// Method: 1 - Recusrison [Time Limit Exceed (TLE)]
+// class Solution {
+//     public int helper(int[] nums, int currentIndex){
+//         if(currentIndex >= nums.length) return 0;
+//         int currentHouse = nums[currentIndex] + helper(nums,currentIndex+2);
+//         return Math.max(currentHouse, helper(nums,currentIndex+1));
+//     }
+//     public int rob(int[] nums) {
+//         return helper(nums,0);
+//     }
+// }
+
+
+// Method 2         : Memoization: Accepted 
+// Time complexity  : O(n)
+// Space Complexity : O(n) + recursion stack memory
+// class Solution {
+//     public int helper(int[] nums, int[] dp, int currentIndex){
+//         if(currentIndex >= nums.length) return 0;
+//         if(dp[currentIndex] != -1) return dp[currentIndex];
+//         int currentHouse = nums[currentIndex] + helper(nums,dp,currentIndex+2);
+//         dp[currentIndex] = Math.max(currentHouse, helper(nums,dp,currentIndex+1));
+//         return dp[currentIndex];
+//     }
+//     public int rob(int[] nums) {
+//         int[] dp = new int[nums.length];
+//         for(int i =0;i<nums.length;i++){
+//             dp[i] = -1;
+//         }
+//         return helper(nums,dp,0);
+//     }
+// }
+
+// Method 2         : Dynammic Programming: Accepted  (Most opmtimized)
+// Time complexity  : O(n)
+// Space complexity : O(n)
+class Solution {
+
+
+    public int helper(int[] house, int currentHouse,int[] memo){
+        if(currentHouse>=house.length) return 0;
+        if(memo[currentHouse] != -1) return memo[currentHouse];
+
+        int currentHouseLoot = house[currentHouse] + helper(house,currentHouse+2,memo);
+        int notLoot          = helper(house,currentHouse+1,memo);
+
+        memo[currentHouse] = Math.max(currentHouseLoot,notLoot);
+        return memo[currentHouse];
+    }
+
+
+
+    public int rob(int[] nums) {
+        int[] memo = new int[nums.length];
+        for(int i = 0;i<nums.length;i++){
+            memo[i] = -1;
+        }
+        return helper(nums,0,memo);
+
+    }
+}
+
+
+
+
diff --git a/leetcode/leetcode/0198-house-robber/0198-house-robber.py b/leetcode/leetcode/0198-house-robber/0198-house-robber.py
new file mode 100644
index 0000000..d266efb
--- /dev/null
+++ b/leetcode/leetcode/0198-house-robber/0198-house-robber.py
@@ -0,0 +1,19 @@
+class Solution:
+    
+
+    def rob(self, nums: List[int]) -> int:
+        n = len(nums)
+        memo = [-1]*n
+        def max_ans(nums,index):
+            if(index>=n): 
+                return 0
+            if(index == len(nums)-1):
+                return nums[-1]
+            if(memo[index]!=-1):
+                return memo[index]
+            
+            memo[index] = max(nums[index]+max_ans(nums,index+2),max_ans(nums,index+1))
+            return memo[index]
+        return max_ans(nums,0)
+    
+  
diff --git a/leetcode/leetcode/0198-house-robber/README.md b/leetcode/leetcode/0198-house-robber/README.md
new file mode 100644
index 0000000..c491b96
--- /dev/null
+++ b/leetcode/leetcode/0198-house-robber/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/house-robber">198. House Robber</a></h2><h3>Medium</h3><hr><p>You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and <b>it will automatically contact the police if two adjacent houses were broken into on the same night</b>.</p>
+
+<p>Given an integer array <code>nums</code> representing the amount of money of each house, return <em>the maximum amount of money you can rob tonight <b>without alerting the police</b></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,1]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Rob house 1 (money = 1) and then rob house 3 (money = 3).
+Total amount you can rob = 1 + 3 = 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,7,9,3,1]
+<strong>Output:</strong> 12
+<strong>Explanation:</strong> Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
+Total amount you can rob = 2 + 9 + 1 = 12.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 400</code></li>
+</ul>
diff --git a/leetcode/leetcode/0199-binary-tree-right-side-view/0199-binary-tree-right-side-view.java b/leetcode/leetcode/0199-binary-tree-right-side-view/0199-binary-tree-right-side-view.java
new file mode 100644
index 0000000..920aad6
--- /dev/null
+++ b/leetcode/leetcode/0199-binary-tree-right-side-view/0199-binary-tree-right-side-view.java
@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> rightSideView(TreeNode root) {
+        List<Integer> result = new ArrayList<>();
+        if(root == null) return result;
+
+        Queue<TreeNode> q = new LinkedList<>();
+
+        q.add(root);
+        while(!q.isEmpty()){
+            for(int i = q.size();i!=0;i--){
+                root = q.poll();
+                if(i == 1) result.add(root.val);
+
+                if(root.left!=null) q.add(root.left);
+                if(root.right!=null) q.add(root.right);
+            }
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0199-binary-tree-right-side-view/README.md b/leetcode/leetcode/0199-binary-tree-right-side-view/README.md
new file mode 100644
index 0000000..e5e81cc
--- /dev/null
+++ b/leetcode/leetcode/0199-binary-tree-right-side-view/README.md
@@ -0,0 +1,50 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-right-side-view">199. Binary Tree Right Side View</a></h2><h3>Medium</h3><hr><p>Given the <code>root</code> of a binary tree, imagine yourself standing on the <strong>right side</strong> of it, return <em>the values of the nodes you can see ordered from top to bottom</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1,2,3,null,5,null,4]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1,3,4]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/11/24/tmpd5jn43fs-1.png" style="width: 400px; height: 207px;" /></p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1,2,3,4,null,null,null,5]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1,3,4,5]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/11/24/tmpkpe40xeh-1.png" style="width: 400px; height: 214px;" /></p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = [1,null,3]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1,3]</span></p>
+</div>
+
+<p><strong class="example">Example 4:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">root = []</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[]</span></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0200-number-of-islands/0200-number-of-islands.java b/leetcode/leetcode/0200-number-of-islands/0200-number-of-islands.java
new file mode 100644
index 0000000..e84b64a
--- /dev/null
+++ b/leetcode/leetcode/0200-number-of-islands/0200-number-of-islands.java
@@ -0,0 +1,31 @@
+class Solution {
+    public void helper(char[][] grid, int rows, int cols, int row, int col, boolean[][] visited){
+        if(row<0 || col<0 || row>=rows || col>= cols) return;
+        if(visited[row][col]) return;
+        if(grid[row][col] == '0') return;
+        visited[row][col] = true;
+        helper(grid,rows,cols,row+1,col,visited);
+        helper(grid,rows,cols,row,col+1,visited);
+        helper(grid,rows,cols,row-1,col,visited);
+        helper(grid,rows,cols,row,col-1,visited);
+        return;
+    }
+
+    public int numIslands(char[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+
+        boolean[][] visited = new boolean[rows][cols];
+        int ans = 0;
+        for(int row = 0;row<rows;row++){
+            for(int col = 0;col<cols;col++){
+                if(visited[row][col]) continue;
+                if(grid[row][col] == '1'){
+                    ans++;
+                    helper(grid,rows,cols,row,col,visited);
+                }
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0200-number-of-islands/README.md b/leetcode/leetcode/0200-number-of-islands/README.md
new file mode 100644
index 0000000..42a12c0
--- /dev/null
+++ b/leetcode/leetcode/0200-number-of-islands/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/number-of-islands">200. Number of Islands</a></h2><h3>Medium</h3><hr><p>Given an <code>m x n</code> 2D binary grid <code>grid</code> which represents a map of <code>&#39;1&#39;</code>s (land) and <code>&#39;0&#39;</code>s (water), return <em>the number of islands</em>.</p>
+
+<p>An <strong>island</strong> is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [
+  [&quot;1&quot;,&quot;1&quot;,&quot;1&quot;,&quot;1&quot;,&quot;0&quot;],
+  [&quot;1&quot;,&quot;1&quot;,&quot;0&quot;,&quot;1&quot;,&quot;0&quot;],
+  [&quot;1&quot;,&quot;1&quot;,&quot;0&quot;,&quot;0&quot;,&quot;0&quot;],
+  [&quot;0&quot;,&quot;0&quot;,&quot;0&quot;,&quot;0&quot;,&quot;0&quot;]
+]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [
+  [&quot;1&quot;,&quot;1&quot;,&quot;0&quot;,&quot;0&quot;,&quot;0&quot;],
+  [&quot;1&quot;,&quot;1&quot;,&quot;0&quot;,&quot;0&quot;,&quot;0&quot;],
+  [&quot;0&quot;,&quot;0&quot;,&quot;1&quot;,&quot;0&quot;,&quot;0&quot;],
+  [&quot;0&quot;,&quot;0&quot;,&quot;0&quot;,&quot;1&quot;,&quot;1&quot;]
+]
+<strong>Output:</strong> 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 300</code></li>
+	<li><code>grid[i][j]</code> is <code>&#39;0&#39;</code> or <code>&#39;1&#39;</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0201-bitwise-and-of-numbers-range/0201-bitwise-and-of-numbers-range.java b/leetcode/leetcode/0201-bitwise-and-of-numbers-range/0201-bitwise-and-of-numbers-range.java
new file mode 100644
index 0000000..dd79d09
--- /dev/null
+++ b/leetcode/leetcode/0201-bitwise-and-of-numbers-range/0201-bitwise-and-of-numbers-range.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int rangeBitwiseAnd(int left, int right) {
+        int index = 0;
+        while(left!=right){
+            left = left >> 1;
+            right = right >> 1;
+            index++; 
+        }
+        return left << index;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0201-bitwise-and-of-numbers-range/README.md b/leetcode/leetcode/0201-bitwise-and-of-numbers-range/README.md
new file mode 100644
index 0000000..e55e5e5
--- /dev/null
+++ b/leetcode/leetcode/0201-bitwise-and-of-numbers-range/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/bitwise-and-of-numbers-range">201. Bitwise AND of Numbers Range</a></h2><h3>Medium</h3><hr><p>Given two integers <code>left</code> and <code>right</code> that represent the range <code>[left, right]</code>, return <em>the bitwise AND of all numbers in this range, inclusive</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> left = 5, right = 7
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> left = 0, right = 0
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> left = 1, right = 2147483647
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= left &lt;= right &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
diff --git a/leetcode/leetcode/0205-isomorphic-strings/0205-isomorphic-strings.java b/leetcode/leetcode/0205-isomorphic-strings/0205-isomorphic-strings.java
new file mode 100644
index 0000000..5346ebb
--- /dev/null
+++ b/leetcode/leetcode/0205-isomorphic-strings/0205-isomorphic-strings.java
@@ -0,0 +1,21 @@
+class Solution {
+    public boolean isIsomorphic(String s, String t) {
+        HashMap<Character,Character> map = new HashMap<>();
+        for(int i = 0;i<s.length();i++){
+            if(!map.containsKey(s.charAt(i))){
+                map.put(s.charAt(i),t.charAt(i));
+            }else if(map.get(s.charAt(i))!=t.charAt(i)){
+                return false;
+            }
+        }
+        map.clear();
+        for(int i = 0;i<s.length();i++){
+            if(!map.containsKey(t.charAt(i))){
+                map.put(t.charAt(i),s.charAt(i));
+            }else if(map.get(t.charAt(i))!=s.charAt(i)){
+                return false;
+            }
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0205-isomorphic-strings/NOTES.md b/leetcode/leetcode/0205-isomorphic-strings/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0205-isomorphic-strings/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0205-isomorphic-strings/README.md b/leetcode/leetcode/0205-isomorphic-strings/README.md
new file mode 100644
index 0000000..c7d544c
--- /dev/null
+++ b/leetcode/leetcode/0205-isomorphic-strings/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/isomorphic-strings/">205. Isomorphic Strings</a></h2><h3>Easy</h3><hr><div><p>Given two strings <code>s</code> and <code>t</code>, <em>determine if they are isomorphic</em>.</p>
+
+<p>Two strings <code>s</code> and <code>t</code> are isomorphic if the characters in <code>s</code> can be replaced to get <code>t</code>.</p>
+
+<p>All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character, but a character may map to itself.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "egg", t = "add"
+<strong>Output:</strong> true
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "foo", t = "bar"
+<strong>Output:</strong> false
+</pre><p><strong class="example">Example 3:</strong></p>
+<pre><strong>Input:</strong> s = "paper", t = "title"
+<strong>Output:</strong> true
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>t.length == s.length</code></li>
+	<li><code>s</code> and <code>t</code> consist of any valid ascii character.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0206-reverse-linked-list/0206-reverse-linked-list.java b/leetcode/leetcode/0206-reverse-linked-list/0206-reverse-linked-list.java
new file mode 100644
index 0000000..b4daf0b
--- /dev/null
+++ b/leetcode/leetcode/0206-reverse-linked-list/0206-reverse-linked-list.java
@@ -0,0 +1,50 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode reverseList(ListNode head) {
+        // // Approach 1: Copy Linked list to array.
+        // // TC : O(N)
+        // // SC : O(N)
+        // // Initialize a list
+        // ArrayList<Integer> list = new ArrayList<>();
+        // // Traversal
+        // ListNode temp = head;
+        // while(temp!=null){
+        //     list.add(temp.val);
+        //     temp = temp.next;
+        // }
+        // temp = head;
+        // for(int i = list.size()-1;i!=-1;i--){
+        //     System.out.println(list.get(i));
+        //     temp.val = list.get(i);
+        //     temp = temp.next;
+        // }
+        // return head;
+
+
+        // Approach 2: Optimial
+
+        if(head == null || head.next == null) return head;
+
+        ListNode prev = null;
+        ListNode curr = head;
+        ListNode next = head.next;
+        while(next!=null){
+            curr.next = prev;
+            prev  =curr;
+            curr = next;
+            next = next.next;
+        } 
+        curr.next = prev;
+        return curr;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0206-reverse-linked-list/0206-reverse-linked-list.py b/leetcode/leetcode/0206-reverse-linked-list/0206-reverse-linked-list.py
new file mode 100644
index 0000000..03d4c66
--- /dev/null
+++ b/leetcode/leetcode/0206-reverse-linked-list/0206-reverse-linked-list.py
@@ -0,0 +1,19 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        if(head == None or head.next == None):
+            return head
+        
+        newHead = self.reverseList(head.next)
+
+
+        tail = head.next
+
+        tail.next = head
+        head.next = None
+
+        return newHead
\ No newline at end of file
diff --git a/leetcode/leetcode/0206-reverse-linked-list/README.md b/leetcode/leetcode/0206-reverse-linked-list/README.md
new file mode 100644
index 0000000..d0e5a22
--- /dev/null
+++ b/leetcode/leetcode/0206-reverse-linked-list/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/reverse-linked-list">206. Reverse Linked List</a></h2><h3>Easy</h3><hr><p>Given the <code>head</code> of a singly linked list, reverse the list, and return <em>the reversed list</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg" style="width: 542px; height: 222px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5]
+<strong>Output:</strong> [5,4,3,2,1]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg" style="width: 182px; height: 222px;" />
+<pre>
+<strong>Input:</strong> head = [1,2]
+<strong>Output:</strong> [2,1]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> head = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is the range <code>[0, 5000]</code>.</li>
+	<li><code>-5000 &lt;= Node.val &lt;= 5000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> A linked list can be reversed either iteratively or recursively. Could you implement both?</p>
diff --git a/leetcode/leetcode/0209-minimum-size-subarray-sum/0209-minimum-size-subarray-sum.java b/leetcode/leetcode/0209-minimum-size-subarray-sum/0209-minimum-size-subarray-sum.java
new file mode 100644
index 0000000..b50f8f4
--- /dev/null
+++ b/leetcode/leetcode/0209-minimum-size-subarray-sum/0209-minimum-size-subarray-sum.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int minSubArrayLen(int target, int[] nums) {
+        int start = 0;
+        int end   = 0;
+        int sum   = 0;
+        int ans   = Integer.MAX_VALUE;
+        while(end<nums.length){
+            sum+=nums[end];
+            while(sum>=target){
+                ans = Math.min(ans,end-start+1);
+                sum-=nums[start];
+                start++;
+            }
+            end++;
+        }
+        if(ans == Integer.MAX_VALUE) return 0;
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0209-minimum-size-subarray-sum/README.md b/leetcode/leetcode/0209-minimum-size-subarray-sum/README.md
new file mode 100644
index 0000000..6175d13
--- /dev/null
+++ b/leetcode/leetcode/0209-minimum-size-subarray-sum/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/minimum-size-subarray-sum">209. Minimum Size Subarray Sum</a></h2><h3>Medium</h3><hr><p>Given an array of positive integers <code>nums</code> and a positive integer <code>target</code>, return <em>the <strong>minimal length</strong> of a </em><span data-keyword="subarray-nonempty"><em>subarray</em></span><em> whose sum is greater than or equal to</em> <code>target</code>. If there is no such subarray, return <code>0</code> instead.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> target = 7, nums = [2,3,1,2,4,3]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The subarray [4,3] has the minimal length under the problem constraint.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> target = 4, nums = [1,4,4]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> target = 11, nums = [1,1,1,1,1,1,1,1]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= target &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> If you have figured out the <code>O(n)</code> solution, try coding another solution of which the time complexity is <code>O(n log(n))</code>.
\ No newline at end of file
diff --git a/leetcode/leetcode/0213-house-robber-ii/0213-house-robber-ii.java b/leetcode/leetcode/0213-house-robber-ii/0213-house-robber-ii.java
new file mode 100644
index 0000000..7fa4cb7
--- /dev/null
+++ b/leetcode/leetcode/0213-house-robber-ii/0213-house-robber-ii.java
@@ -0,0 +1,30 @@
+class Solution {
+    public int helper(int[] nums, int[] memo, int index,  int exclude){
+        if(index== exclude) return 0;
+        if(index>=nums.length) return 0;
+        if(memo[index]!=-1) return memo[index];
+
+        int currentHouseLoot = nums[index]+ helper(nums, memo, index+2,exclude);
+        int notLoot = helper(nums,memo,index+1,exclude);
+        memo[index] = Math.max(currentHouseLoot,notLoot);
+        return memo[index];
+
+    }
+
+    public int rob(int[] nums) {
+        if(nums.length  ==1) return nums[0];
+
+        int[] memo = new int[nums.length];
+        for(int i = 0;i<nums.length;i++){
+            memo[i] = -1;
+        }
+
+        int ans1 = helper(nums,memo,0,nums.length -1);
+        for(int i = 0;i<nums.length;i++){
+            memo[i] = -1;
+        }
+        int ans2 = helper(nums,memo,1,0);
+        return Math.max(ans1,ans2);
+    
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0213-house-robber-ii/README.md b/leetcode/leetcode/0213-house-robber-ii/README.md
new file mode 100644
index 0000000..e45c4fa
--- /dev/null
+++ b/leetcode/leetcode/0213-house-robber-ii/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/house-robber-ii">213. House Robber II</a></h2><h3>Medium</h3><hr><p>You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are <strong>arranged in a circle.</strong> That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have a security system connected, and&nbsp;<b>it will automatically contact the police if two adjacent houses were broken into on the same night</b>.</p>
+
+<p>Given an integer array <code>nums</code> representing the amount of money of each house, return <em>the maximum amount of money you can rob tonight <strong>without alerting the police</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,3,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> You cannot rob house 1 (money = 2) and then rob house 3 (money = 2), because they are adjacent houses.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,1]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Rob house 1 (money = 1) and then rob house 3 (money = 3).
+Total amount you can rob = 1 + 3 = 4.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/0214-shortest-palindrome/0214-shortest-palindrome.java b/leetcode/leetcode/0214-shortest-palindrome/0214-shortest-palindrome.java
new file mode 100644
index 0000000..1eaeb60
--- /dev/null
+++ b/leetcode/leetcode/0214-shortest-palindrome/0214-shortest-palindrome.java
@@ -0,0 +1,18 @@
+class Solution {
+
+    public String shortestPalindrome(String s) {
+        int length = s.length();
+        String reversedString = new StringBuilder(s).reverse().toString();
+
+        for (int i = 0; i < length; i++) {
+            if (
+                s.substring(0, length - i).equals(reversedString.substring(i))
+            ) {
+                return new StringBuilder(reversedString.substring(0, i))
+                    .append(s)
+                    .toString();
+            }
+        }
+        return "";
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0214-shortest-palindrome/NOTES.md b/leetcode/leetcode/0214-shortest-palindrome/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0214-shortest-palindrome/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0214-shortest-palindrome/README.md b/leetcode/leetcode/0214-shortest-palindrome/README.md
new file mode 100644
index 0000000..127c954
--- /dev/null
+++ b/leetcode/leetcode/0214-shortest-palindrome/README.md
@@ -0,0 +1,20 @@
+<h2><a href="https://leetcode.com/problems/shortest-palindrome/">214. Shortest Palindrome</a></h2><h3>Hard</h3><hr><div><p>You are given a string <code>s</code>. You can convert <code>s</code> to a <span data-keyword="palindrome-string">palindrome</span> by adding characters in front of it.</p>
+
+<p>Return <em>the shortest palindrome you can find by performing this transformation</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "aacecaaa"
+<strong>Output:</strong> "aaacecaaa"
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "abcd"
+<strong>Output:</strong> "dcbabcd"
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of lowercase English letters only.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0215-kth-largest-element-in-an-array/0215-kth-largest-element-in-an-array.java b/leetcode/leetcode/0215-kth-largest-element-in-an-array/0215-kth-largest-element-in-an-array.java
new file mode 100644
index 0000000..389260a
--- /dev/null
+++ b/leetcode/leetcode/0215-kth-largest-element-in-an-array/0215-kth-largest-element-in-an-array.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+
+        for(int num: nums){
+            pq.add(num);
+            if(pq.size()>k) pq.remove();
+        }
+        return pq.remove();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0215-kth-largest-element-in-an-array/NOTES.md b/leetcode/leetcode/0215-kth-largest-element-in-an-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0215-kth-largest-element-in-an-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0215-kth-largest-element-in-an-array/README.md b/leetcode/leetcode/0215-kth-largest-element-in-an-array/README.md
new file mode 100644
index 0000000..298cc5a
--- /dev/null
+++ b/leetcode/leetcode/0215-kth-largest-element-in-an-array/README.md
@@ -0,0 +1,21 @@
+<h2><a href="https://leetcode.com/problems/kth-largest-element-in-an-array">215. Kth Largest Element in an Array</a></h2><h3>Medium</h3><hr><p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <em>the</em> <code>k<sup>th</sup></code> <em>largest element in the array</em>.</p>
+
+<p>Note that it is the <code>k<sup>th</sup></code> largest element in the sorted order, not the <code>k<sup>th</sup></code> distinct element.</p>
+
+<p>Can you solve it without sorting?</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,1,5,6,4], k = 2
+<strong>Output:</strong> 5
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,3,1,2,4,5,5,6], k = 4
+<strong>Output:</strong> 4
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0217-contains-duplicate/0217-contains-duplicate.java b/leetcode/leetcode/0217-contains-duplicate/0217-contains-duplicate.java
new file mode 100644
index 0000000..b0e3233
--- /dev/null
+++ b/leetcode/leetcode/0217-contains-duplicate/0217-contains-duplicate.java
@@ -0,0 +1,10 @@
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        HashSet<Integer> seen = new HashSet<>();
+        for(int num: nums){
+            if(seen.contains(num)) return true;
+            seen.add(num);
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0217-contains-duplicate/README.md b/leetcode/leetcode/0217-contains-duplicate/README.md
new file mode 100644
index 0000000..32f1258
--- /dev/null
+++ b/leetcode/leetcode/0217-contains-duplicate/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/contains-duplicate">217. Contains Duplicate</a></h2><h3>Easy</h3><hr><p>Given an integer array <code>nums</code>, return <code>true</code> if any value appears <strong>at least twice</strong> in the array, and return <code>false</code> if every element is distinct.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [1,2,3,1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The element 1 occurs at the indices 0 and 3.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [1,2,3,4]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">false</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>All elements are distinct.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [1,1,1,3,3,4,3,2,4,2]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0225-implement-stack-using-queues/0225-implement-stack-using-queues.java b/leetcode/leetcode/0225-implement-stack-using-queues/0225-implement-stack-using-queues.java
new file mode 100644
index 0000000..1debbde
--- /dev/null
+++ b/leetcode/leetcode/0225-implement-stack-using-queues/0225-implement-stack-using-queues.java
@@ -0,0 +1,45 @@
+class MyStack {
+
+    Queue<Integer> q1;
+    Queue<Integer> q2;
+
+    public MyStack() {
+        q1 = new LinkedList<>();
+        q2 = new LinkedList<>();
+    }
+    // O(n) time
+    public void push(int x) {
+        if(q1.isEmpty()){
+            q1.add(x);
+        }else{
+            q2.add(x);
+            while(!q1.isEmpty()){
+                q2.add(q1.remove());
+            }
+            Queue<Integer> q = q1;
+            q1 = q2;
+            q2 = q;
+        }
+    }
+    
+    public int pop() {
+        return q1.remove();
+    }
+    
+    public int top() {
+        return q1.peek();
+    }
+    
+    public boolean empty() {
+        return q1.isEmpty();
+    }
+}
+
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * MyStack obj = new MyStack();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.top();
+ * boolean param_4 = obj.empty();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/0225-implement-stack-using-queues/README.md b/leetcode/leetcode/0225-implement-stack-using-queues/README.md
new file mode 100644
index 0000000..b654d83
--- /dev/null
+++ b/leetcode/leetcode/0225-implement-stack-using-queues/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/implement-stack-using-queues">225. Implement Stack using Queues</a></h2><h3>Easy</h3><hr><p>Implement a last-in-first-out (LIFO) stack using only two queues. The implemented stack should support all the functions of a normal stack (<code>push</code>, <code>top</code>, <code>pop</code>, and <code>empty</code>).</p>
+
+<p>Implement the <code>MyStack</code> class:</p>
+
+<ul>
+	<li><code>void push(int x)</code> Pushes element x to the top of the stack.</li>
+	<li><code>int pop()</code> Removes the element on the top of the stack and returns it.</li>
+	<li><code>int top()</code> Returns the element on the top of the stack.</li>
+	<li><code>boolean empty()</code> Returns <code>true</code> if the stack is empty, <code>false</code> otherwise.</li>
+</ul>
+
+<p><b>Notes:</b></p>
+
+<ul>
+	<li>You must use <strong>only</strong> standard operations of a queue, which means that only <code>push to back</code>, <code>peek/pop from front</code>, <code>size</code> and <code>is empty</code> operations are valid.</li>
+	<li>Depending on your language, the queue may not be supported natively. You may simulate a queue using a list or deque (double-ended queue) as long as you use only a queue&#39;s standard operations.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input</strong>
+[&quot;MyStack&quot;, &quot;push&quot;, &quot;push&quot;, &quot;top&quot;, &quot;pop&quot;, &quot;empty&quot;]
+[[], [1], [2], [], [], []]
+<strong>Output</strong>
+[null, null, null, 2, 2, false]
+
+<strong>Explanation</strong>
+MyStack myStack = new MyStack();
+myStack.push(1);
+myStack.push(2);
+myStack.top(); // return 2
+myStack.pop(); // return 2
+myStack.empty(); // return False
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= x &lt;= 9</code></li>
+	<li>At most <code>100</code> calls will be made to <code>push</code>, <code>pop</code>, <code>top</code>, and <code>empty</code>.</li>
+	<li>All the calls to <code>pop</code> and <code>top</code> are valid.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong> Can you implement the stack using only one queue?</p>
diff --git a/leetcode/leetcode/0226-invert-binary-tree/0226-invert-binary-tree.java b/leetcode/leetcode/0226-invert-binary-tree/0226-invert-binary-tree.java
new file mode 100644
index 0000000..5697955
--- /dev/null
+++ b/leetcode/leetcode/0226-invert-binary-tree/0226-invert-binary-tree.java
@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+
+    // Approach 2: Swap Nodes
+    public TreeNode invertTree(TreeNode root) {
+        if(root == null) return root;
+
+
+        TreeNode temp = root.left;
+        root.left = root.right;
+        root.right = temp;
+        invertTree(root.left);
+        invertTree(root.right);
+        return root;
+       
+    }
+
+    // Approach 1: Create New Tree
+    // public TreeNode invertTree(TreeNode root) {
+    //     if(root == null) return null;
+    //     TreeNode node = new TreeNode(root.val);
+    //     node.left = invertTree(root.right);
+    //     node.right = invertTree(root.left);
+    //     return node;
+    // }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0226-invert-binary-tree/README.md b/leetcode/leetcode/0226-invert-binary-tree/README.md
new file mode 100644
index 0000000..50f4a63
--- /dev/null
+++ b/leetcode/leetcode/0226-invert-binary-tree/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/invert-binary-tree">226. Invert Binary Tree</a></h2><h3>Easy</h3><hr><p>Given the <code>root</code> of a binary tree, invert the tree, and return <em>its root</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg" style="width: 500px; height: 165px;" />
+<pre>
+<strong>Input:</strong> root = [4,2,7,1,3,6,9]
+<strong>Output:</strong> [4,7,2,9,6,3,1]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg" style="width: 500px; height: 120px;" />
+<pre>
+<strong>Input:</strong> root = [2,1,3]
+<strong>Output:</strong> [2,3,1]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0229-majority-element-ii/0229-majority-element-ii.java b/leetcode/leetcode/0229-majority-element-ii/0229-majority-element-ii.java
new file mode 100644
index 0000000..d513056
--- /dev/null
+++ b/leetcode/leetcode/0229-majority-element-ii/0229-majority-element-ii.java
@@ -0,0 +1,43 @@
+class Solution {
+    public List<Integer> majorityElement(int[] nums) {
+        int count1 = 0;
+        int count2 = 0;
+        int majority1 = 0;
+        int majority2 = 0;
+        for(int num: nums){
+            if(num == majority1) count1++;
+            else if(num == majority2) count2++;
+            else if(count1 == 0){
+                majority1 = num;
+                count1++;
+            }else if(count2 == 0){
+                majority2 = num;
+                count2++;
+            }else{
+                count1--;
+                count2--;
+            }
+        }
+        count1 = 0;
+        count2 = 0;
+        for(int num: nums){
+            if(num == majority1){
+                count1++;
+            }else if(num == majority2){
+                count2++;
+            }
+        }
+        
+        List<Integer> res = new ArrayList<>();
+        int n = nums.length;
+
+        if (count1 > n / 3) {
+            res.add(majority1);
+        }
+        if (count2 > n / 3) {
+            res.add(majority2);
+        }
+
+        return res;        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0229-majority-element-ii/README.md b/leetcode/leetcode/0229-majority-element-ii/README.md
new file mode 100644
index 0000000..91109a2
--- /dev/null
+++ b/leetcode/leetcode/0229-majority-element-ii/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/majority-element-ii">229. Majority Element II</a></h2><h3>Medium</h3><hr><p>Given an integer array of size <code>n</code>, find all elements that appear more than <code>&lfloor; n/3 &rfloor;</code> times.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,2,3]
+<strong>Output:</strong> [3]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2]
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you solve the problem in linear time and in <code>O(1)</code> space?</p>
diff --git a/leetcode/leetcode/0230-kth-smallest-element-in-a-bst/0230-kth-smallest-element-in-a-bst.java b/leetcode/leetcode/0230-kth-smallest-element-in-a-bst/0230-kth-smallest-element-in-a-bst.java
new file mode 100644
index 0000000..d331bc4
--- /dev/null
+++ b/leetcode/leetcode/0230-kth-smallest-element-in-a-bst/0230-kth-smallest-element-in-a-bst.java
@@ -0,0 +1,74 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    int count = 0;
+
+    public int helper(TreeNode root, int k){
+        if(root == null) return -1;
+        if(count == k) return root.val;
+        int left = helper(root.left,k);
+        if(count == k) return left;
+        count++;
+        if(count == k) return root.val;
+        return helper(root.right,k);
+
+
+    }
+    
+    public int kthSmallest(TreeNode root, int k) {
+        return helper(root,k);
+     }
+
+
+
+    // Approach 2: Save only k elements
+    // ArrayList<Integer> result = new ArrayList<>();
+
+    // public void helper(TreeNode root, int k){
+    //     if(root == null) return;
+    //     if(result.size() == k) return;
+
+    //     helper(root.left,k);
+    //     if(result.size() == k) return;
+    //     result.add(root.val);
+    //     if(result.size() == k) return;
+    //     helper(root.right,k);
+        
+    // } 
+
+    // public int kthSmallest(TreeNode root, int k) {
+    //     helper(root,k);
+    //     return result.get(k-1);
+    // }
+
+
+    // Approach: 1 Brute Forc
+    // ArrayList<Integer> result = new ArrayList<>();
+
+    // public void inorder(TreeNode root){
+    //     if(root == null) return;
+    //     inorder(root.left);
+    //     result.add(root.val);
+    //     inorder(root.right);
+    // }
+
+    // public int kthSmallest(TreeNode root, int k) {
+    //     inorder(root);
+    //     return result.get(k-1);
+        
+
+
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0230-kth-smallest-element-in-a-bst/README.md b/leetcode/leetcode/0230-kth-smallest-element-in-a-bst/README.md
new file mode 100644
index 0000000..b85079c
--- /dev/null
+++ b/leetcode/leetcode/0230-kth-smallest-element-in-a-bst/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/kth-smallest-element-in-a-bst">230. Kth Smallest Element in a BST</a></h2><h3>Medium</h3><hr><p>Given the <code>root</code> of a binary search tree, and an integer <code>k</code>, return <em>the</em> <code>k<sup>th</sup></code> <em>smallest value (<strong>1-indexed</strong>) of all the values of the nodes in the tree</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg" style="width: 212px; height: 301px;" />
+<pre>
+<strong>Input:</strong> root = [3,1,4,null,2], k = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/28/kthtree2.jpg" style="width: 382px; height: 302px;" />
+<pre>
+<strong>Input:</strong> root = [5,3,6,2,4,null,null,1], k = 3
+<strong>Output:</strong> 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is <code>n</code>.</li>
+	<li><code>1 &lt;= k &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?</p>
diff --git a/leetcode/leetcode/0232-implement-queue-using-stacks/0232-implement-queue-using-stacks.java b/leetcode/leetcode/0232-implement-queue-using-stacks/0232-implement-queue-using-stacks.java
new file mode 100644
index 0000000..bfdeb22
--- /dev/null
+++ b/leetcode/leetcode/0232-implement-queue-using-stacks/0232-implement-queue-using-stacks.java
@@ -0,0 +1,44 @@
+class MyQueue {
+
+    Stack<Integer> s1;
+    Stack<Integer> s2;
+
+
+    public MyQueue() {
+        s1 = new Stack<>();
+        s2 = new Stack<>();
+
+    }
+    
+    public void push(int x) {
+        while(!s1.isEmpty()){
+            s2.push(s1.pop());
+        }
+        s1.push(x);
+
+        while(!s2.isEmpty()){
+            s1.push(s2.pop());
+        }
+    }
+    
+    public int pop() {
+        return s1.pop();
+    }
+    
+    public int peek() {
+        return s1.peek();
+    }
+    
+    public boolean empty() {
+        return s1.isEmpty();
+    }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * MyQueue obj = new MyQueue();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.peek();
+ * boolean param_4 = obj.empty();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/0232-implement-queue-using-stacks/README.md b/leetcode/leetcode/0232-implement-queue-using-stacks/README.md
new file mode 100644
index 0000000..d0de1ae
--- /dev/null
+++ b/leetcode/leetcode/0232-implement-queue-using-stacks/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/implement-queue-using-stacks">232. Implement Queue using Stacks</a></h2><h3>Easy</h3><hr><p>Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue (<code>push</code>, <code>peek</code>, <code>pop</code>, and <code>empty</code>).</p>
+
+<p>Implement the <code>MyQueue</code> class:</p>
+
+<ul>
+	<li><code>void push(int x)</code> Pushes element x to the back of the queue.</li>
+	<li><code>int pop()</code> Removes the element from the front of the queue and returns it.</li>
+	<li><code>int peek()</code> Returns the element at the front of the queue.</li>
+	<li><code>boolean empty()</code> Returns <code>true</code> if the queue is empty, <code>false</code> otherwise.</li>
+</ul>
+
+<p><strong>Notes:</strong></p>
+
+<ul>
+	<li>You must use <strong>only</strong> standard operations of a stack, which means only <code>push to top</code>, <code>peek/pop from top</code>, <code>size</code>, and <code>is empty</code> operations are valid.</li>
+	<li>Depending on your language, the stack may not be supported natively. You may simulate a stack using a list or deque (double-ended queue) as long as you use only a stack&#39;s standard operations.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input</strong>
+[&quot;MyQueue&quot;, &quot;push&quot;, &quot;push&quot;, &quot;peek&quot;, &quot;pop&quot;, &quot;empty&quot;]
+[[], [1], [2], [], [], []]
+<strong>Output</strong>
+[null, null, null, 1, 1, false]
+
+<strong>Explanation</strong>
+MyQueue myQueue = new MyQueue();
+myQueue.push(1); // queue is: [1]
+myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
+myQueue.peek(); // return 1
+myQueue.pop(); // return 1, queue is [2]
+myQueue.empty(); // return false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= x &lt;= 9</code></li>
+	<li>At most <code>100</code>&nbsp;calls will be made to <code>push</code>, <code>pop</code>, <code>peek</code>, and <code>empty</code>.</li>
+	<li>All the calls to <code>pop</code> and <code>peek</code> are valid.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong> Can you implement the queue such that each operation is <strong><a href="https://en.wikipedia.org/wiki/Amortized_analysis" target="_blank">amortized</a></strong> <code>O(1)</code> time complexity? In other words, performing <code>n</code> operations will take overall <code>O(n)</code> time even if one of those operations may take longer.</p>
diff --git a/leetcode/leetcode/0234-palindrome-linked-list/0234-palindrome-linked-list.java b/leetcode/leetcode/0234-palindrome-linked-list/0234-palindrome-linked-list.java
new file mode 100644
index 0000000..dbf2552
--- /dev/null
+++ b/leetcode/leetcode/0234-palindrome-linked-list/0234-palindrome-linked-list.java
@@ -0,0 +1,52 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    //   null <- 1<- 2<-3  null
+    //               p  c n
+    public ListNode reverse(ListNode head){
+        ListNode prev = null;
+        ListNode curr = head;
+        ListNode next = head.next;
+        while(next!=null){
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+            next = next.next;
+        }
+        curr.next = prev;
+        return curr;
+    }
+ // 1->2
+ // 1->2->3
+    public boolean isPalindrome(ListNode head) {
+        if(head==null || head.next==null) return true;
+        ListNode prev = null;
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast!=null && fast.next !=null){
+            prev = slow;
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        prev.next = null;
+        slow = reverse(slow);
+
+        ListNode temp = head;
+        while(temp!=null && slow!=null){
+            if(temp.val!=slow.val) return false;
+            temp = temp.next;
+            slow = slow.next;
+        }
+        return true;
+
+
+    } 
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0234-palindrome-linked-list/README.md b/leetcode/leetcode/0234-palindrome-linked-list/README.md
new file mode 100644
index 0000000..7576eb7
--- /dev/null
+++ b/leetcode/leetcode/0234-palindrome-linked-list/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/palindrome-linked-list">234. Palindrome Linked List</a></h2><h3>Easy</h3><hr><p>Given the <code>head</code> of a singly linked list, return <code>true</code><em> if it is a </em><span data-keyword="palindrome-sequence"><em>palindrome</em></span><em> or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,2,1]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;" />
+<pre>
+<strong>Input:</strong> head = [1,2]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 9</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?
\ No newline at end of file
diff --git a/leetcode/leetcode/0235-lowest-common-ancestor-of-a-binary-search-tree/0235-lowest-common-ancestor-of-a-binary-search-tree.java b/leetcode/leetcode/0235-lowest-common-ancestor-of-a-binary-search-tree/0235-lowest-common-ancestor-of-a-binary-search-tree.java
new file mode 100644
index 0000000..c88b12b
--- /dev/null
+++ b/leetcode/leetcode/0235-lowest-common-ancestor-of-a-binary-search-tree/0235-lowest-common-ancestor-of-a-binary-search-tree.java
@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+
+class Solution {
+
+    public TreeNode helper(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null)
+            return null;
+
+        if (root == p || root == q)
+            return root;
+        TreeNode left = helper(root.left, p, q);
+        TreeNode right = helper(root.right, p, q);
+
+        if (left != null && right != null)
+            return root;
+        if (left == null && right != null)
+            return right;
+        if (left != null && right == null)
+            return left;
+        return null;
+
+    }
+
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        return helper(root, p, q);
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0235-lowest-common-ancestor-of-a-binary-search-tree/README.md b/leetcode/leetcode/0235-lowest-common-ancestor-of-a-binary-search-tree/README.md
new file mode 100644
index 0000000..ccc587c
--- /dev/null
+++ b/leetcode/leetcode/0235-lowest-common-ancestor-of-a-binary-search-tree/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree">235. Lowest Common Ancestor of a Binary Search Tree</a></h2><h3>Medium</h3><hr><p>Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.</p>
+
+<p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: &ldquo;The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <strong>a node to be a descendant of itself</strong>).&rdquo;</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" />
+<pre>
+<strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The LCA of nodes 2 and 8 is 6.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarysearchtree_improved.png" style="width: 200px; height: 190px;" />
+<pre>
+<strong>Input:</strong> root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [2,1], p = 2, q = 1
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li>
+	<li><code>-10<sup>9</sup> &lt;= Node.val &lt;= 10<sup>9</sup></code></li>
+	<li>All <code>Node.val</code> are <strong>unique</strong>.</li>
+	<li><code>p != q</code></li>
+	<li><code>p</code> and <code>q</code> will exist in the BST.</li>
+</ul>
diff --git a/leetcode/leetcode/0236-lowest-common-ancestor-of-a-binary-tree/0236-lowest-common-ancestor-of-a-binary-tree.java b/leetcode/leetcode/0236-lowest-common-ancestor-of-a-binary-tree/0236-lowest-common-ancestor-of-a-binary-tree.java
new file mode 100644
index 0000000..5da51b7
--- /dev/null
+++ b/leetcode/leetcode/0236-lowest-common-ancestor-of-a-binary-tree/0236-lowest-common-ancestor-of-a-binary-tree.java
@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if(root == null) return null;
+
+
+        if(root == p || root == q) return root;
+
+        TreeNode left  = lowestCommonAncestor(root.left,p,q);
+        TreeNode right = lowestCommonAncestor(root.right,p,q);
+
+        if(left!=null && right== null){
+            return left;
+        }else if(left==null && right !=null){
+            return right;
+        }else if(left !=null && right !=null){
+            return root;
+        }else{
+            return null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0236-lowest-common-ancestor-of-a-binary-tree/README.md b/leetcode/leetcode/0236-lowest-common-ancestor-of-a-binary-tree/README.md
new file mode 100644
index 0000000..2e41005
--- /dev/null
+++ b/leetcode/leetcode/0236-lowest-common-ancestor-of-a-binary-tree/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree">236. Lowest Common Ancestor of a Binary Tree</a></h2><h3>Medium</h3><hr><p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p>
+
+<p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: &ldquo;The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).&rdquo;</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
+<pre>
+<strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
+<pre>
+<strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [1,2], p = 1, q = 2
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li>
+	<li><code>-10<sup>9</sup> &lt;= Node.val &lt;= 10<sup>9</sup></code></li>
+	<li>All <code>Node.val</code> are <strong>unique</strong>.</li>
+	<li><code>p != q</code></li>
+	<li><code>p</code> and <code>q</code> will exist in the tree.</li>
+</ul>
diff --git a/leetcode/leetcode/0237-delete-node-in-a-linked-list/0237-delete-node-in-a-linked-list.java b/leetcode/leetcode/0237-delete-node-in-a-linked-list/0237-delete-node-in-a-linked-list.java
new file mode 100644
index 0000000..8d38454
--- /dev/null
+++ b/leetcode/leetcode/0237-delete-node-in-a-linked-list/0237-delete-node-in-a-linked-list.java
@@ -0,0 +1,15 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public void deleteNode(ListNode node) {
+        node.val = node.next.val;
+        node.next = node.next.next;
+        return;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0237-delete-node-in-a-linked-list/NOTES.md b/leetcode/leetcode/0237-delete-node-in-a-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0237-delete-node-in-a-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0237-delete-node-in-a-linked-list/README.md b/leetcode/leetcode/0237-delete-node-in-a-linked-list/README.md
new file mode 100644
index 0000000..3fc46f1
--- /dev/null
+++ b/leetcode/leetcode/0237-delete-node-in-a-linked-list/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/delete-node-in-a-linked-list/">237. Delete Node in a Linked List</a></h2><h3>Medium</h3><hr><div><p>There is a singly-linked list <code>head</code> and we want to delete a node <code>node</code> in it.</p>
+
+<p>You are given the node to be deleted <code>node</code>. You will <strong>not be given access</strong> to the first node of <code>head</code>.</p>
+
+<p>All the values of the linked list are <strong>unique</strong>, and it is guaranteed that the given node <code>node</code> is not the last node in the linked list.</p>
+
+<p>Delete the given node. Note that by deleting the node, we do not mean removing it from memory. We mean:</p>
+
+<ul>
+	<li>The value of the given node should not exist in the linked list.</li>
+	<li>The number of nodes in the linked list should decrease by one.</li>
+	<li>All the values before <code>node</code> should be in the same order.</li>
+	<li>All the values after <code>node</code> should be in the same order.</li>
+</ul>
+
+<p><strong>Custom testing:</strong></p>
+
+<ul>
+	<li>For the input, you should provide the entire linked list <code>head</code> and the node to be given <code>node</code>. <code>node</code> should not be the last node of the list and should be an actual node in the list.</li>
+	<li>We will build the linked list and pass the node to your function.</li>
+	<li>The output will be the entire list after calling your function.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/node1.jpg" style="width: 400px; height: 286px;">
+<pre><strong>Input:</strong> head = [4,5,1,9], node = 5
+<strong>Output:</strong> [4,1,9]
+<strong>Explanation: </strong>You are given the second node with value 5, the linked list should become 4 -&gt; 1 -&gt; 9 after calling your function.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/node2.jpg" style="width: 400px; height: 315px;">
+<pre><strong>Input:</strong> head = [4,5,1,9], node = 1
+<strong>Output:</strong> [4,5,9]
+<strong>Explanation: </strong>You are given the third node with value 1, the linked list should become 4 -&gt; 5 -&gt; 9 after calling your function.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of the nodes in the given list is in the range <code>[2, 1000]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+	<li>The value of each node in the list is <strong>unique</strong>.</li>
+	<li>The <code>node</code> to be deleted is <strong>in the list</strong> and is <strong>not a tail</strong> node.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0238-product-of-array-except-self/0238-product-of-array-except-self.java b/leetcode/leetcode/0238-product-of-array-except-self/0238-product-of-array-except-self.java
new file mode 100644
index 0000000..eba3bf7
--- /dev/null
+++ b/leetcode/leetcode/0238-product-of-array-except-self/0238-product-of-array-except-self.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int[] result = new int[nums.length];
+        result[0] = 1;
+        for(int i = 1;i<nums.length;i++){
+            result[i] = nums[i-1]*result[i-1];
+        }
+        int right= 1;
+        for(int i = nums.length-1;i!=-1;i--){
+            result[i] = result[i]*right;
+            right = right*nums[i];
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0238-product-of-array-except-self/NOTES.md b/leetcode/leetcode/0238-product-of-array-except-self/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0238-product-of-array-except-self/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0238-product-of-array-except-self/README.md b/leetcode/leetcode/0238-product-of-array-except-self/README.md
new file mode 100644
index 0000000..912d25d
--- /dev/null
+++ b/leetcode/leetcode/0238-product-of-array-except-self/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/product-of-array-except-self">238. Product of Array Except Self</a></h2><h3>Medium</h3><hr><p>Given an integer array <code>nums</code>, return <em>an array</em> <code>answer</code> <em>such that</em> <code>answer[i]</code> <em>is equal to the product of all the elements of</em> <code>nums</code> <em>except</em> <code>nums[i]</code>.</p>
+
+<p>The product of any prefix or suffix of <code>nums</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</p>
+
+<p>You must write an algorithm that runs in&nbsp;<code>O(n)</code>&nbsp;time and without using the division operation.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> [24,12,8,6]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [-1,1,0,-3,3]
+<strong>Output:</strong> [0,0,9,0,0]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-30 &lt;= nums[i] &lt;= 30</code></li>
+	<li>The input is generated such that <code>answer[i]</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong>&nbsp;Can you solve the problem in <code>O(1)</code>&nbsp;extra&nbsp;space complexity? (The output array <strong>does not</strong> count as extra space for space complexity analysis.)</p>
diff --git a/leetcode/leetcode/0239-sliding-window-maximum/0239-sliding-window-maximum.java b/leetcode/leetcode/0239-sliding-window-maximum/0239-sliding-window-maximum.java
new file mode 100644
index 0000000..6a93027
--- /dev/null
+++ b/leetcode/leetcode/0239-sliding-window-maximum/0239-sliding-window-maximum.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        int n = nums.length;
+        Deque<Integer> dq = new ArrayDeque<>();
+        int[] result = new int[n-k+1];
+        int currentIndex = 0;
+        for(int i = 0;i<nums.length;i++){
+            while(!dq.isEmpty() && dq.peekFirst()<=i-k) dq.pollFirst();
+            while(!dq.isEmpty() && nums[dq.peekLast()] < nums[i]) dq.pollLast();
+            dq.offerLast(i);
+            if(i>=k-1) result[currentIndex++] = nums[dq.peekFirst()];
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0239-sliding-window-maximum/README.md b/leetcode/leetcode/0239-sliding-window-maximum/README.md
new file mode 100644
index 0000000..e74bbc2
--- /dev/null
+++ b/leetcode/leetcode/0239-sliding-window-maximum/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/sliding-window-maximum">239. Sliding Window Maximum</a></h2><h3>Hard</h3><hr><p>You are given an array of integers&nbsp;<code>nums</code>, there is a sliding window of size <code>k</code> which is moving from the very left of the array to the very right. You can only see the <code>k</code> numbers in the window. Each time the sliding window moves right by one position.</p>
+
+<p>Return <em>the max sliding window</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,3,-1,-3,5,3,6,7], k = 3
+<strong>Output:</strong> [3,3,5,5,6,7]
+<strong>Explanation:</strong> 
+Window position                Max
+---------------               -----
+[1  3  -1] -3  5  3  6  7       <strong>3</strong>
+ 1 [3  -1  -3] 5  3  6  7       <strong>3</strong>
+ 1  3 [-1  -3  5] 3  6  7      <strong> 5</strong>
+ 1  3  -1 [-3  5  3] 6  7       <strong>5</strong>
+ 1  3  -1  -3 [5  3  6] 7       <strong>6</strong>
+ 1  3  -1  -3  5 [3  6  7]      <strong>7</strong>
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1], k = 1
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= k &lt;= nums.length</code></li>
+</ul>
diff --git a/leetcode/leetcode/0241-different-ways-to-add-parentheses/0241-different-ways-to-add-parentheses.java b/leetcode/leetcode/0241-different-ways-to-add-parentheses/0241-different-ways-to-add-parentheses.java
new file mode 100644
index 0000000..01bdd7c
--- /dev/null
+++ b/leetcode/leetcode/0241-different-ways-to-add-parentheses/0241-different-ways-to-add-parentheses.java
@@ -0,0 +1,49 @@
+class Solution {
+    public List<Integer> diffWaysToCompute(String expression) {
+        List<Integer> results = new ArrayList<>();
+        if (expression.length() == 0) return results;
+
+        if (expression.length() == 1) {
+            results.add(Integer.parseInt(expression));
+            return results;
+        }
+        if(expression.length() == 2 && Character.isDigit(expression.charAt(0))){
+            results.add(Integer.parseInt(expression));
+            return results;
+        }
+        for (int i = 0; i < expression.length(); i++) {
+            char currentChar = expression.charAt(i);
+
+            if (Character.isDigit(currentChar)) continue;
+
+            List<Integer> leftResults = diffWaysToCompute(
+                expression.substring(0, i)
+            );
+            List<Integer> rightResults = diffWaysToCompute(
+                expression.substring(i + 1)
+            );
+
+            for (int leftValue : leftResults) {
+                for (int rightValue : rightResults) {
+                    int computedResult = 0;
+
+                    switch (currentChar) {
+                        case '+':
+                            computedResult = leftValue + rightValue;
+                            break;
+                        case '-':
+                            computedResult = leftValue - rightValue;
+                            break;
+                        case '*':
+                            computedResult = leftValue * rightValue;
+                            break;
+                    }
+
+                    results.add(computedResult);
+                }
+            }
+        }
+
+        return results;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0241-different-ways-to-add-parentheses/NOTES.md b/leetcode/leetcode/0241-different-ways-to-add-parentheses/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0241-different-ways-to-add-parentheses/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0241-different-ways-to-add-parentheses/README.md b/leetcode/leetcode/0241-different-ways-to-add-parentheses/README.md
new file mode 100644
index 0000000..9e125c0
--- /dev/null
+++ b/leetcode/leetcode/0241-different-ways-to-add-parentheses/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/different-ways-to-add-parentheses/">241. Different Ways to Add Parentheses</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>expression</code> of numbers and operators, return <em>all possible results from computing all the different possible ways to group numbers and operators</em>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>The test cases are generated such that the output values fit in a 32-bit integer and the number of different results does not exceed <code>10<sup>4</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> expression = "2-1-1"
+<strong>Output:</strong> [0,2]
+<strong>Explanation:</strong>
+((2-1)-1) = 0 
+(2-(1-1)) = 2
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> expression = "2*3-4*5"
+<strong>Output:</strong> [-34,-14,-10,-10,10]
+<strong>Explanation:</strong>
+(2*(3-(4*5))) = -34 
+((2*3)-(4*5)) = -14 
+((2*(3-4))*5) = -10 
+(2*((3-4)*5)) = -10 
+(((2*3)-4)*5) = 10
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= expression.length &lt;= 20</code></li>
+	<li><code>expression</code> consists of digits and the operator <code>'+'</code>, <code>'-'</code>, and <code>'*'</code>.</li>
+	<li>All the integer values in the input expression are in the range <code>[0, 99]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0242-valid-anagram/0242-valid-anagram.java b/leetcode/leetcode/0242-valid-anagram/0242-valid-anagram.java
new file mode 100644
index 0000000..3e05e81
--- /dev/null
+++ b/leetcode/leetcode/0242-valid-anagram/0242-valid-anagram.java
@@ -0,0 +1,17 @@
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        HashMap<Character,Integer> map = new HashMap<>();
+        for(int i = 0;i<s.length();i++){
+            map.put(s.charAt(i),map.getOrDefault(s.charAt(i),0)+1);
+        }
+        for(int i = 0;i<t.length();i++){
+            if(map.containsKey(t.charAt(i))){
+                map.put(t.charAt(i),map.get(t.charAt(i))-1);
+            }else{
+                return false;
+            }
+            if(map.get(t.charAt(i)) == 0) map.remove(t.charAt(i));
+        }
+        return map.size() == 0;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0242-valid-anagram/NOTES.md b/leetcode/leetcode/0242-valid-anagram/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0242-valid-anagram/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0242-valid-anagram/README.md b/leetcode/leetcode/0242-valid-anagram/README.md
new file mode 100644
index 0000000..c06723c
--- /dev/null
+++ b/leetcode/leetcode/0242-valid-anagram/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/valid-anagram/">242. Valid Anagram</a></h2><h3>Easy</h3><hr><div><p>Given two strings <code>s</code> and <code>t</code>, return <code>true</code> <em>if</em> <code>t</code> <em>is an anagram of</em> <code>s</code><em>, and</em> <code>false</code> <em>otherwise</em>.</p>
+
+<p>An <strong>Anagram</strong> is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "anagram", t = "nagaram"
+<strong>Output:</strong> true
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "rat", t = "car"
+<strong>Output:</strong> false
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length, t.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>s</code> and <code>t</code> consist of lowercase English letters.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> What if the inputs contain Unicode characters? How would you adapt your solution to such a case?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0257-binary-tree-paths/0257-binary-tree-paths.py b/leetcode/leetcode/0257-binary-tree-paths/0257-binary-tree-paths.py
new file mode 100644
index 0000000..fce9e5d
--- /dev/null
+++ b/leetcode/leetcode/0257-binary-tree-paths/0257-binary-tree-paths.py
@@ -0,0 +1,34 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+
+    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
+        res = []
+
+        if(root.left == root.right == None):
+            res.append(str(root.val))
+            return res
+        if(root == None):
+            return []
+        def helper(root, curr_path=""):
+            if(root == None):
+                return 
+
+            if(root.left == root.right == None):
+                res.append(curr_path + "->" + str(root.val))
+                return
+
+            helper(root.left,curr_path + "->" + str(root.val))
+            helper(root.right,curr_path + "->" + str(root.val))
+    
+        helper(root.left,str(root.val))
+        helper(root.right,str(root.val))
+        return res
+            
+            
+
+
diff --git a/leetcode/leetcode/0257-binary-tree-paths/README.md b/leetcode/leetcode/0257-binary-tree-paths/README.md
new file mode 100644
index 0000000..d0a5987
--- /dev/null
+++ b/leetcode/leetcode/0257-binary-tree-paths/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-paths">257. Binary Tree Paths</a></h2><h3>Easy</h3><hr><p>Given the <code>root</code> of a binary tree, return <em>all root-to-leaf paths in <strong>any order</strong></em>.</p>
+
+<p>A <strong>leaf</strong> is a node with no children.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/12/paths-tree.jpg" style="width: 207px; height: 293px;" />
+<pre>
+<strong>Input:</strong> root = [1,2,3,null,5]
+<strong>Output:</strong> [&quot;1-&gt;2-&gt;5&quot;,&quot;1-&gt;3&quot;]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [1]
+<strong>Output:</strong> [&quot;1&quot;]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0268-missing-number/0268-missing-number.java b/leetcode/leetcode/0268-missing-number/0268-missing-number.java
new file mode 100644
index 0000000..8551ad2
--- /dev/null
+++ b/leetcode/leetcode/0268-missing-number/0268-missing-number.java
@@ -0,0 +1,8 @@
+class Solution {
+    public int missingNumber(int[] nums) {
+        int n = nums.length;
+        int Tsum = (n * (n + 1)) / 2;
+        int actualSum = Arrays.stream(nums).sum();
+        return Tsum - actualSum;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0268-missing-number/README.md b/leetcode/leetcode/0268-missing-number/README.md
new file mode 100644
index 0000000..9910f82
--- /dev/null
+++ b/leetcode/leetcode/0268-missing-number/README.md
@@ -0,0 +1,69 @@
+<h2><a href="https://leetcode.com/problems/missing-number">268. Missing Number</a></h2><h3>Easy</h3><hr><p>Given an array <code>nums</code> containing <code>n</code> distinct numbers in the range <code>[0, n]</code>, return <em>the only number in the range that is missing from the array.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [3,0,1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">2</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><code>n = 3</code> since there are 3 numbers, so all numbers are in the range <code>[0,3]</code>. 2 is the missing number in the range since it does not appear in <code>nums</code>.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [0,1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">2</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><code>n = 2</code> since there are 2 numbers, so all numbers are in the range <code>[0,2]</code>. 2 is the missing number in the range since it does not appear in <code>nums</code>.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [9,6,4,2,3,5,7,0,1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">8</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><code>n = 9</code> since there are 9 numbers, so all numbers are in the range <code>[0,9]</code>. 8 is the missing number in the range since it does not appear in <code>nums</code>.</p>
+</div>
+
+<div class="simple-translate-system-theme" id="simple-translate">
+<div>
+<div class="simple-translate-button isShow" style="background-image: url(&quot;moz-extension://8a9ffb6b-7e69-4e93-aae1-436a1448eff6/icons/512.png&quot;); height: 22px; width: 22px; top: 318px; left: 36px;">&nbsp;</div>
+
+<div class="simple-translate-panel " style="width: 300px; height: 200px; top: 0px; left: 0px; font-size: 13px;">
+<div class="simple-translate-result-wrapper" style="overflow: hidden;">
+<div class="simple-translate-move" draggable="true">&nbsp;</div>
+
+<div class="simple-translate-result-contents">
+<p class="simple-translate-result" dir="auto">&nbsp;</p>
+
+<p class="simple-translate-candidate" dir="auto">&nbsp;</p>
+</div>
+</div>
+</div>
+</div>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= n</code></li>
+	<li>All the numbers of <code>nums</code> are <strong>unique</strong>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you implement a solution using only <code>O(1)</code> extra space complexity and <code>O(n)</code> runtime complexity?</p>
diff --git a/leetcode/leetcode/0283-move-zeroes/0283-move-zeroes.java b/leetcode/leetcode/0283-move-zeroes/0283-move-zeroes.java
new file mode 100644
index 0000000..189f83d
--- /dev/null
+++ b/leetcode/leetcode/0283-move-zeroes/0283-move-zeroes.java
@@ -0,0 +1,21 @@
+class Solution {
+    public void swap(int[] nums, int i, int j){
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+    public void moveZeroes(int[] nums) {
+        if(nums.length == 1) return;
+        int count = 0;
+        int indexToSwap = 0;
+        for(int i = 0;i<nums.length;i++){
+            if(nums[i] == 0) count++;
+            else{
+                swap(nums,i,indexToSwap);
+                indexToSwap++;
+            }
+        }
+        return;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0283-move-zeroes/NOTES.md b/leetcode/leetcode/0283-move-zeroes/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0283-move-zeroes/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0283-move-zeroes/README.md b/leetcode/leetcode/0283-move-zeroes/README.md
new file mode 100644
index 0000000..4867dc0
--- /dev/null
+++ b/leetcode/leetcode/0283-move-zeroes/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/move-zeroes/">283. Move Zeroes</a></h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code>, move all <code>0</code>'s to the end of it while maintaining the relative order of the non-zero elements.</p>
+
+<p><strong>Note</strong> that you must do this in-place without making a copy of the array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [0,1,0,3,12]
+<strong>Output:</strong> [1,3,12,0,0]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [0]
+<strong>Output:</strong> [0]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you minimize the total number of operations done?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0287-find-the-duplicate-number/0287-find-the-duplicate-number.java b/leetcode/leetcode/0287-find-the-duplicate-number/0287-find-the-duplicate-number.java
new file mode 100644
index 0000000..8decd49
--- /dev/null
+++ b/leetcode/leetcode/0287-find-the-duplicate-number/0287-find-the-duplicate-number.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int findDuplicate(int[] nums) {
+        for(int num: nums){
+            int index = Math.abs(num) - 1;
+            if(nums[index]<0) return index+1;
+            nums[index] = -nums[index];
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0287-find-the-duplicate-number/README.md b/leetcode/leetcode/0287-find-the-duplicate-number/README.md
new file mode 100644
index 0000000..ba4e856
--- /dev/null
+++ b/leetcode/leetcode/0287-find-the-duplicate-number/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/find-the-duplicate-number">287. Find the Duplicate Number</a></h2><h3>Medium</h3><hr><p>Given an array of integers <code>nums</code> containing&nbsp;<code>n + 1</code> integers where each integer is in the range <code>[1, n]</code> inclusive.</p>
+
+<p>There is only <strong>one repeated number</strong> in <code>nums</code>, return <em>this&nbsp;repeated&nbsp;number</em>.</p>
+
+<p>You must solve the problem <strong>without</strong> modifying the array <code>nums</code>&nbsp;and using only constant extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,3,4,2,2]
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,1,3,4,2]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,3,3,3,3]
+<strong>Output:</strong> 3</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums.length == n + 1</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= n</code></li>
+	<li>All the integers in <code>nums</code> appear only <strong>once</strong> except for <strong>precisely one integer</strong> which appears <strong>two or more</strong> times.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><b>Follow up:</b></p>
+
+<ul>
+	<li>How can we prove that at least one duplicate number must exist in <code>nums</code>?</li>
+	<li>Can you solve the problem in linear runtime complexity?</li>
+</ul>
diff --git a/leetcode/leetcode/0300-longest-increasing-subsequence/0300-longest-increasing-subsequence.java b/leetcode/leetcode/0300-longest-increasing-subsequence/0300-longest-increasing-subsequence.java
new file mode 100644
index 0000000..31dc936
--- /dev/null
+++ b/leetcode/leetcode/0300-longest-increasing-subsequence/0300-longest-increasing-subsequence.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        int n = nums.length;
+        int[] dp = new int[n];
+        dp[0] = 1;
+        for(int i = 1;i<n;i++){
+            dp[i] = 1;
+            for(int j = 0;j<i;j++){
+                if(nums[i]>nums[j]){
+                    dp[i] = Math.max(dp[i],dp[j]+1);
+                }
+            }
+        }
+        int ans =1;
+        for(int num: dp){
+            ans = Math.max(ans,num);
+        }
+        return ans;
+     }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0300-longest-increasing-subsequence/NOTES.md b/leetcode/leetcode/0300-longest-increasing-subsequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0300-longest-increasing-subsequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0300-longest-increasing-subsequence/README.md b/leetcode/leetcode/0300-longest-increasing-subsequence/README.md
new file mode 100644
index 0000000..598ddc0
--- /dev/null
+++ b/leetcode/leetcode/0300-longest-increasing-subsequence/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/longest-increasing-subsequence">300. Longest Increasing Subsequence</a></h2><h3>Medium</h3><hr><p>Given an integer array <code>nums</code>, return <em>the length of the longest <strong>strictly increasing </strong></em><span data-keyword="subsequence-array"><em><strong>subsequence</strong></em></span>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [10,9,2,5,3,7,101,18]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The longest increasing subsequence is [2,3,7,101], therefore the length is 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,1,0,3,2,3]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [7,7,7,7,7,7,7]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2500</code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><b>Follow up:</b>&nbsp;Can you come up with an algorithm that runs in&nbsp;<code>O(n log(n))</code> time complexity?</p>
diff --git a/leetcode/leetcode/0303-range-sum-query-immutable/0303-range-sum-query-immutable.java b/leetcode/leetcode/0303-range-sum-query-immutable/0303-range-sum-query-immutable.java
new file mode 100644
index 0000000..23f3216
--- /dev/null
+++ b/leetcode/leetcode/0303-range-sum-query-immutable/0303-range-sum-query-immutable.java
@@ -0,0 +1,22 @@
+class NumArray {
+    int[] prefixSum;
+
+    public NumArray(int[] nums) {
+        prefixSum = new int[nums.length];
+        prefixSum[0] = nums[0];
+        for(int i =1;i<nums.length;i++){
+            prefixSum[i] = prefixSum[i-1]+nums[i];
+        }
+    }
+    
+    public int sumRange(int left, int right) {
+        if(left == 0) return prefixSum[right];
+        return prefixSum[right] - prefixSum[left-1];
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * int param_1 = obj.sumRange(left,right);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/0303-range-sum-query-immutable/README.md b/leetcode/leetcode/0303-range-sum-query-immutable/README.md
new file mode 100644
index 0000000..5a7f2f7
--- /dev/null
+++ b/leetcode/leetcode/0303-range-sum-query-immutable/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/range-sum-query-immutable">303. Range Sum Query - Immutable</a></h2><h3>Easy</h3><hr><p>Given an integer array <code>nums</code>, handle multiple queries of the following type:</p>
+
+<ol>
+	<li>Calculate the <strong>sum</strong> of the elements of <code>nums</code> between indices <code>left</code> and <code>right</code> <strong>inclusive</strong> where <code>left &lt;= right</code>.</li>
+</ol>
+
+<p>Implement the <code>NumArray</code> class:</p>
+
+<ul>
+	<li><code>NumArray(int[] nums)</code> Initializes the object with the integer array <code>nums</code>.</li>
+	<li><code>int sumRange(int left, int right)</code> Returns the <strong>sum</strong> of the elements of <code>nums</code> between indices <code>left</code> and <code>right</code> <strong>inclusive</strong> (i.e. <code>nums[left] + nums[left + 1] + ... + nums[right]</code>).</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input</strong>
+[&quot;NumArray&quot;, &quot;sumRange&quot;, &quot;sumRange&quot;, &quot;sumRange&quot;]
+[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
+<strong>Output</strong>
+[null, 1, -1, -3]
+
+<strong>Explanation</strong>
+NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
+numArray.sumRange(0, 2); // return (-2) + 0 + 3 = 1
+numArray.sumRange(2, 5); // return 3 + (-5) + 2 + (-1) = -1
+numArray.sumRange(0, 5); // return (-2) + 0 + 3 + (-5) + 2 + (-1) = -3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>5</sup> &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= left &lt;= right &lt; nums.length</code></li>
+	<li>At most <code>10<sup>4</sup></code> calls will be made to <code>sumRange</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0322-coin-change/0322-coin-change.java b/leetcode/leetcode/0322-coin-change/0322-coin-change.java
new file mode 100644
index 0000000..0d728ee
--- /dev/null
+++ b/leetcode/leetcode/0322-coin-change/0322-coin-change.java
@@ -0,0 +1,38 @@
+class Solution {
+    
+    public int coinChange(int[] coins, int amount, int index, int[][] dp){
+        if(amount == 0) return 0;
+        if(index>=coins.length) return -1;
+        if(dp[amount][index] != -2) return dp[amount][index];
+        int ans = Integer.MAX_VALUE;
+        if(coins[index]<=amount){
+            int temp  = coinChange(coins,amount-coins[index],index,dp);
+            int temp3 = coinChange(coins,amount,index+1,dp);
+            if(temp == -1 && temp3 == -1) ans = -1;
+            else{
+                if(temp == -1) ans = temp3;
+                else if(temp3 == -1) ans = temp + 1;
+                else ans = Math.min(1+temp,temp3);
+                
+                
+            }
+        }else{
+            ans = coinChange(coins,amount,index+1,dp);
+        }
+        dp[amount][index] = ans;
+        return ans;
+        
+
+    }
+
+    public int coinChange(int[] coins, int amount) {
+        int n = coins.length;
+        int[][] dp = new int[amount+1][n];
+        for(int i = 0;i<amount+1;i++){
+            for(int j = 0;j<n;j++){
+                dp[i][j] = -2;
+            }
+        }
+        return coinChange(coins, amount, 0,dp);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0322-coin-change/README.md b/leetcode/leetcode/0322-coin-change/README.md
new file mode 100644
index 0000000..f31f965
--- /dev/null
+++ b/leetcode/leetcode/0322-coin-change/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/coin-change">322. Coin Change</a></h2><h3>Medium</h3><hr><p>You are given an integer array <code>coins</code> representing coins of different denominations and an integer <code>amount</code> representing a total amount of money.</p>
+
+<p>Return <em>the fewest number of coins that you need to make up that amount</em>. If that amount of money cannot be made up by any combination of the coins, return <code>-1</code>.</p>
+
+<p>You may assume that you have an infinite number of each kind of coin.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> coins = [1,2,5], amount = 11
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 11 = 5 + 5 + 1
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> coins = [2], amount = 3
+<strong>Output:</strong> -1
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> coins = [1], amount = 0
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= coins.length &lt;= 12</code></li>
+	<li><code>1 &lt;= coins[i] &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>0 &lt;= amount &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0326-power-of-three/0326-power-of-three.java b/leetcode/leetcode/0326-power-of-three/0326-power-of-three.java
new file mode 100644
index 0000000..de32f8a
--- /dev/null
+++ b/leetcode/leetcode/0326-power-of-three/0326-power-of-three.java
@@ -0,0 +1,11 @@
+class Solution {
+    public boolean isPowerOfThree(int n) {
+        if(n<=0) return false;
+        if(n==1) return true;
+        while(n!=1){
+            if(n%3!=0) return false;
+            n/=3;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0326-power-of-three/README.md b/leetcode/leetcode/0326-power-of-three/README.md
new file mode 100644
index 0000000..bb5baa8
--- /dev/null
+++ b/leetcode/leetcode/0326-power-of-three/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/power-of-three">326. Power of Three</a></h2><h3>Easy</h3><hr><p>Given an integer <code>n</code>, return <em><code>true</code> if it is a power of three. Otherwise, return <code>false</code></em>.</p>
+
+<p>An integer <code>n</code> is a power of three, if there exists an integer <code>x</code> such that <code>n == 3<sup>x</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 27
+<strong>Output:</strong> true
+<strong>Explanation:</strong> 27 = 3<sup>3</sup>
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 0
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There is no x where 3<sup>x</sup> = 0.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = -1
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There is no x where 3<sup>x</sup> = (-1).
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you solve it without loops/recursion?
\ No newline at end of file
diff --git a/leetcode/leetcode/0328-odd-even-linked-list/0328-odd-even-linked-list.cpp b/leetcode/leetcode/0328-odd-even-linked-list/0328-odd-even-linked-list.cpp
new file mode 100644
index 0000000..874d13c
--- /dev/null
+++ b/leetcode/leetcode/0328-odd-even-linked-list/0328-odd-even-linked-list.cpp
@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* oddEvenList(ListNode* head) {
+        if(!head || !head->next) return head;
+        ListNode *even=head->next,*odd=head,*temp=even;
+        while(odd->next && odd->next->next){
+            ListNode *nodd=even?even->next:nullptr;
+            ListNode *neven=nodd?nodd->next:nullptr;
+            if(even)
+            even->next=neven;
+            if(odd)
+            odd->next=nodd;
+            even=neven;
+            odd=nodd;
+        }
+        odd->next=temp;
+        return head;
+    }
+};
\ No newline at end of file
diff --git a/leetcode/leetcode/0328-odd-even-linked-list/README.md b/leetcode/leetcode/0328-odd-even-linked-list/README.md
new file mode 100644
index 0000000..6e8419b
--- /dev/null
+++ b/leetcode/leetcode/0328-odd-even-linked-list/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/odd-even-linked-list">328. Odd Even Linked List</a></h2><h3>Medium</h3><hr><p>Given the <code>head</code> of a singly linked list, group all the nodes with odd indices together followed by the nodes with even indices, and return <em>the reordered list</em>.</p>
+
+<p>The <strong>first</strong> node is considered <strong>odd</strong>, and the <strong>second</strong> node is <strong>even</strong>, and so on.</p>
+
+<p>Note that the relative order inside both the even and odd groups should remain as it was in the input.</p>
+
+<p>You must solve the problem&nbsp;in <code>O(1)</code>&nbsp;extra space complexity and <code>O(n)</code> time complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/10/oddeven-linked-list.jpg" style="width: 300px; height: 123px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5]
+<strong>Output:</strong> [1,3,5,2,4]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/10/oddeven2-linked-list.jpg" style="width: 500px; height: 142px;" />
+<pre>
+<strong>Input:</strong> head = [2,1,3,5,6,4,7]
+<strong>Output:</strong> [2,3,6,7,1,5,4]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the linked list is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>6</sup> &lt;= Node.val &lt;= 10<sup>6</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0334-increasing-triplet-subsequence/0334-increasing-triplet-subsequence.java b/leetcode/leetcode/0334-increasing-triplet-subsequence/0334-increasing-triplet-subsequence.java
new file mode 100644
index 0000000..f1b2a89
--- /dev/null
+++ b/leetcode/leetcode/0334-increasing-triplet-subsequence/0334-increasing-triplet-subsequence.java
@@ -0,0 +1,24 @@
+class Solution {
+    public boolean increasingTriplet(int[] nums) {
+        if(nums.length<3) return false;
+        int maxAfterThat[] = new int[nums.length];
+        int minBeforeThat[] = new int[nums.length];
+        int min ;
+        int max;
+        max = maxAfterThat[nums.length-1] = nums[nums.length-1];
+        min = minBeforeThat[0] = nums[0];
+        for(int i = nums.length-2;i!=-1;i--){
+            max = Math.max(max,nums[i]);
+            maxAfterThat[i] = max;
+            min = Math.min(min,nums[nums.length - i-1]);
+            minBeforeThat[nums.length-i-1] = min;
+        }
+        for(int i = 1;i<nums.length-1;i++){
+            if(minBeforeThat[i]<nums[i] && nums[i]<maxAfterThat[i]){
+                return true;
+            }
+        }
+        return false;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0334-increasing-triplet-subsequence/NOTES.md b/leetcode/leetcode/0334-increasing-triplet-subsequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0334-increasing-triplet-subsequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0334-increasing-triplet-subsequence/README.md b/leetcode/leetcode/0334-increasing-triplet-subsequence/README.md
new file mode 100644
index 0000000..261895c
--- /dev/null
+++ b/leetcode/leetcode/0334-increasing-triplet-subsequence/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/increasing-triplet-subsequence/">334. Increasing Triplet Subsequence</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, return <code>true</code><em> if there exists a triple of indices </em><code>(i, j, k)</code><em> such that </em><code>i &lt; j &lt; k</code><em> and </em><code>nums[i] &lt; nums[j] &lt; nums[k]</code>. If no such indices exists, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,5]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Any triplet where i &lt; j &lt; k is valid.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [5,4,3,2,1]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> No triplet exists.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,1,5,0,4,6]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The triplet (3, 4, 5) is valid because nums[3] == 0 &lt; nums[4] == 4 &lt; nums[5] == 6.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 5 * 10<sup>5</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you implement a solution that runs in <code>O(n)</code> time complexity and <code>O(1)</code> space complexity?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0337-house-robber-iii/0337-house-robber-iii.java b/leetcode/leetcode/0337-house-robber-iii/0337-house-robber-iii.java
new file mode 100644
index 0000000..4258c15
--- /dev/null
+++ b/leetcode/leetcode/0337-house-robber-iii/0337-house-robber-iii.java
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int[] helper(TreeNode root){
+        if(root==null){
+            int[] ans = {0,0};
+            return ans;
+        }
+        int[] left = helper(root.left);
+        int[] right = helper(root.right);
+        int[] ans = {0,0};
+        ans[0] = root.val + left[1] + right[1];
+        ans[1] = Math.max(left[0],left[1]) + Math.max(right[0],right[1]);
+        return ans;
+    }
+    public int rob(TreeNode root) {
+        int[] ans = helper(root);
+        return Math.max(ans[0],ans[1]);
+       
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0337-house-robber-iii/README.md b/leetcode/leetcode/0337-house-robber-iii/README.md
new file mode 100644
index 0000000..e63c52a
--- /dev/null
+++ b/leetcode/leetcode/0337-house-robber-iii/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/house-robber-iii">337. House Robber III</a></h2><h3>Medium</h3><hr><p>The thief has found himself a new place for his thievery again. There is only one entrance to this area, called <code>root</code>.</p>
+
+<p>Besides the <code>root</code>, each house has one and only one parent house. After a tour, the smart thief realized that all houses in this place form a binary tree. It will automatically contact the police if <strong>two directly-linked houses were broken into on the same night</strong>.</p>
+
+<p>Given the <code>root</code> of the binary tree, return <em>the maximum amount of money the thief can rob <strong>without alerting the police</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/10/rob1-tree.jpg" style="width: 277px; height: 293px;" />
+<pre>
+<strong>Input:</strong> root = [3,2,3,null,3,null,1]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/10/rob2-tree.jpg" style="width: 357px; height: 293px;" />
+<pre>
+<strong>Input:</strong> root = [3,4,5,1,3,null,1]
+<strong>Output:</strong> 9
+<strong>Explanation:</strong> Maximum amount of money the thief can rob = 4 + 5 = 9.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0338-counting-bits/0338-counting-bits.java b/leetcode/leetcode/0338-counting-bits/0338-counting-bits.java
new file mode 100644
index 0000000..c26306b
--- /dev/null
+++ b/leetcode/leetcode/0338-counting-bits/0338-counting-bits.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int[] countBits(int n) {
+        int[] ans = new int[n+1];
+        ans[0] = 0;
+        for(int i = 1;i<=n;i++){
+            ans[i] = ans[i>>1]+(i%2);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0338-counting-bits/README.md b/leetcode/leetcode/0338-counting-bits/README.md
new file mode 100644
index 0000000..49b28d8
--- /dev/null
+++ b/leetcode/leetcode/0338-counting-bits/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/counting-bits">338. Counting Bits</a></h2><h3>Easy</h3><hr><p>Given an integer <code>n</code>, return <em>an array </em><code>ans</code><em> of length </em><code>n + 1</code><em> such that for each </em><code>i</code><em> </em>(<code>0 &lt;= i &lt;= n</code>)<em>, </em><code>ans[i]</code><em> is the <strong>number of </strong></em><code>1</code><em><strong>&#39;s</strong> in the binary representation of </em><code>i</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 2
+<strong>Output:</strong> [0,1,1]
+<strong>Explanation:</strong>
+0 --&gt; 0
+1 --&gt; 1
+2 --&gt; 10
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 5
+<strong>Output:</strong> [0,1,1,2,1,2]
+<strong>Explanation:</strong>
+0 --&gt; 0
+1 --&gt; 1
+2 --&gt; 10
+3 --&gt; 11
+4 --&gt; 100
+5 --&gt; 101
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>It is very easy to come up with a solution with a runtime of <code>O(n log n)</code>. Can you do it in linear time <code>O(n)</code> and possibly in a single pass?</li>
+	<li>Can you do it without using any built-in function (i.e., like <code>__builtin_popcount</code> in C++)?</li>
+</ul>
diff --git a/leetcode/leetcode/0342-power-of-four/0342-power-of-four.java b/leetcode/leetcode/0342-power-of-four/0342-power-of-four.java
new file mode 100644
index 0000000..7d2c53f
--- /dev/null
+++ b/leetcode/leetcode/0342-power-of-four/0342-power-of-four.java
@@ -0,0 +1,11 @@
+class Solution {
+    public boolean isPowerOfFour(int n) {
+        if(n==1) return true;
+        if(n<=0 || n%4 !=0) return false;
+        
+        while(n%4==0){
+            n = n/4;
+        } 
+        return n==1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0342-power-of-four/README.md b/leetcode/leetcode/0342-power-of-four/README.md
new file mode 100644
index 0000000..151e06f
--- /dev/null
+++ b/leetcode/leetcode/0342-power-of-four/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/power-of-four">342. Power of Four</a></h2><h3>Easy</h3><hr><p>Given an integer <code>n</code>, return <em><code>true</code> if it is a power of four. Otherwise, return <code>false</code></em>.</p>
+
+<p>An integer <code>n</code> is a power of four, if there exists an integer <code>x</code> such that <code>n == 4<sup>x</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 16
+<strong>Output:</strong> true
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> false
+</pre><p><strong class="example">Example 3:</strong></p>
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> true
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you solve it without loops/recursion?
\ No newline at end of file
diff --git a/leetcode/leetcode/0345-reverse-vowels-of-a-string/0345-reverse-vowels-of-a-string.java b/leetcode/leetcode/0345-reverse-vowels-of-a-string/0345-reverse-vowels-of-a-string.java
new file mode 100644
index 0000000..cd97906
--- /dev/null
+++ b/leetcode/leetcode/0345-reverse-vowels-of-a-string/0345-reverse-vowels-of-a-string.java
@@ -0,0 +1,31 @@
+class Solution {
+    public String reverseVowels(String s) {
+        if(s.length()==1) return s;
+        List<Integer> list = new ArrayList<>();
+        for(int i = 0;i<s.length();i++){
+            if(s.charAt(i) == 'a' || s.charAt(i) == 'e' || s.charAt(i) == 'i' ||s.charAt(i) == 'o' ||s.charAt(i) == 'u' ||
+              s.charAt(i) == 'A' || s.charAt(i) == 'E' || s.charAt(i) == 'I' ||s.charAt(i) == 'O' ||s.charAt(i) == 'U'){
+                list.add(i);
+            }
+        }
+        if(list.size()<=1) return s;
+        Collections.reverse(list);
+        StringBuilder sb = new StringBuilder();
+        int index = 0;
+        int low = list.get(index);
+        int high = list.get(list.size()-1);
+        for(int i = 0;i<s.length();i++){
+            if(index!=list.size()){
+                low = list.get(index);
+                high = list.get(list.size()-1-index);
+            }
+            if(i!= high){
+                sb.append(s.charAt(i));
+            }else{
+                sb.append(s.charAt(low));
+                index++;
+            }
+        }
+        return sb.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0345-reverse-vowels-of-a-string/README.md b/leetcode/leetcode/0345-reverse-vowels-of-a-string/README.md
new file mode 100644
index 0000000..5fb835d
--- /dev/null
+++ b/leetcode/leetcode/0345-reverse-vowels-of-a-string/README.md
@@ -0,0 +1,20 @@
+<h2><a href="https://leetcode.com/problems/reverse-vowels-of-a-string/">345. Reverse Vowels of a String</a></h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code>, reverse only all the vowels in the string and return it.</p>
+
+<p>The vowels are <code>'a'</code>, <code>'e'</code>, <code>'i'</code>, <code>'o'</code>, and <code>'u'</code>, and they can appear in both lower and upper cases, more than once.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "hello"
+<strong>Output:</strong> "holle"
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "leetcode"
+<strong>Output:</strong> "leotcede"
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 3 * 10<sup>5</sup></code></li>
+	<li><code>s</code> consist of <strong>printable ASCII</strong> characters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0347-top-k-frequent-elements/0347-top-k-frequent-elements.java b/leetcode/leetcode/0347-top-k-frequent-elements/0347-top-k-frequent-elements.java
new file mode 100644
index 0000000..b379f74
--- /dev/null
+++ b/leetcode/leetcode/0347-top-k-frequent-elements/0347-top-k-frequent-elements.java
@@ -0,0 +1,36 @@
+
+
+// Approach - 1: HashMap with Priority queue
+
+class Solution {
+    public class Node implements Comparable<Node>{
+        int num;
+        int frequency;
+        Node(int num, int frequency){
+            this.num       = num;
+            this.frequency = frequency;
+        }
+        @Override
+        public int compareTo(Node node){
+            return Integer.compare(this.frequency,node.frequency);
+        }
+    }
+    public int[] topKFrequent(int[] nums, int k) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: nums){
+            map.put(num, map.getOrDefault(num,0)+1);
+        }
+        PriorityQueue<Node> pq = new PriorityQueue<>();
+        for (Map.Entry<Integer,Integer> mapElement : map.entrySet()){
+            pq.add(new Node(mapElement.getKey(),mapElement.getValue()));
+            if(pq.size()>k) pq.remove();
+        }
+        int[] ans = new int[k];
+        for(int i =0;i<k;i++){
+            ans[i] = pq.remove().num;
+        }
+        return ans;
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0347-top-k-frequent-elements/README.md b/leetcode/leetcode/0347-top-k-frequent-elements/README.md
new file mode 100644
index 0000000..71a7402
--- /dev/null
+++ b/leetcode/leetcode/0347-top-k-frequent-elements/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/top-k-frequent-elements">347. Top K Frequent Elements</a></h2><h3>Medium</h3><hr><p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <em>the</em> <code>k</code> <em>most frequent elements</em>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,1,2,2,3], k = 2
+<strong>Output:</strong> [1,2]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1], k = 1
+<strong>Output:</strong> [1]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+	<li><code>k</code> is in the range <code>[1, the number of unique elements in the array]</code>.</li>
+	<li>It is <strong>guaranteed</strong> that the answer is <strong>unique</strong>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Your algorithm&#39;s time complexity must be better than <code>O(n log n)</code>, where n is the array&#39;s size.</p>
diff --git a/leetcode/leetcode/0350-intersection-of-two-arrays-ii/0350-intersection-of-two-arrays-ii.java b/leetcode/leetcode/0350-intersection-of-two-arrays-ii/0350-intersection-of-two-arrays-ii.java
new file mode 100644
index 0000000..d019f85
--- /dev/null
+++ b/leetcode/leetcode/0350-intersection-of-two-arrays-ii/0350-intersection-of-two-arrays-ii.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int[] intersect(int[] nums1, int[] nums2) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: nums1){
+            map.put(num,map.getOrDefault(num,0)+1);
+        }
+        ArrayList<Integer> ans = new ArrayList<>();
+        for(int num: nums2){
+            if(map.getOrDefault(num,0)!=0){
+                ans.add(num);
+                map.put(num,map.get(num)-1);
+            }
+        }
+                
+        int[] arr = ans.stream().mapToInt(i -> i).toArray();
+        return arr;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0350-intersection-of-two-arrays-ii/NOTES.md b/leetcode/leetcode/0350-intersection-of-two-arrays-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0350-intersection-of-two-arrays-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0350-intersection-of-two-arrays-ii/README.md b/leetcode/leetcode/0350-intersection-of-two-arrays-ii/README.md
new file mode 100644
index 0000000..20f1306
--- /dev/null
+++ b/leetcode/leetcode/0350-intersection-of-two-arrays-ii/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/intersection-of-two-arrays-ii/">350. Intersection of Two Arrays II</a></h2><h3>Easy</h3><hr><div><p>Given two integer arrays <code>nums1</code> and <code>nums2</code>, return <em>an array of their intersection</em>. Each element in the result must appear as many times as it shows in both arrays and you may return the result in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2,2,1], nums2 = [2,2]
+<strong>Output:</strong> [2,2]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+<strong>Output:</strong> [4,9]
+<strong>Explanation:</strong> [9,4] is also accepted.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums1.length, nums2.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums1[i], nums2[i] &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>What if the given array is already sorted? How would you optimize your algorithm?</li>
+	<li>What if <code>nums1</code>'s size is small compared to <code>nums2</code>'s size? Which algorithm is better?</li>
+	<li>What if elements of <code>nums2</code> are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0374-guess-number-higher-or-lower/0374-guess-number-higher-or-lower.java b/leetcode/leetcode/0374-guess-number-higher-or-lower/0374-guess-number-higher-or-lower.java
new file mode 100644
index 0000000..b673d23
--- /dev/null
+++ b/leetcode/leetcode/0374-guess-number-higher-or-lower/0374-guess-number-higher-or-lower.java
@@ -0,0 +1,26 @@
+/** 
+ * Forward declaration of guess API.
+ * @param  num   your guess
+ * @return 	     -1 if num is higher than the picked number
+ *			      1 if num is lower than the picked number
+ *               otherwise return 0
+ * int guess(int num);
+ */
+
+public class Solution extends GuessGame {
+    public int guessNumber(int n) {
+        int low = 0;
+        int high = n;
+        while(low<=high){
+            int mid = (int)(low+(high-low)/2);
+            int isMid = guess(mid);
+            if(isMid==0) return mid;
+            else if(isMid==1){
+                low = mid+1;
+            } else{
+                high = mid -1;
+            }
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0374-guess-number-higher-or-lower/README.md b/leetcode/leetcode/0374-guess-number-higher-or-lower/README.md
new file mode 100644
index 0000000..3dd24cd
--- /dev/null
+++ b/leetcode/leetcode/0374-guess-number-higher-or-lower/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/guess-number-higher-or-lower">374. Guess Number Higher or Lower</a></h2><h3>Easy</h3><hr><p>We are playing the Guess Game. The game is as follows:</p>
+
+<p>I pick a number from <code>1</code> to <code>n</code>. You have to guess which number I picked.</p>
+
+<p>Every time you guess wrong, I will tell you whether the number I picked is higher or lower than your guess.</p>
+
+<p>You call a pre-defined API <code>int guess(int num)</code>, which returns three possible results:</p>
+
+<ul>
+	<li><code>-1</code>: Your guess is higher than the number I picked (i.e. <code>num &gt; pick</code>).</li>
+	<li><code>1</code>: Your guess is lower than the number I picked (i.e. <code>num &lt; pick</code>).</li>
+	<li><code>0</code>: your guess is equal to the number I picked (i.e. <code>num == pick</code>).</li>
+</ul>
+
+<p>Return <em>the number that I picked</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 10, pick = 6
+<strong>Output:</strong> 6
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 1, pick = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 2, pick = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>1 &lt;= pick &lt;= n</code></li>
+</ul>
diff --git a/leetcode/leetcode/0380-insert-delete-getrandom-o1/README.md b/leetcode/leetcode/0380-insert-delete-getrandom-o1/README.md
new file mode 100644
index 0000000..fc1cda7
--- /dev/null
+++ b/leetcode/leetcode/0380-insert-delete-getrandom-o1/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/insert-delete-getrandom-o1/">380. Insert Delete GetRandom O(1)</a></h2><h3>Medium</h3><hr><div><p>Implement the <code>RandomizedSet</code> class:</p>
+
+<ul>
+	<li><code>RandomizedSet()</code> Initializes the <code>RandomizedSet</code> object.</li>
+	<li><code>bool insert(int val)</code> Inserts an item <code>val</code> into the set if not present. Returns <code>true</code> if the item was not present, <code>false</code> otherwise.</li>
+	<li><code>bool remove(int val)</code> Removes an item <code>val</code> from the set if present. Returns <code>true</code> if the item was present, <code>false</code> otherwise.</li>
+	<li><code>int getRandom()</code> Returns a random element from the current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the <b>same probability</b> of being returned.</li>
+</ul>
+
+<p>You must implement the functions of the class such that each function works in&nbsp;<strong>average</strong>&nbsp;<code>O(1)</code>&nbsp;time complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
+[[], [1], [2], [2], [], [1], [2], []]
+<strong>Output</strong>
+[null, true, false, true, 2, true, false, 2]
+
+<strong>Explanation</strong>
+RandomizedSet randomizedSet = new RandomizedSet();
+randomizedSet.insert(1); // Inserts 1 to the set. Returns true as 1 was inserted successfully.
+randomizedSet.remove(2); // Returns false as 2 does not exist in the set.
+randomizedSet.insert(2); // Inserts 2 to the set, returns true. Set now contains [1,2].
+randomizedSet.getRandom(); // getRandom() should return either 1 or 2 randomly.
+randomizedSet.remove(1); // Removes 1 from the set, returns true. Set now contains [2].
+randomizedSet.insert(2); // 2 was already in the set, so return false.
+randomizedSet.getRandom(); // Since 2 is the only number in the set, getRandom() will always return 2.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= val &lt;= 2<sup>31</sup> - 1</code></li>
+	<li>At most <code>2 *&nbsp;</code><code>10<sup>5</sup></code> calls will be made to <code>insert</code>, <code>remove</code>, and <code>getRandom</code>.</li>
+	<li>There will be <strong>at least one</strong> element in the data structure when <code>getRandom</code> is called.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0386-lexicographical-numbers/0386-lexicographical-numbers.java b/leetcode/leetcode/0386-lexicographical-numbers/0386-lexicographical-numbers.java
new file mode 100644
index 0000000..3a415fd
--- /dev/null
+++ b/leetcode/leetcode/0386-lexicographical-numbers/0386-lexicographical-numbers.java
@@ -0,0 +1,21 @@
+class Solution {
+    public List<Integer> lexicalOrder(int n) {
+        List<Integer> result = new ArrayList<>();
+        for(int i = 1;i<=9;i++){
+            generate(result,i,n);
+        }
+        return result;
+    }
+    public void generate(List<Integer> result, int current, int limit){
+        if(current>limit) return;
+        result.add(current);
+        for(int nextDigit = 0;nextDigit<=9;nextDigit++){
+            int nextNumber = current * 10 + nextDigit;
+            if(nextNumber<=limit){
+                generate(result, nextNumber, limit);
+            }else{
+                break;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0386-lexicographical-numbers/README.md b/leetcode/leetcode/0386-lexicographical-numbers/README.md
new file mode 100644
index 0000000..075d992
--- /dev/null
+++ b/leetcode/leetcode/0386-lexicographical-numbers/README.md
@@ -0,0 +1,19 @@
+<h2><a href="https://leetcode.com/problems/lexicographical-numbers/">386. Lexicographical Numbers</a></h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, return all the numbers in the range <code>[1, n]</code> sorted in lexicographical order.</p>
+
+<p>You must write an algorithm that runs in&nbsp;<code>O(n)</code>&nbsp;time and uses <code>O(1)</code> extra space.&nbsp;</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 13
+<strong>Output:</strong> [1,10,11,12,13,2,3,4,5,6,7,8,9]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> [1,2]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 5 * 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0392-is-subsequence/0392-is-subsequence.java b/leetcode/leetcode/0392-is-subsequence/0392-is-subsequence.java
new file mode 100644
index 0000000..a9d5518
--- /dev/null
+++ b/leetcode/leetcode/0392-is-subsequence/0392-is-subsequence.java
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean isSubsequence(String s, String t) {
+        if(t.length()<s.length()) return false;
+        if(s.length()==0) return true;
+        int current = 0;
+        int tIndex  = 0;
+        while(tIndex<t.length()){
+            if(current==s.length()) break;
+            if(s.charAt(current)==t.charAt(tIndex)){
+                current++;
+                tIndex++;
+                continue;
+            }
+            tIndex++;
+        }
+        return current==s.length();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0392-is-subsequence/NOTES.md b/leetcode/leetcode/0392-is-subsequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0392-is-subsequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0392-is-subsequence/README.md b/leetcode/leetcode/0392-is-subsequence/README.md
new file mode 100644
index 0000000..56e9b40
--- /dev/null
+++ b/leetcode/leetcode/0392-is-subsequence/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/is-subsequence/">392. Is Subsequence</a></h2><h3>Easy</h3><hr><div><p>Given two strings <code>s</code> and <code>t</code>, return <code>true</code><em> if </em><code>s</code><em> is a <strong>subsequence</strong> of </em><code>t</code><em>, or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>A <strong>subsequence</strong> of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., <code>"ace"</code> is a subsequence of <code>"<u>a</u>b<u>c</u>d<u>e</u>"</code> while <code>"aec"</code> is not).</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "abc", t = "ahbgdc"
+<strong>Output:</strong> true
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "axc", t = "ahbgdc"
+<strong>Output:</strong> false
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length &lt;= 100</code></li>
+	<li><code>0 &lt;= t.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Suppose there are lots of incoming <code>s</code>, say <code>s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub></code> where <code>k &gt;= 10<sup>9</sup></code>, and you want to check one by one to see if <code>t</code> has its subsequence. In this scenario, how would you change your code?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0402-remove-k-digits/0402-remove-k-digits.java b/leetcode/leetcode/0402-remove-k-digits/0402-remove-k-digits.java
new file mode 100644
index 0000000..1015084
--- /dev/null
+++ b/leetcode/leetcode/0402-remove-k-digits/0402-remove-k-digits.java
@@ -0,0 +1,36 @@
+class Solution { 
+    public String removeKdigits(String num, int k) {
+        if(k ==  num.length()) return "0";
+        Stack<Character> s = new Stack<>();
+        for(int i = 0;i<num.length();i++){
+            while(!s.isEmpty() && k>0 && s.peek() > num.charAt(i) ){
+                s.pop();
+                k--;
+            }
+            s.push(num.charAt(i));
+        }
+
+        while(!s.isEmpty() && k>0 ){
+            s.pop();
+            k--;
+        }
+        StringBuilder sb = new StringBuilder();
+
+        // for(char ch: s){
+        //     sb.append(ch);
+        // }
+
+        while(!s.isEmpty()){
+            sb.append(s.pop());
+        }
+        sb.reverse();
+        
+        while(sb.length()>0 && sb.charAt(0) == '0'){
+            sb.deleteCharAt(0);
+        }
+
+        return sb.length() == 0 ? "0" : sb.toString();
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0402-remove-k-digits/README.md b/leetcode/leetcode/0402-remove-k-digits/README.md
new file mode 100644
index 0000000..eaaadea
--- /dev/null
+++ b/leetcode/leetcode/0402-remove-k-digits/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/remove-k-digits">402. Remove K Digits</a></h2><h3>Medium</h3><hr><p>Given string num representing a non-negative integer <code>num</code>, and an integer <code>k</code>, return <em>the smallest possible integer after removing</em> <code>k</code> <em>digits from</em> <code>num</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> num = &quot;1432219&quot;, k = 3
+<strong>Output:</strong> &quot;1219&quot;
+<strong>Explanation:</strong> Remove the three digits 4, 3, and 2 to form the new number 1219 which is the smallest.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> num = &quot;10200&quot;, k = 1
+<strong>Output:</strong> &quot;200&quot;
+<strong>Explanation:</strong> Remove the leading 1 and the number is 200. Note that the output must not contain leading zeroes.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> num = &quot;10&quot;, k = 2
+<strong>Output:</strong> &quot;0&quot;
+<strong>Explanation:</strong> Remove all the digits from the number and it is left with nothing which is 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= num.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>num</code> consists of only digits.</li>
+	<li><code>num</code> does not have any leading zeros except for the zero itself.</li>
+</ul>
diff --git a/leetcode/leetcode/0404-sum-of-left-leaves/0404-sum-of-left-leaves.java b/leetcode/leetcode/0404-sum-of-left-leaves/0404-sum-of-left-leaves.java
new file mode 100644
index 0000000..eff7875
--- /dev/null
+++ b/leetcode/leetcode/0404-sum-of-left-leaves/0404-sum-of-left-leaves.java
@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    int ans = 0;
+
+    public void helper(TreeNode root){
+        if(root == null) return;
+
+        if(root.left!=null){
+            if(root.left.left == null && root.left.right == null) ans+=root.left.val;
+        }
+        helper(root.left);
+        helper(root.right);
+    }
+    public int sumOfLeftLeaves(TreeNode root) {
+        helper(root);
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0404-sum-of-left-leaves/README.md b/leetcode/leetcode/0404-sum-of-left-leaves/README.md
new file mode 100644
index 0000000..ac38605
--- /dev/null
+++ b/leetcode/leetcode/0404-sum-of-left-leaves/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/sum-of-left-leaves">404. Sum of Left Leaves</a></h2><h3>Easy</h3><hr><p>Given the <code>root</code> of a binary tree, return <em>the sum of all left leaves.</em></p>
+
+<p>A <strong>leaf</strong> is a node with no children. A <strong>left leaf</strong> is a leaf that is the left child of another node.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/04/08/leftsum-tree.jpg" style="width: 277px; height: 302px;" />
+<pre>
+<strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> 24
+<strong>Explanation:</strong> There are two left leaves in the binary tree, with values 9 and 15 respectively.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [1]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 1000]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/0416-partition-equal-subset-sum/0416-partition-equal-subset-sum.java b/leetcode/leetcode/0416-partition-equal-subset-sum/0416-partition-equal-subset-sum.java
new file mode 100644
index 0000000..f477246
--- /dev/null
+++ b/leetcode/leetcode/0416-partition-equal-subset-sum/0416-partition-equal-subset-sum.java
@@ -0,0 +1,76 @@
+// Approach: 1 Recurssion TLE
+// class Solution {
+//     public boolean findSum(int[] nums, int size, long sum){
+//         if(size<1) return false;
+//         if(size == 1){
+//             if(sum == nums[size-1]) return true;
+//             return false;
+//         }
+//         return findSum(nums,size-1,sum) || findSum(nums,size-1,sum-nums[size-1]);
+//     }
+//     public boolean canPartition(int[] nums) {
+//         long sum = 0;
+//         for(int num: nums) sum+=num;
+//         if(sum % 2 != 0) return false;
+//         sum = sum/2;
+//         return findSum(nums, nums.length,sum);       
+//     }
+// }
+
+// Approach 2: Memoization
+// class Solution {
+//     public boolean findSum(int[] nums, int[][] memo, int size, int sum){
+//         if(size<1 || sum<0) return false;
+//         if(size == 1){
+//             if(sum == nums[size-1]) return true;
+//             return false;
+//         }
+//         if(memo[size][sum] != -1) return (memo[size][sum] == 1);
+//         if(findSum(nums,memo,size-1,sum) || findSum(nums,memo,size-1,sum-nums[size-1])){
+//             memo[size][sum] = 1;
+//         }else{
+//             memo[size][sum] = 0;
+//         }
+//         return memo[size][sum] == 1;
+//     }
+//     public boolean canPartition(int[] nums) {
+//         long sum = 0;
+//         for(int num: nums) sum+=num;
+//         if(sum % 2 != 0) return false;
+//         sum = sum/2;
+//         int[][] memo = new int[nums.length+1][(int) sum+1];
+//         for(int i = 0;i<memo.length;i++){
+//             for(int j = 0;j<memo[0].length;j++){
+//                 memo[i][j] = -1;
+//             }
+//         }
+//         return findSum(nums,memo, nums.length,(int) sum);      
+//     }
+// }
+
+// Approach 3: DP
+class Solution {
+    public boolean canPartition(int[] nums) {
+        int sum = 0;
+        for(int num: nums) sum+=num;
+        if(sum % 2 != 0) return false;
+        sum = sum/2;
+        boolean[][] dp = new boolean[nums.length+1][sum+1];
+
+        for(int i = 1;i<=nums.length;i++){
+            for(int j = 0;j<=sum;j++){
+                if(i == 1){
+                    if(j == nums[i-1]) dp[i][j] = true;
+                    else dp[i-1][j] = false;
+                }else{
+                    dp[i][j] = dp[i-1][j];
+                    if(dp[i][j] == false && j-nums[i-1]>0){
+                        dp[i][j] = dp[i-1][j-nums[i-1]];
+                    } 
+                }
+            }
+        }
+        return dp[nums.length][sum];
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0416-partition-equal-subset-sum/README.md b/leetcode/leetcode/0416-partition-equal-subset-sum/README.md
new file mode 100644
index 0000000..6928b40
--- /dev/null
+++ b/leetcode/leetcode/0416-partition-equal-subset-sum/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/partition-equal-subset-sum">416. Partition Equal Subset Sum</a></h2><h3>Medium</h3><hr><p>Given an integer array <code>nums</code>, return <code>true</code> <em>if you can partition the array into two subsets such that the sum of the elements in both subsets is equal or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,5,11,5]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The array can be partitioned as [1, 5, 5] and [11].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,5]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The array cannot be partitioned into equal sum subsets.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 200</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0424-longest-repeating-character-replacement/0424-longest-repeating-character-replacement.java b/leetcode/leetcode/0424-longest-repeating-character-replacement/0424-longest-repeating-character-replacement.java
new file mode 100644
index 0000000..50825c3
--- /dev/null
+++ b/leetcode/leetcode/0424-longest-repeating-character-replacement/0424-longest-repeating-character-replacement.java
@@ -0,0 +1,23 @@
+class Solution {
+    public boolean isValid(int[] freq, int k, int len){
+        int maxFreq = freq[0];
+        for(int i = 1;i<26;i++) maxFreq = Math.max(maxFreq,freq[i]);
+
+        return  len - maxFreq <= k;
+    }
+    public int characterReplacement(String s, int k) {
+        int[] freq = new int[26];
+        int l,r;
+        int ans = Integer.MIN_VALUE;
+        for(l=0,r=0;r<s.length();r++){
+            freq[(int) (s.charAt(r)-'A')]++;
+            
+            while(l<=r && !isValid(freq,k,r-l+1)){
+                freq[(int) (s.charAt(l)-'A')]--;
+                l++;
+            }
+            ans = Math.max(ans,r-l+1);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0424-longest-repeating-character-replacement/README.md b/leetcode/leetcode/0424-longest-repeating-character-replacement/README.md
new file mode 100644
index 0000000..64e2ba5
--- /dev/null
+++ b/leetcode/leetcode/0424-longest-repeating-character-replacement/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/longest-repeating-character-replacement">424. Longest Repeating Character Replacement</a></h2><h3>Medium</h3><hr><p>You are given a string <code>s</code> and an integer <code>k</code>. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most <code>k</code> times.</p>
+
+<p>Return <em>the length of the longest substring containing the same letter you can get after performing the above operations</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;ABAB&quot;, k = 2
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Replace the two &#39;A&#39;s with two &#39;B&#39;s or vice versa.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;AABABBA&quot;, k = 1
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Replace the one &#39;A&#39; in the middle with &#39;B&#39; and form &quot;AABBBBA&quot;.
+The substring &quot;BBBB&quot; has the longest repeating letters, which is 4.
+There may exists other ways to achieve this answer too.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> consists of only uppercase English letters.</li>
+	<li><code>0 &lt;= k &lt;= s.length</code></li>
+</ul>
diff --git a/leetcode/leetcode/0435-non-overlapping-intervals/0435-non-overlapping-intervals.java b/leetcode/leetcode/0435-non-overlapping-intervals/0435-non-overlapping-intervals.java
new file mode 100644
index 0000000..68811c3
--- /dev/null
+++ b/leetcode/leetcode/0435-non-overlapping-intervals/0435-non-overlapping-intervals.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        Arrays.sort(intervals,(a,b)->Integer.compare(a[1],b[1]));
+        int safe_intervals = 1;
+        int prev_start = intervals[0][0];
+        int prev_end   = intervals[0][1];
+        for(int i = 1;i<intervals.length;i++){
+            if(prev_end<=intervals[i][0]){
+                safe_intervals++;
+                prev_start = intervals[i][0];
+                prev_end = intervals[i][1];
+            }
+        }
+        return intervals.length - safe_intervals;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0435-non-overlapping-intervals/README.md b/leetcode/leetcode/0435-non-overlapping-intervals/README.md
new file mode 100644
index 0000000..7512c64
--- /dev/null
+++ b/leetcode/leetcode/0435-non-overlapping-intervals/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/non-overlapping-intervals">435. Non-overlapping Intervals</a></h2><h3>Medium</h3><hr><p>Given an array of intervals <code>intervals</code> where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code>, return <em>the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping</em>.</p>
+
+<p><strong>Note</strong> that intervals which only touch at a point are <strong>non-overlapping</strong>. For example, <code>[1, 2]</code> and <code>[2, 3]</code> are non-overlapping.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> intervals = [[1,2],[2,3],[3,4],[1,3]]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> [1,3] can be removed and the rest of the intervals are non-overlapping.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> intervals = [[1,2],[1,2],[1,2]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> You need to remove two [1,2] to make the rest of the intervals non-overlapping.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> intervals = [[1,2],[2,3]]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> You don&#39;t need to remove any of the intervals since they&#39;re already non-overlapping.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= intervals.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>intervals[i].length == 2</code></li>
+	<li><code>-5 * 10<sup>4</sup> &lt;= start<sub>i</sub> &lt; end<sub>i</sub> &lt;= 5 * 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0440-k-th-smallest-in-lexicographical-order/NOTES.md b/leetcode/leetcode/0440-k-th-smallest-in-lexicographical-order/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0440-k-th-smallest-in-lexicographical-order/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0440-k-th-smallest-in-lexicographical-order/README.md b/leetcode/leetcode/0440-k-th-smallest-in-lexicographical-order/README.md
new file mode 100644
index 0000000..519a677
--- /dev/null
+++ b/leetcode/leetcode/0440-k-th-smallest-in-lexicographical-order/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/k-th-smallest-in-lexicographical-order/">440. K-th Smallest in Lexicographical Order</a></h2><h3>Hard</h3><hr><div><p>Given two integers <code>n</code> and <code>k</code>, return <em>the</em> <code>k<sup>th</sup></code> <em>lexicographically smallest integer in the range</em> <code>[1, n]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 13, k = 2
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> The lexicographical order is [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9], so the second smallest number is 10.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 1, k = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= n &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0443-string-compression/0443-string-compression.java b/leetcode/leetcode/0443-string-compression/0443-string-compression.java
new file mode 100644
index 0000000..db61f51
--- /dev/null
+++ b/leetcode/leetcode/0443-string-compression/0443-string-compression.java
@@ -0,0 +1,29 @@
+class Solution {
+    
+    public int compress(char[] chars) {
+        if(chars.length == 1) return 1;
+        int index = 0;
+        int internalIndex = 0;
+        while(index!=chars.length){
+            int count = 0;
+            int lastChar = (int) chars[index];
+            while(lastChar == ((int) chars[index])){
+                count++;
+                index++;
+                if(index == chars.length) break;
+            }
+            if(count == 1){
+                chars[internalIndex++] = (char) lastChar;
+            }
+            else{
+                String s = String.format("%d",count);
+                chars[internalIndex++] = (char) lastChar;
+                int tempIndex = 0;
+                while(tempIndex!=s.length()){
+                    chars[internalIndex++] = s.charAt(tempIndex++);
+                }
+            }
+        }
+        return internalIndex;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0443-string-compression/NOTES.md b/leetcode/leetcode/0443-string-compression/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0443-string-compression/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0443-string-compression/README.md b/leetcode/leetcode/0443-string-compression/README.md
new file mode 100644
index 0000000..5392816
--- /dev/null
+++ b/leetcode/leetcode/0443-string-compression/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/string-compression/">443. String Compression</a></h2><h3>Medium</h3><hr><div><p>Given an array of characters <code>chars</code>, compress it using the following algorithm:</p>
+
+<p>Begin with an empty string <code>s</code>. For each group of <strong>consecutive repeating characters</strong> in <code>chars</code>:</p>
+
+<ul>
+	<li>If the group's length is <code>1</code>, append the character to <code>s</code>.</li>
+	<li>Otherwise, append the character followed by the group's length.</li>
+</ul>
+
+<p>The compressed string <code>s</code> <strong>should not be returned separately</strong>, but instead, be stored <strong>in the input character array <code>chars</code></strong>. Note that group lengths that are <code>10</code> or longer will be split into multiple characters in <code>chars</code>.</p>
+
+<p>After you are done <strong>modifying the input array,</strong> return <em>the new length of the array</em>.</p>
+
+<p>You must write an algorithm that uses only constant extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> chars = ["a","a","b","b","c","c","c"]
+<strong>Output:</strong> Return 6, and the first 6 characters of the input array should be: ["a","2","b","2","c","3"]
+<strong>Explanation:</strong> The groups are "aa", "bb", and "ccc". This compresses to "a2b2c3".
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> chars = ["a"]
+<strong>Output:</strong> Return 1, and the first character of the input array should be: ["a"]
+<strong>Explanation:</strong> The only group is "a", which remains uncompressed since it's a single character.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
+<strong>Output:</strong> Return 4, and the first 4 characters of the input array should be: ["a","b","1","2"].
+<strong>Explanation:</strong> The groups are "a" and "bbbbbbbbbbbb". This compresses to "ab12".</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= chars.length &lt;= 2000</code></li>
+	<li><code>chars[i]</code> is a lowercase English letter, uppercase English letter, digit, or symbol.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0451-sort-characters-by-frequency/0451-sort-characters-by-frequency.java b/leetcode/leetcode/0451-sort-characters-by-frequency/0451-sort-characters-by-frequency.java
new file mode 100644
index 0000000..1bb9419
--- /dev/null
+++ b/leetcode/leetcode/0451-sort-characters-by-frequency/0451-sort-characters-by-frequency.java
@@ -0,0 +1,28 @@
+class Solution {
+    public String frequencySort(String s) {
+        if(s.length()<3) return s;
+        int[] freq = new int[256];
+        for(int i = 0;i<s.length();i++){
+            freq[(int)s.charAt(i)]++;
+        }
+
+        TreeMap<Integer, List<Character>> sortedMap = new TreeMap<>(Collections.reverseOrder());
+        for (int i = 0; i < 256; i++) {
+            if (freq[i] > 0) {
+                sortedMap.putIfAbsent(freq[i], new ArrayList<>());
+                sortedMap.get(freq[i]).add((char) i);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (Map.Entry<Integer, List<Character>> entry : sortedMap.entrySet()) {
+            int frequency = entry.getKey();
+            List<Character> characters = entry.getValue();
+            for (char c : characters) {
+                for (int i = 0; i < frequency; i++) {
+                    sb.append(c);
+                }
+            }
+        }
+        return sb.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0451-sort-characters-by-frequency/README.md b/leetcode/leetcode/0451-sort-characters-by-frequency/README.md
new file mode 100644
index 0000000..1d68915
--- /dev/null
+++ b/leetcode/leetcode/0451-sort-characters-by-frequency/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/sort-characters-by-frequency">451. Sort Characters By Frequency</a></h2><h3>Medium</h3><hr><p>Given a string <code>s</code>, sort it in <strong>decreasing order</strong> based on the <strong>frequency</strong> of the characters. The <strong>frequency</strong> of a character is the number of times it appears in the string.</p>
+
+<p>Return <em>the sorted string</em>. If there are multiple answers, return <em>any of them</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;tree&quot;
+<strong>Output:</strong> &quot;eert&quot;
+<strong>Explanation:</strong> &#39;e&#39; appears twice while &#39;r&#39; and &#39;t&#39; both appear once.
+So &#39;e&#39; must appear before both &#39;r&#39; and &#39;t&#39;. Therefore &quot;eetr&quot; is also a valid answer.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;cccaaa&quot;
+<strong>Output:</strong> &quot;aaaccc&quot;
+<strong>Explanation:</strong> Both &#39;c&#39; and &#39;a&#39; appear three times, so both &quot;cccaaa&quot; and &quot;aaaccc&quot; are valid answers.
+Note that &quot;cacaca&quot; is incorrect, as the same characters must be together.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;Aabb&quot;
+<strong>Output:</strong> &quot;bbAa&quot;
+<strong>Explanation:</strong> &quot;bbaA&quot; is also a valid answer, but &quot;Aabb&quot; is incorrect.
+Note that &#39;A&#39; and &#39;a&#39; are treated as two different characters.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 5 * 10<sup>5</sup></code></li>
+	<li><code>s</code> consists of uppercase and lowercase English letters and digits.</li>
+</ul>
diff --git a/leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/0452-minimum-number-of-arrows-to-burst-balloons.java b/leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/0452-minimum-number-of-arrows-to-burst-balloons.java
new file mode 100644
index 0000000..4ce7416
--- /dev/null
+++ b/leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/0452-minimum-number-of-arrows-to-burst-balloons.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int findMinArrowShots(int[][] points) {
+        int res = 1;
+        Arrays.sort(points,(a,b)-> Integer.compare(a[1],b[1]));
+        int end = points[0][1];
+        for(int i = 0;i<points.length;i++){
+            if(points[i][0] > end){
+                res++;
+                end = points[i][1];
+            }
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/NOTES.md b/leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/README.md b/leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/README.md
new file mode 100644
index 0000000..2223a5e
--- /dev/null
+++ b/leetcode/leetcode/0452-minimum-number-of-arrows-to-burst-balloons/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/">452. Minimum Number of Arrows to Burst Balloons</a></h2><h3>Medium</h3><hr><div><p>There are some spherical balloons taped onto a flat wall that represents the XY-plane. The balloons are represented as a 2D integer array <code>points</code> where <code>points[i] = [x<sub>start</sub>, x<sub>end</sub>]</code> denotes a balloon whose <strong>horizontal diameter</strong> stretches between <code>x<sub>start</sub></code> and <code>x<sub>end</sub></code>. You do not know the exact y-coordinates of the balloons.</p>
+
+<p>Arrows can be shot up <strong>directly vertically</strong> (in the positive y-direction) from different points along the x-axis. A balloon with <code>x<sub>start</sub></code> and <code>x<sub>end</sub></code> is <strong>burst</strong> by an arrow shot at <code>x</code> if <code>x<sub>start</sub> &lt;= x &lt;= x<sub>end</sub></code>. There is <strong>no limit</strong> to the number of arrows that can be shot. A shot arrow keeps traveling up infinitely, bursting any balloons in its path.</p>
+
+<p>Given the array <code>points</code>, return <em>the <strong>minimum</strong> number of arrows that must be shot to burst all balloons</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> points = [[10,16],[2,8],[1,6],[7,12]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The balloons can be burst by 2 arrows:
+- Shoot an arrow at x = 6, bursting the balloons [2,8] and [1,6].
+- Shoot an arrow at x = 11, bursting the balloons [10,16] and [7,12].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> points = [[1,2],[3,4],[5,6],[7,8]]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> One arrow needs to be shot for each balloon for a total of 4 arrows.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> points = [[1,2],[2,3],[3,4],[4,5]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The balloons can be burst by 2 arrows:
+- Shoot an arrow at x = 2, bursting the balloons [1,2] and [2,3].
+- Shoot an arrow at x = 4, bursting the balloons [3,4] and [4,5].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= points.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>points[i].length == 2</code></li>
+	<li><code>-2<sup>31</sup> &lt;= x<sub>start</sub> &lt; x<sub>end</sub> &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0480-sliding-window-median/0480-sliding-window-median.java b/leetcode/leetcode/0480-sliding-window-median/0480-sliding-window-median.java
new file mode 100644
index 0000000..4adf9b3
--- /dev/null
+++ b/leetcode/leetcode/0480-sliding-window-median/0480-sliding-window-median.java
@@ -0,0 +1,141 @@
+class Solution {
+    public class Pair implements Comparable<Pair>{
+        long val;
+        double noise;
+        Pair(long val, double random) {
+            this.val = val;
+            this.noise = random;
+        }
+        
+        public int compareTo(Pair p){
+            if(this.val == p.val){
+                return Double.compare(this.noise,p.noise);
+            }
+            return Long.compare(this.val,p.val);
+        }
+    }
+    public double[] medianSlidingWindow(int[] nums, int k) {
+        int n = nums.length;
+
+        double[] ans = new double[n-k+1];
+
+        if(k == 1){
+            for(int i = 0;i<n;i++){
+                ans[i] = nums[i];
+            }
+            return ans;
+        }
+        TreeSet<Pair> left = new TreeSet<>();
+        TreeSet<Pair> right = new TreeSet<>();
+        int index = 0;
+        int min = Integer.MIN_VALUE;
+        while(index<k){
+            left.add(new Pair(nums[index],Math.random()));
+            index++;
+        }
+
+        rebalance(left,right,k);
+        
+
+
+        ans[0] = getMedian(left,right, k);
+
+        for(index = k;index<n;index++){
+            remove(left,right,nums[index-k]);
+            rebalance(left,right,k-1);
+
+            add(left,right,nums[index],k);
+            rebalance(left,right,k);
+            ans[index-k+1] = getMedian(left,right,k);
+            // if(index-k == 3) break;
+        }
+
+        while(left.size()!=0){
+            Pair p = left.first();
+            System.out.print(p.val + " ");
+            left.remove(p);
+        }
+        System.out.println();
+
+        while(right.size()!=0){
+            Pair p = right.first();
+            System.out.print(p.val + " " );
+            right.remove(p);
+        }
+        
+
+
+
+
+        return ans;
+    }
+
+    public double getMedian(TreeSet<Pair> left, TreeSet<Pair> right, int k){
+        if(k%2==0){
+            return (left.last().val + right.first().val)/2.0;
+        }else{
+            return left.last().val;
+        }
+    }
+    public void remove(TreeSet<Pair> left, TreeSet<Pair> right, int ele){
+        if(left.last().val>=ele){
+            Pair p = left.higher(new Pair(ele,-1));
+            left.remove(p);
+        }else{
+            Pair p = right.higher(new Pair(ele,-1));
+            right.remove(p);
+        }
+    }
+
+    public void add(TreeSet<Pair> left, TreeSet<Pair> right, int ele, int k){
+        if(left.last().val<ele){
+            right.add(new Pair(ele,Math.random()));
+        }else{
+            left.add(new Pair(ele,Math.random()));
+        }
+    }
+
+    public void rebalance(TreeSet<Pair> left, TreeSet<Pair> right, int k){
+        if(k%2==0){
+            rebalanceEven(left, right);
+        }else{
+            rebalanceOdd(left,right);
+        }
+    }
+
+    public void rebalanceOdd(TreeSet<Pair> left, TreeSet<Pair> right){
+        if(left.size()>right.size()){
+            if(left.size()-right.size() == 1) return;
+            else{
+                while(left.size()-right.size() != 1){
+                    Pair p = left.pollLast();
+                    right.add(p);
+                }
+            }
+        }else{
+            while(left.size()-right.size() != 1){
+                Pair p = right.pollFirst();
+                left.add(p);
+            }
+
+        }
+    }
+
+    public void rebalanceEven(TreeSet<Pair> left, TreeSet<Pair> right){
+        if(left.size()==right.size()) return;
+
+        else if(left.size()>right.size()){
+            while(left.size()-right.size() != 0){
+                Pair p = left.pollLast();
+                right.add(p);
+            }
+
+        }else{
+            while(left.size()-right.size() != 0){
+                Pair p = right.pollFirst();
+                left.add(p);
+            }
+
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0480-sliding-window-median/README.md b/leetcode/leetcode/0480-sliding-window-median/README.md
new file mode 100644
index 0000000..7d669f5
--- /dev/null
+++ b/leetcode/leetcode/0480-sliding-window-median/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/sliding-window-median">480. Sliding Window Median</a></h2><h3>Hard</h3><hr><p>The <strong>median</strong> is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle values.</p>
+
+<ul>
+	<li>For examples, if <code>arr = [2,<u>3</u>,4]</code>, the median is <code>3</code>.</li>
+	<li>For examples, if <code>arr = [1,<u>2,3</u>,4]</code>, the median is <code>(2 + 3) / 2 = 2.5</code>.</li>
+</ul>
+
+<p>You are given an integer array <code>nums</code> and an integer <code>k</code>. There is a sliding window of size <code>k</code> which is moving from the very left of the array to the very right. You can only see the <code>k</code> numbers in the window. Each time the sliding window moves right by one position.</p>
+
+<p>Return <em>the median array for each window in the original array</em>. Answers within <code>10<sup>-5</sup></code> of the actual value will be accepted.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,3,-1,-3,5,3,6,7], k = 3
+<strong>Output:</strong> [1.00000,-1.00000,-1.00000,3.00000,5.00000,6.00000]
+<strong>Explanation:</strong> 
+Window position                Median
+---------------                -----
+[<strong>1  3  -1</strong>] -3  5  3  6  7        1
+ 1 [<strong>3  -1  -3</strong>] 5  3  6  7       -1
+ 1  3 [<strong>-1  -3  5</strong>] 3  6  7       -1
+ 1  3  -1 [<strong>-3  5  3</strong>] 6  7        3
+ 1  3  -1  -3 [<strong>5  3  6</strong>] 7        5
+ 1  3  -1  -3  5 [<strong>3  6  7</strong>]       6
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,4,2,3,1,4,2], k = 3
+<strong>Output:</strong> [2.00000,3.00000,3.00000,3.00000,2.00000,3.00000,2.00000]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
diff --git a/leetcode/leetcode/0485-max-consecutive-ones/0485-max-consecutive-ones.java b/leetcode/leetcode/0485-max-consecutive-ones/0485-max-consecutive-ones.java
new file mode 100644
index 0000000..31a5093
--- /dev/null
+++ b/leetcode/leetcode/0485-max-consecutive-ones/0485-max-consecutive-ones.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int findMaxConsecutiveOnes(int[] nums) {
+       int maxNo=0;
+       int currNo=0;
+        for (int i=0; i<nums.length;i++){
+            if(nums[i]==1){
+                currNo++;
+                maxNo = Math.max(currNo,maxNo);
+            }
+            else{
+                currNo=0;
+            }
+
+        }
+        return maxNo;        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0485-max-consecutive-ones/README.md b/leetcode/leetcode/0485-max-consecutive-ones/README.md
new file mode 100644
index 0000000..0a88ee7
--- /dev/null
+++ b/leetcode/leetcode/0485-max-consecutive-ones/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/max-consecutive-ones">485. Max Consecutive Ones</a></h2><h3>Easy</h3><hr><p>Given a binary array <code>nums</code>, return <em>the maximum number of consecutive </em><code>1</code><em>&#39;s in the array</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,1,0,1,1,1]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The first two digits or the last three digits are consecutive 1s. The maximum number of consecutive 1s is 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,0,1,1,0,1]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0503-next-greater-element-ii/0503-next-greater-element-ii.java b/leetcode/leetcode/0503-next-greater-element-ii/0503-next-greater-element-ii.java
new file mode 100644
index 0000000..045903d
--- /dev/null
+++ b/leetcode/leetcode/0503-next-greater-element-ii/0503-next-greater-element-ii.java
@@ -0,0 +1,47 @@
+class Solution {
+    class Pair{
+        public int index;
+        public int value;
+        Pair(int i, int v){
+            this.index   = i;
+            this.value    = v;
+        }
+    }
+    public int[] nextGreaterElements(int[] arr) {
+        int[] list = new int[arr.length];
+        for(int i =0;i<arr.length;i++){
+            list[i] = -1;
+        }
+        Stack<Pair> s = new Stack<>();
+        int index = 0;
+        while(index!=arr.length){
+            if(s.isEmpty()) {
+                s.push(new Pair(index,arr[index]));
+                index++;
+                continue;
+            }
+            while(!s.isEmpty() && s.peek().value<arr[index]){
+                list[s.peek().index] = arr[index];
+                s.pop();
+            }
+            s.push(new Pair(index,arr[index]));
+            index++;
+        }
+        index = 0;
+        while(index!=arr.length){
+            if(s.isEmpty()) {
+                s.push(new Pair(index,arr[index]));
+                index++;
+                continue;
+            }
+            while(!s.isEmpty() && s.peek().value<arr[index]){
+                list[s.peek().index] = arr[index];
+                s.pop();
+            }
+            s.push(new Pair(index,arr[index]));
+            index++;
+        }
+
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0503-next-greater-element-ii/README.md b/leetcode/leetcode/0503-next-greater-element-ii/README.md
new file mode 100644
index 0000000..9d0f8b6
--- /dev/null
+++ b/leetcode/leetcode/0503-next-greater-element-ii/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/next-greater-element-ii">503. Next Greater Element II</a></h2><h3>Medium</h3><hr><p>Given a circular integer array <code>nums</code> (i.e., the next element of <code>nums[nums.length - 1]</code> is <code>nums[0]</code>), return <em>the <strong>next greater number</strong> for every element in</em> <code>nums</code>.</p>
+
+<p>The <strong>next greater number</strong> of a number <code>x</code> is the first greater number to its traversing-order next in the array, which means you could search circularly to find its next greater number. If it doesn&#39;t exist, return <code>-1</code> for this number.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,1]
+<strong>Output:</strong> [2,-1,2]
+Explanation: The first 1&#39;s next greater number is 2; 
+The number 2 can&#39;t find next greater number. 
+The second 1&#39;s next greater number needs to search circularly, which is also 2.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,4,3]
+<strong>Output:</strong> [2,3,4,-1,4]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0509-fibonacci-number/NOTES.md b/leetcode/leetcode/0509-fibonacci-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0509-fibonacci-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0509-fibonacci-number/README.md b/leetcode/leetcode/0509-fibonacci-number/README.md
new file mode 100644
index 0000000..328aa57
--- /dev/null
+++ b/leetcode/leetcode/0509-fibonacci-number/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/fibonacci-number/">509. Fibonacci Number</a></h2><h3>Easy</h3><hr><div><p>The <b>Fibonacci numbers</b>, commonly denoted <code>F(n)</code> form a sequence, called the <b>Fibonacci sequence</b>, such that each number is the sum of the two preceding ones, starting from <code>0</code> and <code>1</code>. That is,</p>
+
+<pre>F(0) = 0, F(1) = 1
+F(n) = F(n - 1) + F(n - 2), for n &gt; 1.
+</pre>
+
+<p>Given <code>n</code>, calculate <code>F(n)</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> F(2) = F(1) + F(0) = 1 + 0 = 1.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> F(3) = F(2) + F(1) = 1 + 1 = 2.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> F(4) = F(3) + F(2) = 2 + 1 = 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 30</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0513-find-bottom-left-tree-value/0513-find-bottom-left-tree-value.java b/leetcode/leetcode/0513-find-bottom-left-tree-value/0513-find-bottom-left-tree-value.java
new file mode 100644
index 0000000..150077e
--- /dev/null
+++ b/leetcode/leetcode/0513-find-bottom-left-tree-value/0513-find-bottom-left-tree-value.java
@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int findBottomLeftValue(TreeNode root) {
+        Queue<TreeNode> q = new LinkedList<>();
+        int ans = -1;
+        q.add(root);
+        while(!q.isEmpty()){
+            ans = q.peek().val;
+            for(int i = q.size(); i!=0;i--){
+                root = q.poll();
+                if(root.left!=null) q.add(root.left); 
+                if(root.right!=null) q.add(root.right); 
+                // System.out.print(root.val + " ");
+            }
+            // System.out.println();
+        }
+        return ans;
+
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0513-find-bottom-left-tree-value/README.md b/leetcode/leetcode/0513-find-bottom-left-tree-value/README.md
new file mode 100644
index 0000000..579cbb8
--- /dev/null
+++ b/leetcode/leetcode/0513-find-bottom-left-tree-value/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/find-bottom-left-tree-value">513. Find Bottom Left Tree Value</a></h2><h3>Medium</h3><hr><p>Given the <code>root</code> of a binary tree, return the leftmost value in the last row of the tree.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/14/tree1.jpg" style="width: 302px; height: 182px;" />
+<pre>
+<strong>Input:</strong> root = [2,1,3]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/14/tree2.jpg" style="width: 432px; height: 421px;" />
+<pre>
+<strong>Input:</strong> root = [1,2,3,4,null,5,6,null,null,7]
+<strong>Output:</strong> 7
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-2<sup>31</sup> &lt;= Node.val &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
diff --git a/leetcode/leetcode/0515-find-largest-value-in-each-tree-row/README.md b/leetcode/leetcode/0515-find-largest-value-in-each-tree-row/README.md
new file mode 100644
index 0000000..95bb431
--- /dev/null
+++ b/leetcode/leetcode/0515-find-largest-value-in-each-tree-row/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/find-largest-value-in-each-tree-row/">515. Find Largest Value in Each Tree Row</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>an array of the largest value in each row</em> of the tree <strong>(0-indexed)</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/21/largest_e1.jpg" style="width: 300px; height: 172px;">
+<pre><strong>Input:</strong> root = [1,3,2,5,3,null,9]
+<strong>Output:</strong> [1,3,9]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,2,3]
+<strong>Output:</strong> [1,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree will be in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-2<sup>31</sup> &lt;= Node.val &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0516-longest-palindromic-subsequence/0516-longest-palindromic-subsequence.java b/leetcode/leetcode/0516-longest-palindromic-subsequence/0516-longest-palindromic-subsequence.java
new file mode 100644
index 0000000..795d3bb
--- /dev/null
+++ b/leetcode/leetcode/0516-longest-palindromic-subsequence/0516-longest-palindromic-subsequence.java
@@ -0,0 +1,57 @@
+// class Solution {
+//     public int LCS(String s, int m, int n) {
+//         if (m <= 0 || n > s.length())
+//             return 0;
+//         if (s.charAt(m - 1) == s.charAt(n - 1))
+//             return 1 + LCS(s, m - 1, n + 1);
+//         else
+//             return Math.max(LCS(s, m - 1, n), LCS(s, m, n + 1));
+//     }
+
+//     public int longestPalindromeSubseq(String s) {
+//         return LCS(s, s.length(), 1);
+//     }
+// }
+
+// class Solution {
+//     public int LCS(String s, int[][] memo, int m, int n) {
+//         if (m <= 0 || n > s.length())
+//             return 0;
+//         if (memo[m - 1][n - 1] != -1)
+//             return memo[m - 1][n - 1];
+//         if (s.charAt(m - 1) == s.charAt(n - 1))
+//             memo[m - 1][n - 1] = 1 + LCS(s, memo, m - 1, n + 1);
+//         else
+//             memo[m - 1][n - 1] = Math.max(LCS(s, memo, m - 1, n), LCS(s, memo, m, n + 1));
+//         return memo[m - 1][n - 1];
+//     }
+
+//     public int longestPalindromeSubseq(String s) {
+//         int[][] memo = new int[s.length() + 1][s.length() + 1];
+//         for (int i = 0; i <= s.length(); i++) {
+//             for (int j = 0; j <= s.length(); j++) {
+//                 memo[i][j] = -1;
+//             }
+//         }
+//         return LCS(s, memo, s.length(), 1);
+//     }
+// }
+
+class Solution {
+
+
+    public int longestPalindromeSubseq(String s) {
+        int[][] dp = new int[s.length() + 1][s.length() + 1];
+
+        for (int m = 1; m <= s.length(); m++) {
+            for (int n = 1; n <= s.length(); n++) {
+                if (s.charAt(m - 1) == s.charAt(s.length() - n))
+                    dp[m][n] = 1 + dp[m - 1][n - 1];
+                else
+                    dp[m][n] = Math.max(dp[m - 1][n], dp[m][n - 1]);
+            }
+        }
+
+        return dp[s.length()][s.length()];
+    }
+}
diff --git a/leetcode/leetcode/0516-longest-palindromic-subsequence/README.md b/leetcode/leetcode/0516-longest-palindromic-subsequence/README.md
new file mode 100644
index 0000000..f772e50
--- /dev/null
+++ b/leetcode/leetcode/0516-longest-palindromic-subsequence/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/longest-palindromic-subsequence">516. Longest Palindromic Subsequence</a></h2><h3>Medium</h3><hr><p>Given a string <code>s</code>, find <em>the longest palindromic <strong>subsequence</strong>&#39;s length in</em> <code>s</code>.</p>
+
+<p>A <strong>subsequence</strong> is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;bbbab&quot;
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> One possible longest palindromic subsequence is &quot;bbbb&quot;.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;cbbd&quot;
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> One possible longest palindromic subsequence is &quot;bb&quot;.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 1000</code></li>
+	<li><code>s</code> consists only of lowercase English letters.</li>
+</ul>
diff --git a/leetcode/leetcode/0525-contiguous-array/0525-contiguous-array.java b/leetcode/leetcode/0525-contiguous-array/0525-contiguous-array.java
new file mode 100644
index 0000000..d87b426
--- /dev/null
+++ b/leetcode/leetcode/0525-contiguous-array/0525-contiguous-array.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int findMaxLength(int[] nums) {
+        int count = 0;
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int ans = 0;
+        map.put(0,0);
+        for(int i = 0;i<nums.length;i++){
+            if(nums[i] == 0){
+                count--;
+            }else{
+                count++;
+            }
+
+
+            if(map.containsKey(count)){
+                ans = Math.max(ans, i - map.get(count)+1);
+            }else{
+                map.put(count,i+1);
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0525-contiguous-array/README.md b/leetcode/leetcode/0525-contiguous-array/README.md
new file mode 100644
index 0000000..8393a67
--- /dev/null
+++ b/leetcode/leetcode/0525-contiguous-array/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/contiguous-array">525. Contiguous Array</a></h2><h3>Medium</h3><hr><p>Given a binary array <code>nums</code>, return <em>the maximum length of a contiguous subarray with an equal number of </em><code>0</code><em> and </em><code>1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> [0, 1] is the longest contiguous subarray with an equal number of 0 and 1.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,1,0]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,1,1,1,1,1,0,0,0]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> [1,1,1,0,0,0] is the longest contiguous subarray with equal number of 0 and 1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0539-minimum-time-difference/0539-minimum-time-difference.java b/leetcode/leetcode/0539-minimum-time-difference/0539-minimum-time-difference.java
new file mode 100644
index 0000000..4ddd45e
--- /dev/null
+++ b/leetcode/leetcode/0539-minimum-time-difference/0539-minimum-time-difference.java
@@ -0,0 +1,40 @@
+class Solution {
+//     public class Time implements Comparable<Time>{
+//         int hour;
+//         int minute;
+//         Time(int hour, int minute){
+//             this.hour = hour;
+//             this.minute = minute;
+//         }
+//         public int compareTo(Time T){  
+//             return (T.minutes+(T.hour*60))  - (this.minutes+(this.hour*60));
+
+//         }       
+//     }
+    public int findMinDifference(List<String> timePoints) {
+        boolean[] minutes = new boolean[1440];
+        for(int i =0;i<timePoints.size();i++){
+            int hour = Integer.parseInt(timePoints.get(i).substring(0,2));
+            int min = Integer.parseInt(timePoints.get(i).substring(3));
+            if(minutes[hour*60+min] ==true){
+                return 0;
+            }
+            minutes[hour*60+min] = true;
+        }
+        int prevIndex = Integer.MAX_VALUE;
+        int firstIndex = Integer.MAX_VALUE;
+        int lastIndex = Integer.MAX_VALUE;
+        int ans = Integer.MAX_VALUE;
+        for(int i = 0;i<1440;i++){
+            if(minutes[i]){
+                if(prevIndex!=Integer.MAX_VALUE){
+                    ans = Math.min(ans,i-prevIndex);
+                }
+                prevIndex = i;
+                if(firstIndex == Integer.MAX_VALUE) firstIndex = i;
+                lastIndex = i;
+            }
+        }
+        return Math.min(ans,1440 - lastIndex + firstIndex);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0539-minimum-time-difference/NOTES.md b/leetcode/leetcode/0539-minimum-time-difference/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0539-minimum-time-difference/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0539-minimum-time-difference/README.md b/leetcode/leetcode/0539-minimum-time-difference/README.md
new file mode 100644
index 0000000..d8d04fe
--- /dev/null
+++ b/leetcode/leetcode/0539-minimum-time-difference/README.md
@@ -0,0 +1,17 @@
+<h2><a href="https://leetcode.com/problems/minimum-time-difference/">539. Minimum Time Difference</a></h2><h3>Medium</h3><hr><div>Given a list of 24-hour clock time points in <strong>"HH:MM"</strong> format, return <em>the minimum <b>minutes</b> difference between any two time-points in the list</em>.
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> timePoints = ["23:59","00:00"]
+<strong>Output:</strong> 1
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> timePoints = ["00:00","23:59","00:00"]
+<strong>Output:</strong> 0
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= timePoints.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>timePoints[i]</code> is in the format <strong>"HH:MM"</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0540-single-element-in-a-sorted-array/0540-single-element-in-a-sorted-array.java b/leetcode/leetcode/0540-single-element-in-a-sorted-array/0540-single-element-in-a-sorted-array.java
new file mode 100644
index 0000000..bb78474
--- /dev/null
+++ b/leetcode/leetcode/0540-single-element-in-a-sorted-array/0540-single-element-in-a-sorted-array.java
@@ -0,0 +1,30 @@
+class Solution {
+    public int singleNonDuplicate(int[] nums) {
+        if(nums.length  == 1) return nums[0];
+
+        int low = 0;
+        int high = nums.length - 1;
+
+        if(nums[low] != nums[low+1]) return nums[low];
+        if(nums[high] != nums[high-1]) return nums[high];
+
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(nums[mid] == nums[mid+1]){
+                if(mid%2 == 0){
+                    low = mid+1;
+                } else{
+                    high = mid-1;
+                }
+            }else if(nums[mid] == nums[mid-1]){
+                if((mid - 1) % 2 == 0 ){
+                    low = mid + 1;
+                }else{
+                    high = mid - 1;
+                }
+
+            }else return nums[mid];
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0540-single-element-in-a-sorted-array/README.md b/leetcode/leetcode/0540-single-element-in-a-sorted-array/README.md
new file mode 100644
index 0000000..0fe63f4
--- /dev/null
+++ b/leetcode/leetcode/0540-single-element-in-a-sorted-array/README.md
@@ -0,0 +1,21 @@
+<h2><a href="https://leetcode.com/problems/single-element-in-a-sorted-array">540. Single Element in a Sorted Array</a></h2><h3>Medium</h3><hr><p>You are given a sorted array consisting of only integers where every element appears exactly twice, except for one element which appears exactly once.</p>
+
+<p>Return <em>the single element that appears only once</em>.</p>
+
+<p>Your solution must run in <code>O(log n)</code> time and <code>O(1)</code> space.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,2,3,3,4,4,8,8]
+<strong>Output:</strong> 2
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [3,3,7,7,10,11,11]
+<strong>Output:</strong> 10
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0543-diameter-of-binary-tree/0543-diameter-of-binary-tree.java b/leetcode/leetcode/0543-diameter-of-binary-tree/0543-diameter-of-binary-tree.java
new file mode 100644
index 0000000..1ef75e7
--- /dev/null
+++ b/leetcode/leetcode/0543-diameter-of-binary-tree/0543-diameter-of-binary-tree.java
@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    class Pair{
+        int height;
+        int dia;
+        Pair(int h, int d){
+            this.height = h;
+            this.dia    = d; 
+        }
+    }
+
+    public Pair helper(TreeNode root){
+        if(root == null) return new Pair(0,0);
+
+        Pair left = helper(root.left);
+        Pair right = helper(root.right);
+
+
+        Pair ans  = new Pair(0,0);
+         
+        ans.dia = Math.max(left.dia,Math.max(right.dia,left.height+right.height+1));
+        ans.height = Math.max(left.height,right.height)+1;
+        return ans;
+    }
+    public int diameterOfBinaryTree(TreeNode root) {
+        return helper(root).dia - 1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0543-diameter-of-binary-tree/README.md b/leetcode/leetcode/0543-diameter-of-binary-tree/README.md
new file mode 100644
index 0000000..5ef438e
--- /dev/null
+++ b/leetcode/leetcode/0543-diameter-of-binary-tree/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/diameter-of-binary-tree">543. Diameter of Binary Tree</a></h2><h3>Easy</h3><hr><p>Given the <code>root</code> of a binary tree, return <em>the length of the <strong>diameter</strong> of the tree</em>.</p>
+
+<p>The <strong>diameter</strong> of a binary tree is the <strong>length</strong> of the longest path between any two nodes in a tree. This path may or may not pass through the <code>root</code>.</p>
+
+<p>The <strong>length</strong> of a path between two nodes is represented by the number of edges between them.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/06/diamtree.jpg" style="width: 292px; height: 302px;" />
+<pre>
+<strong>Input:</strong> root = [1,2,3,4,5]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 3 is the length of the path [4,2,1,3] or [5,2,1,3].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [1,2]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0560-subarray-sum-equals-k/0560-subarray-sum-equals-k.java b/leetcode/leetcode/0560-subarray-sum-equals-k/0560-subarray-sum-equals-k.java
new file mode 100644
index 0000000..6cd8036
--- /dev/null
+++ b/leetcode/leetcode/0560-subarray-sum-equals-k/0560-subarray-sum-equals-k.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int subarraySum(int[] nums, int k) {
+        int ans = 0;
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int sum =0;
+        map.put(sum,1);
+        for(int i = 0;i<nums.length;i++){
+            sum+=nums[i];
+
+            ans+=map.getOrDefault(sum-k,0);
+
+            map.put(sum,map.getOrDefault(sum,0)+1);
+
+
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0560-subarray-sum-equals-k/README.md b/leetcode/leetcode/0560-subarray-sum-equals-k/README.md
new file mode 100644
index 0000000..dc9c776
--- /dev/null
+++ b/leetcode/leetcode/0560-subarray-sum-equals-k/README.md
@@ -0,0 +1,20 @@
+<h2><a href="https://leetcode.com/problems/subarray-sum-equals-k">560. Subarray Sum Equals K</a></h2><h3>Medium</h3><hr><p>Given an array of integers <code>nums</code> and an integer <code>k</code>, return <em>the total number of subarrays whose sum equals to</em> <code>k</code>.</p>
+
+<p>A subarray is a contiguous <strong>non-empty</strong> sequence of elements within an array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,1], k = 2
+<strong>Output:</strong> 2
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3], k = 3
+<strong>Output:</strong> 2
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= nums[i] &lt;= 1000</code></li>
+	<li><code>-10<sup>7</sup> &lt;= k &lt;= 10<sup>7</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0584-find-customer-referee/0584-find-customer-referee.sql b/leetcode/leetcode/0584-find-customer-referee/0584-find-customer-referee.sql
new file mode 100644
index 0000000..df97c0b
--- /dev/null
+++ b/leetcode/leetcode/0584-find-customer-referee/0584-find-customer-referee.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT name from Customer where referee_id != 2 or referee_id is null;
\ No newline at end of file
diff --git a/leetcode/leetcode/0584-find-customer-referee/README.md b/leetcode/leetcode/0584-find-customer-referee/README.md
new file mode 100644
index 0000000..86aa614
--- /dev/null
+++ b/leetcode/leetcode/0584-find-customer-referee/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/find-customer-referee">584. Find Customer Referee</a></h2><h3>Easy</h3><hr><p>Table: <code>Customer</code></p>
+
+<pre>
++-------------+---------+
+| Column Name | Type    |
++-------------+---------+
+| id          | int     |
+| name        | varchar |
+| referee_id  | int     |
++-------------+---------+
+In SQL, id is the primary key column for this table.
+Each row of this table indicates the id of a customer, their name, and the id of the customer who referred them.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Find the names of the customer that are <strong>not referred by</strong> the customer with <code>id = 2</code>.</p>
+
+<p>Return the result table in <strong>any order</strong>.</p>
+
+<p>The result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> 
+Customer table:
++----+------+------------+
+| id | name | referee_id |
++----+------+------------+
+| 1  | Will | null       |
+| 2  | Jane | null       |
+| 3  | Alex | 2          |
+| 4  | Bill | null       |
+| 5  | Zack | 1          |
+| 6  | Mark | 2          |
++----+------+------------+
+<strong>Output:</strong> 
++------+
+| name |
++------+
+| Will |
+| Jane |
+| Bill |
+| Zack |
++------+
+</pre>
diff --git a/leetcode/leetcode/0605-can-place-flowers/0605-can-place-flowers.java b/leetcode/leetcode/0605-can-place-flowers/0605-can-place-flowers.java
new file mode 100644
index 0000000..828c963
--- /dev/null
+++ b/leetcode/leetcode/0605-can-place-flowers/0605-can-place-flowers.java
@@ -0,0 +1,28 @@
+class Solution {
+    public boolean canPlaceFlowers(int[] flowerbed, int n) {
+        if(n==0) return true;
+        if(flowerbed.length == 1){
+            if(n==1 && flowerbed[0] != 1 ) return true;
+            return false;
+        }
+        if(n>(flowerbed.length+1)/2) return false;
+        if(flowerbed[0]==0 && flowerbed[1]==0){
+            flowerbed[0] = 1;
+            n--;
+        }
+        for(int i = 1;i<flowerbed.length-1;i++){
+            if(n==0) return true;
+            if(flowerbed[i]==0 && flowerbed[i+1]==0 && flowerbed[i-1] == 0){
+                flowerbed[i] = 1;
+                i++;
+                n--;
+            }
+        }
+        if(n<=0) return true;
+        if(flowerbed[flowerbed.length-1]==0 && flowerbed[flowerbed.length-2]==0){
+            flowerbed[flowerbed.length-1]=1;
+            n--;
+        }
+        return n<=0;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0605-can-place-flowers/NOTES.md b/leetcode/leetcode/0605-can-place-flowers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0605-can-place-flowers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0605-can-place-flowers/README.md b/leetcode/leetcode/0605-can-place-flowers/README.md
new file mode 100644
index 0000000..8cb8a5d
--- /dev/null
+++ b/leetcode/leetcode/0605-can-place-flowers/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/can-place-flowers/">605. Can Place Flowers</a></h2><h3>Easy</h3><hr><div><p>You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in <strong>adjacent</strong> plots.</p>
+
+<p>Given an integer array <code>flowerbed</code> containing <code>0</code>'s and <code>1</code>'s, where <code>0</code> means empty and <code>1</code> means not empty, and an integer <code>n</code>, return <code>true</code>&nbsp;<em>if</em> <code>n</code> <em>new flowers can be planted in the</em> <code>flowerbed</code> <em>without violating the no-adjacent-flowers rule and</em> <code>false</code> <em>otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> flowerbed = [1,0,0,0,1], n = 1
+<strong>Output:</strong> true
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> flowerbed = [1,0,0,0,1], n = 2
+<strong>Output:</strong> false
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= flowerbed.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>flowerbed[i]</code> is <code>0</code> or <code>1</code>.</li>
+	<li>There are no two adjacent flowers in <code>flowerbed</code>.</li>
+	<li><code>0 &lt;= n &lt;= flowerbed.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0621-task-scheduler/0621-task-scheduler.java b/leetcode/leetcode/0621-task-scheduler/0621-task-scheduler.java
new file mode 100644
index 0000000..fa87461
--- /dev/null
+++ b/leetcode/leetcode/0621-task-scheduler/0621-task-scheduler.java
@@ -0,0 +1,24 @@
+class Solution {
+    public int leastInterval(char[] tasks, int n) {
+        // freq array to store the frequency of each task
+        int[] freq = new int[26];  
+        int maxCount = 0;
+
+        // Count the frequency of each task and find the maximum frequency
+        for (char task : tasks) {
+            freq[task - 'A']++;
+            maxCount = Math.max(maxCount, freq[task - 'A']);
+        }
+
+        // Calculate the total time needed for execution
+        int time = (maxCount - 1) * (n + 1);
+        for (int f : freq) {
+            if (f == maxCount) {
+                time++;
+            }
+        }
+
+        // Return the maximum of total time needed and the length of the task list
+        return Math.max(tasks.length, time);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0621-task-scheduler/NOTES.md b/leetcode/leetcode/0621-task-scheduler/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0621-task-scheduler/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0621-task-scheduler/README.md b/leetcode/leetcode/0621-task-scheduler/README.md
new file mode 100644
index 0000000..a449ed3
--- /dev/null
+++ b/leetcode/leetcode/0621-task-scheduler/README.md
@@ -0,0 +1,95 @@
+<h2><a href="https://leetcode.com/problems/task-scheduler/">621. Task Scheduler</a></h2><h3>Medium</h3><hr><div><p>You are given an array of CPU <code>tasks</code>, each represented by letters&nbsp;A&nbsp;to Z, and a cooling time, <code>n</code>. Each cycle or interval allows the completion of one task. Tasks can be completed in any order, but there's a constraint: <strong>identical</strong> tasks must be separated by at least <code>n</code> intervals due to cooling time.</p>
+
+<p>​Return the <em>minimum number of intervals</em> required to complete all tasks.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block" style="
+    border-color: var(--border-tertiary);
+    border-left-width: 2px;
+    color: var(--text-secondary);
+    font-size: .875rem;
+    margin-bottom: 1rem;
+    margin-top: 1rem;
+    overflow: visible;
+    padding-left: 1rem;
+">
+<p><strong>Input:</strong> <span class="example-io" style="
+    font-family: Menlo,sans-serif;
+    font-size: 0.85rem;
+">tasks = ["A","A","A","B","B","B"], n = 2</span></p>
+
+<p><strong>Output:</strong> <span class="example-io" style="
+font-family: Menlo,sans-serif;
+font-size: 0.85rem;
+">8</span></p>
+
+<p><strong>Explanation:</strong> A possible sequence is: A -&gt; B -&gt; idle -&gt; A -&gt; B -&gt; idle -&gt; A -&gt; B.</p>
+
+<p>After completing task A, you must wait two cycles before doing A again. The same applies to task B. In the 3<sup>rd</sup> interval, neither A nor B can be done, so you idle. By the 4<sup>th</sup> cycle, you can do A again as 2 intervals have passed.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block" style="
+    border-color: var(--border-tertiary);
+    border-left-width: 2px;
+    color: var(--text-secondary);
+    font-size: .875rem;
+    margin-bottom: 1rem;
+    margin-top: 1rem;
+    overflow: visible;
+    padding-left: 1rem;
+">
+<p><strong>Input:</strong> <span class="example-io" style="
+    font-family: Menlo,sans-serif;
+    font-size: 0.85rem;
+">tasks = ["A","C","A","B","D","B"], n = 1</span></p>
+
+<p><strong>Output:</strong> <span class="example-io" style="
+    font-family: Menlo,sans-serif;
+    font-size: 0.85rem;
+">6</span></p>
+
+<p><strong>Explanation:</strong> A possible sequence is: A -&gt; B -&gt; C -&gt; D -&gt; A -&gt; B.</p>
+
+<p>With a cooling interval of 1, you can repeat a task after just one other task.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block" style="
+    border-color: var(--border-tertiary);
+    border-left-width: 2px;
+    color: var(--text-secondary);
+    font-size: .875rem;
+    margin-bottom: 1rem;
+    margin-top: 1rem;
+    overflow: visible;
+    padding-left: 1rem;
+">
+<p><strong>Input:</strong> <span class="example-io" style="
+    font-family: Menlo,sans-serif;
+    font-size: 0.85rem;
+">tasks = ["A","A","A", "B","B","B"], n = 3</span></p>
+
+<p><strong>Output:</strong> <span class="example-io" style="
+    font-family: Menlo,sans-serif;
+    font-size: 0.85rem;
+">10</span></p>
+
+<p><strong>Explanation:</strong> A possible sequence is: A -&gt; B -&gt; idle -&gt; idle -&gt; A -&gt; B -&gt; idle -&gt; idle -&gt; A -&gt; B.</p>
+
+<p>There are only two types of tasks, A and B, which need to be separated by 3 intervals. This leads to idling twice between repetitions of these tasks.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= tasks.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>tasks[i]</code> is an uppercase English letter.</li>
+	<li><code>0 &lt;= n &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0637-average-of-levels-in-binary-tree/0637-average-of-levels-in-binary-tree.java b/leetcode/leetcode/0637-average-of-levels-in-binary-tree/0637-average-of-levels-in-binary-tree.java
new file mode 100644
index 0000000..df0740b
--- /dev/null
+++ b/leetcode/leetcode/0637-average-of-levels-in-binary-tree/0637-average-of-levels-in-binary-tree.java
@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Double> averageOfLevels(TreeNode root) {
+        List<Double> answer = new ArrayList<>();
+
+        if(root == null) return answer;
+
+        Queue<TreeNode> q =new LinkedList<>();
+        q.add(root);
+
+        while(!q.isEmpty()){
+
+            double sum = 0;
+            int size = q.size();
+            for(int i = 0;i<size;i++){
+                root = q.poll();
+                sum+=root.val;
+
+                if(root.left!=null) q.add(root.left);
+                if(root.right !=null) q.add(root.right);
+            }
+            answer.add(sum/size);
+        }
+        return answer;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0637-average-of-levels-in-binary-tree/README.md b/leetcode/leetcode/0637-average-of-levels-in-binary-tree/README.md
new file mode 100644
index 0000000..aaa6ac7
--- /dev/null
+++ b/leetcode/leetcode/0637-average-of-levels-in-binary-tree/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/average-of-levels-in-binary-tree">637. Average of Levels in Binary Tree</a></h2><h3>Easy</h3><hr>Given the <code>root</code> of a binary tree, return <em>the average value of the nodes on each level in the form of an array</em>. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/avg1-tree.jpg" style="width: 277px; height: 302px;" />
+<pre>
+<strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> [3.00000,14.50000,11.00000]
+Explanation: The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11.
+Hence return [3, 14.5, 11].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/avg2-tree.jpg" style="width: 292px; height: 302px;" />
+<pre>
+<strong>Input:</strong> root = [3,9,20,15,7]
+<strong>Output:</strong> [3.00000,14.50000,11.00000]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-2<sup>31</sup> &lt;= Node.val &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
diff --git a/leetcode/leetcode/0643-maximum-average-subarray-i/0643-maximum-average-subarray-i.java b/leetcode/leetcode/0643-maximum-average-subarray-i/0643-maximum-average-subarray-i.java
new file mode 100644
index 0000000..14cd3df
--- /dev/null
+++ b/leetcode/leetcode/0643-maximum-average-subarray-i/0643-maximum-average-subarray-i.java
@@ -0,0 +1,17 @@
+class Solution {
+    public double findMaxAverage(int[] nums, int k) {
+        int low = 0;
+        double sum = 0;
+        for(int i = 0;i<k;i++){
+            sum+=nums[i];
+        }
+        double ans = sum/k;
+        while(low+k!=nums.length){
+            sum-=nums[low];
+            sum+=nums[low+k];
+            ans = Math.max(ans,sum/k);
+            low++;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0643-maximum-average-subarray-i/NOTES.md b/leetcode/leetcode/0643-maximum-average-subarray-i/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0643-maximum-average-subarray-i/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0643-maximum-average-subarray-i/README.md b/leetcode/leetcode/0643-maximum-average-subarray-i/README.md
new file mode 100644
index 0000000..5b504df
--- /dev/null
+++ b/leetcode/leetcode/0643-maximum-average-subarray-i/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/maximum-average-subarray-i/">643. Maximum Average Subarray I</a></h2><h3>Easy</h3><hr><div><p>You are given an integer array <code>nums</code> consisting of <code>n</code> elements, and an integer <code>k</code>.</p>
+
+<p>Find a contiguous subarray whose <strong>length is equal to</strong> <code>k</code> that has the maximum average value and return <em>this value</em>. Any answer with a calculation error less than <code>10<sup>-5</sup></code> will be accepted.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,12,-5,-6,50,3], k = 4
+<strong>Output:</strong> 12.75000
+<strong>Explanation:</strong> Maximum average is (12 - 5 - 6 + 50) / 4 = 51 / 4 = 12.75
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [5], k = 1
+<strong>Output:</strong> 5.00000
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= k &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0713-subarray-product-less-than-k/0713-subarray-product-less-than-k.java b/leetcode/leetcode/0713-subarray-product-less-than-k/0713-subarray-product-less-than-k.java
new file mode 100644
index 0000000..ee4fa7c
--- /dev/null
+++ b/leetcode/leetcode/0713-subarray-product-less-than-k/0713-subarray-product-less-than-k.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int numSubarrayProductLessThanK(int[] nums, int k) {
+        int ans = 0;
+        int start = 0;
+        int end = 0;
+        int product = 1;
+        for(end = 0;end<nums.length; end++){
+            product = product*nums[end];
+            while(start<=end && product>=k){
+                product = product/nums[start];
+                start++;
+            }
+            ans+=end-start+1;
+            
+        }
+
+        return ans;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0713-subarray-product-less-than-k/README.md b/leetcode/leetcode/0713-subarray-product-less-than-k/README.md
new file mode 100644
index 0000000..b147fb6
--- /dev/null
+++ b/leetcode/leetcode/0713-subarray-product-less-than-k/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/subarray-product-less-than-k">713. Subarray Product Less Than K</a></h2><h3>Medium</h3><hr><p>Given an array of integers <code>nums</code> and an integer <code>k</code>, return <em>the number of contiguous subarrays where the product of all the elements in the subarray is strictly less than </em><code>k</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [10,5,2,6], k = 100
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> The 8 subarrays that have product less than 100 are:
+[10], [5], [2], [6], [10, 5], [5, 2], [2, 6], [5, 2, 6]
+Note that [10, 5, 2] is not included as the product of 100 is not strictly less than k.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3], k = 0
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 1000</code></li>
+	<li><code>0 &lt;= k &lt;= 10<sup>6</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0724-find-pivot-index/0724-find-pivot-index.java b/leetcode/leetcode/0724-find-pivot-index/0724-find-pivot-index.java
new file mode 100644
index 0000000..7a5f727
--- /dev/null
+++ b/leetcode/leetcode/0724-find-pivot-index/0724-find-pivot-index.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int pivotIndex(int[] nums) {
+        long sum = 0;
+        int left[] = new int[nums.length+1];
+        int right[] = new int[nums.length+1];
+        for(int i = 0;i<nums.length;i++){
+            left[i+1] = left[i]+nums[i];
+            right[nums.length-i-1] = right[nums.length-i]+nums[nums.length-i-1];
+        }
+
+        int index = -1;
+        for(int i = 0;i<nums.length;i++){
+            if(left[i] == right[i+1]){
+                return i;
+            }
+        }
+        return index;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0724-find-pivot-index/NOTES.md b/leetcode/leetcode/0724-find-pivot-index/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0724-find-pivot-index/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0724-find-pivot-index/README.md b/leetcode/leetcode/0724-find-pivot-index/README.md
new file mode 100644
index 0000000..c6b48db
--- /dev/null
+++ b/leetcode/leetcode/0724-find-pivot-index/README.md
@@ -0,0 +1,47 @@
+<h2><a href="https://leetcode.com/problems/find-pivot-index/">724. Find Pivot Index</a></h2><h3>Easy</h3><hr><div><p>Given an array of integers <code>nums</code>, calculate the <strong>pivot index</strong> of this array.</p>
+
+<p>The <strong>pivot index</strong> is the index where the sum of all the numbers <strong>strictly</strong> to the left of the index is equal to the sum of all the numbers <strong>strictly</strong> to the index's right.</p>
+
+<p>If the index is on the left edge of the array, then the left sum is <code>0</code> because there are no elements to the left. This also applies to the right edge of the array.</p>
+
+<p>Return <em>the <strong>leftmost pivot index</strong></em>. If no such index exists, return <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,7,3,6,5,6]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+The pivot index is 3.
+Left sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11
+Right sum = nums[4] + nums[5] = 5 + 6 = 11
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong>
+There is no index that satisfies the conditions in the problem statement.</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,1,-1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong>
+The pivot index is 0.
+Left sum = 0 (no elements to the left of index 0)
+Right sum = nums[1] + nums[2] = 1 + -1 = 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as&nbsp;1991:&nbsp;<a href="https://leetcode.com/problems/find-the-middle-index-in-array/" target="_blank">https://leetcode.com/problems/find-the-middle-index-in-array/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0725-split-linked-list-in-parts/0725-split-linked-list-in-parts.java b/leetcode/leetcode/0725-split-linked-list-in-parts/0725-split-linked-list-in-parts.java
new file mode 100644
index 0000000..b6bf4b5
--- /dev/null
+++ b/leetcode/leetcode/0725-split-linked-list-in-parts/0725-split-linked-list-in-parts.java
@@ -0,0 +1,48 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode[] splitListToParts(ListNode head, int k) {
+        // if(k == 1){
+
+        // }
+        int size = 0;
+        ListNode temp = head;
+        while(temp!=null){
+            temp = temp.next;
+            size++;
+        }
+        int splitSize = size / k;
+        int numRemainingParts = size % k;
+
+        ListNode[] result = new ListNode[k];
+        result[0] = head;
+        ListNode prev = null;
+        for(int i = 0;i<k;i++){
+            result[i] = head;
+            int groupSize = splitSize;
+            if (numRemainingParts > 0) {
+                numRemainingParts--;
+                groupSize++;
+            }
+            int j = 0;
+            while(head!=null && j<groupSize){
+                prev = head;
+                head = head.next;
+                j++;
+            } 
+            if(prev!=null) prev.next = null;
+        }
+        return result;
+
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0725-split-linked-list-in-parts/README.md b/leetcode/leetcode/0725-split-linked-list-in-parts/README.md
new file mode 100644
index 0000000..10e13a9
--- /dev/null
+++ b/leetcode/leetcode/0725-split-linked-list-in-parts/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/split-linked-list-in-parts">725. Split Linked List in Parts</a></h2><h3>Medium</h3><hr><p>Given the <code>head</code> of a singly linked list and an integer <code>k</code>, split the linked list into <code>k</code> consecutive linked list parts.</p>
+
+<p>The length of each part should be as equal as possible: no two parts should have a size differing by more than one. This may lead to some parts being null.</p>
+
+<p>The parts should be in the order of occurrence in the input list, and parts occurring earlier should always have a size greater than or equal to parts occurring later.</p>
+
+<p>Return <em>an array of the </em><code>k</code><em> parts</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/13/split1-lc.jpg" style="width: 400px; height: 134px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3], k = 5
+<strong>Output:</strong> [[1],[2],[3],[],[]]
+<strong>Explanation:</strong>
+The first element output[0] has output[0].val = 1, output[0].next = null.
+The last element output[4] is null, but its string representation as a ListNode is [].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/13/split2-lc.jpg" style="width: 600px; height: 60px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5,6,7,8,9,10], k = 3
+<strong>Output:</strong> [[1,2,3,4],[5,6,7],[8,9,10]]
+<strong>Explanation:</strong>
+The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 1000]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 1000</code></li>
+	<li><code>1 &lt;= k &lt;= 50</code></li>
+</ul>
diff --git a/leetcode/leetcode/0735-asteroid-collision/0735-asteroid-collision.java b/leetcode/leetcode/0735-asteroid-collision/0735-asteroid-collision.java
new file mode 100644
index 0000000..97f3553
--- /dev/null
+++ b/leetcode/leetcode/0735-asteroid-collision/0735-asteroid-collision.java
@@ -0,0 +1,37 @@
+class Solution {
+    public int[] asteroidCollision(int[] asteroids) {
+        Stack<Integer> s = new Stack<>();
+        int index = 0;
+        while(index<asteroids.length){
+            if(s.isEmpty()){
+                s.push(asteroids[index]);
+                index++;
+                continue;
+            }
+            if(s.peek() * asteroids[index] < 0 ){
+                if(s.peek()< 0 && asteroids[index]>0){
+                    s.push(asteroids[index]);
+                    index++;
+                }else if(s.peek() >0 && asteroids[index] < 0 ){
+                    if(Math.abs(s.peek()) > Math.abs(asteroids[index])){
+                        index++;
+                    }else if(Math.abs(s.peek()) < Math.abs(asteroids[index])){
+                        s.pop();
+                    }else{
+                        s.pop();
+                        index++;
+                    }
+                }
+            }else{
+                s.push(asteroids[index]);
+                index++;
+            }
+
+        }
+        int[] result = new int[s.size()];
+        for(int i = 0;i<result.length;i++){
+            result[result.length - i - 1] = s.pop();
+        } 
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0735-asteroid-collision/README.md b/leetcode/leetcode/0735-asteroid-collision/README.md
new file mode 100644
index 0000000..3ab52c8
--- /dev/null
+++ b/leetcode/leetcode/0735-asteroid-collision/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/asteroid-collision">735. Asteroid Collision</a></h2><h3>Medium</h3><hr><p>We are given an array <code>asteroids</code> of integers representing asteroids in a row. The indices of the asteriod in the array represent their relative position in space.</p>
+
+<p>For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.</p>
+
+<p>Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> asteroids = [5,10,-5]
+<strong>Output:</strong> [5,10]
+<strong>Explanation:</strong> The 10 and -5 collide resulting in 10. The 5 and 10 never collide.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> asteroids = [8,-8]
+<strong>Output:</strong> []
+<strong>Explanation:</strong> The 8 and -8 collide exploding each other.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> asteroids = [10,2,-5]
+<strong>Output:</strong> [10]
+<strong>Explanation:</strong> The 2 and -5 collide resulting in -5. The 10 and -5 collide resulting in 10.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= asteroids.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= asteroids[i] &lt;= 1000</code></li>
+	<li><code>asteroids[i] != 0</code></li>
+</ul>
diff --git a/leetcode/leetcode/0739-daily-temperatures/0739-daily-temperatures.java b/leetcode/leetcode/0739-daily-temperatures/0739-daily-temperatures.java
new file mode 100644
index 0000000..2911044
--- /dev/null
+++ b/leetcode/leetcode/0739-daily-temperatures/0739-daily-temperatures.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int[] dailyTemperatures(int[] temperatures) {
+       Stack<Integer> s = new Stack<>();
+        int[] ans = new int[temperatures.length];
+        for(int i = 0;i<temperatures.length;i++){
+            while(!s.isEmpty() && temperatures[s.peek()]<temperatures[i]){
+                ans[s.peek()] = i - s.peek();
+                s.pop();
+            }
+            s.push(i);
+       } 
+       return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0739-daily-temperatures/README.md b/leetcode/leetcode/0739-daily-temperatures/README.md
new file mode 100644
index 0000000..5c61532
--- /dev/null
+++ b/leetcode/leetcode/0739-daily-temperatures/README.md
@@ -0,0 +1,20 @@
+<h2><a href="https://leetcode.com/problems/daily-temperatures">739. Daily Temperatures</a></h2><h3>Medium</h3><hr><p>Given an array of integers <code>temperatures</code> represents the daily temperatures, return <em>an array</em> <code>answer</code> <em>such that</em> <code>answer[i]</code> <em>is the number of days you have to wait after the</em> <code>i<sup>th</sup></code> <em>day to get a warmer temperature</em>. If there is no future day for which this is possible, keep <code>answer[i] == 0</code> instead.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<pre><strong>Input:</strong> temperatures = [73,74,75,71,69,72,76,73]
+<strong>Output:</strong> [1,1,4,2,1,1,0,0]
+</pre><p><strong class="example">Example 2:</strong></p>
+<pre><strong>Input:</strong> temperatures = [30,40,50,60]
+<strong>Output:</strong> [1,1,1,0]
+</pre><p><strong class="example">Example 3:</strong></p>
+<pre><strong>Input:</strong> temperatures = [30,60,90]
+<strong>Output:</strong> [1,1,0]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;=&nbsp;temperatures.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>30 &lt;=&nbsp;temperatures[i] &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0763-partition-labels/0763-partition-labels.java b/leetcode/leetcode/0763-partition-labels/0763-partition-labels.java
new file mode 100644
index 0000000..65f6ade
--- /dev/null
+++ b/leetcode/leetcode/0763-partition-labels/0763-partition-labels.java
@@ -0,0 +1,28 @@
+class Solution {
+    public List<Integer> partitionLabels(String s) {
+        HashMap<Character,Integer> map = new HashMap<>();
+        for(int i = s.length()-1;i!=-1;i--){
+            if(!map.containsKey(s.charAt(i))){
+                map.put(s.charAt(i),i);
+            }
+        }
+        int begin = 0;
+        int end = map.get(s.charAt(0));
+        ArrayList<Integer> list = new ArrayList<>();
+        while(begin!=s.length()){
+            end = map.get(s.charAt(begin));
+            int temp = begin;
+            while(temp!=end){
+                int nextCharEnd = map.get(s.charAt(temp));
+                if(nextCharEnd>end){
+                    end = nextCharEnd;
+                }
+                if(end ==s.length()-1 ) break;
+                temp++;
+            }
+            list.add(end-begin+1);
+            begin = end+1;
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0763-partition-labels/NOTES.md b/leetcode/leetcode/0763-partition-labels/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0763-partition-labels/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0763-partition-labels/README.md b/leetcode/leetcode/0763-partition-labels/README.md
new file mode 100644
index 0000000..7a526d8
--- /dev/null
+++ b/leetcode/leetcode/0763-partition-labels/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/partition-labels/">763. Partition Labels</a></h2><h3>Medium</h3><hr><div><p>You are given a string <code>s</code>. We want to partition the string into as many parts as possible so that each letter appears in at most one part.</p>
+
+<p>Note that the partition is done so that after concatenating all the parts in order, the resultant string should be <code>s</code>.</p>
+
+<p>Return <em>a list of integers representing the size of these parts</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "ababcbacadefegdehijhklij"
+<strong>Output:</strong> [9,7,8]
+<strong>Explanation:</strong>
+The partition is "ababcbaca", "defegde", "hijhklij".
+This is a partition so that each letter appears in at most one part.
+A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits s into less parts.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "eccbbbbdec"
+<strong>Output:</strong> [10]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 500</code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0768-partition-labels/0768-partition-labels.java b/leetcode/leetcode/0768-partition-labels/0768-partition-labels.java
new file mode 100644
index 0000000..e2467a6
--- /dev/null
+++ b/leetcode/leetcode/0768-partition-labels/0768-partition-labels.java
@@ -0,0 +1,30 @@
+class Solution {
+    public boolean isValid(int[] freq, int[] allFreq){
+        for(int i =0;i<26;i++){
+            if(freq[i]!=0 && freq[i] != allFreq[i]  ) return false;
+            
+        }
+        return true;
+    }
+    public List<Integer> partitionLabels(String s) {
+
+        int[] freq = new int[26];
+        int[] allFreq = new int[26];
+        for(int i = 0; i<s.length();i++){
+            allFreq[s.charAt(i) - 'a']++;
+        }
+        List<Integer> result = new ArrayList<>();
+        for(int l= 0, r = 0;r<s.length();r++){
+            freq[s.charAt(r)-'a']++;
+            boolean flag = isValid(freq,allFreq);
+            if(flag){
+                result.add(r-l+1);
+                l = r+1;
+                for(int i = 0;i<26;i++){
+                    freq[i] = 0;
+                }
+            }
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0768-partition-labels/README.md b/leetcode/leetcode/0768-partition-labels/README.md
new file mode 100644
index 0000000..6c15e4b
--- /dev/null
+++ b/leetcode/leetcode/0768-partition-labels/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/partition-labels">768. Partition Labels</a></h2><h3>Medium</h3><hr><p>You are given a string <code>s</code>. We want to partition the string into as many parts as possible so that each letter appears in at most one part. For example, the string <code>&quot;ababcc&quot;</code> can be partitioned into <code>[&quot;abab&quot;, &quot;cc&quot;]</code>, but partitions such as <code>[&quot;aba&quot;, &quot;bcc&quot;]</code> or <code>[&quot;ab&quot;, &quot;ab&quot;, &quot;cc&quot;]</code> are invalid.</p>
+
+<p>Note that the partition is done so that after concatenating all the parts in order, the resultant string should be <code>s</code>.</p>
+
+<p>Return <em>a list of integers representing the size of these parts</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;ababcbacadefegdehijhklij&quot;
+<strong>Output:</strong> [9,7,8]
+<strong>Explanation:</strong>
+The partition is &quot;ababcbaca&quot;, &quot;defegde&quot;, &quot;hijhklij&quot;.
+This is a partition so that each letter appears in at most one part.
+A partition like &quot;ababcbacadefegde&quot;, &quot;hijhklij&quot; is incorrect, because it splits s into less parts.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;eccbbbbdec&quot;
+<strong>Output:</strong> [10]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 500</code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+</ul>
diff --git a/leetcode/leetcode/0783-search-in-a-binary-search-tree/0783-search-in-a-binary-search-tree.py b/leetcode/leetcode/0783-search-in-a-binary-search-tree/0783-search-in-a-binary-search-tree.py
new file mode 100644
index 0000000..579b6d2
--- /dev/null
+++ b/leetcode/leetcode/0783-search-in-a-binary-search-tree/0783-search-in-a-binary-search-tree.py
@@ -0,0 +1,13 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
+        if(root == None): return root
+        if(root.val == val): return root
+        elif(root.val>val): return self.searchBST(root.left,val)
+        else: return self.searchBST(root.right,val)
+
diff --git a/leetcode/leetcode/0783-search-in-a-binary-search-tree/README.md b/leetcode/leetcode/0783-search-in-a-binary-search-tree/README.md
new file mode 100644
index 0000000..0ebb87b
--- /dev/null
+++ b/leetcode/leetcode/0783-search-in-a-binary-search-tree/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/search-in-a-binary-search-tree">783. Search in a Binary Search Tree</a></h2><h3>Easy</h3><hr><p>You are given the <code>root</code> of a binary search tree (BST) and an integer <code>val</code>.</p>
+
+<p>Find the node in the BST that the node&#39;s value equals <code>val</code> and return the subtree rooted with that node. If such a node does not exist, return <code>null</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/12/tree1.jpg" style="width: 422px; height: 302px;" />
+<pre>
+<strong>Input:</strong> root = [4,2,7,1,3], val = 2
+<strong>Output:</strong> [2,1,3]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/12/tree2.jpg" style="width: 422px; height: 302px;" />
+<pre>
+<strong>Input:</strong> root = [4,2,7,1,3], val = 5
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 5000]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>7</sup></code></li>
+	<li><code>root</code> is a binary search tree.</li>
+	<li><code>1 &lt;= val &lt;= 10<sup>7</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0784-insert-into-a-binary-search-tree/0784-insert-into-a-binary-search-tree.java b/leetcode/leetcode/0784-insert-into-a-binary-search-tree/0784-insert-into-a-binary-search-tree.java
new file mode 100644
index 0000000..b1134cb
--- /dev/null
+++ b/leetcode/leetcode/0784-insert-into-a-binary-search-tree/0784-insert-into-a-binary-search-tree.java
@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode insertIntoBST(TreeNode root, int val) {
+        if(root == null) return new TreeNode(val);
+
+        if(root.val>val){
+            root.left = insertIntoBST(root.left,val);
+        }else{
+            root.right = insertIntoBST(root.right,val);
+        }
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0784-insert-into-a-binary-search-tree/0784-insert-into-a-binary-search-tree.py b/leetcode/leetcode/0784-insert-into-a-binary-search-tree/0784-insert-into-a-binary-search-tree.py
new file mode 100644
index 0000000..f167575
--- /dev/null
+++ b/leetcode/leetcode/0784-insert-into-a-binary-search-tree/0784-insert-into-a-binary-search-tree.py
@@ -0,0 +1,15 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def insertIntoBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
+        if(root == None): return TreeNode(val)
+        if(root.val>val):
+            root.left = self.insertIntoBST(root.left,val)
+        else:
+            root.right = self.insertIntoBST(root.right,val)
+        
+        return root
\ No newline at end of file
diff --git a/leetcode/leetcode/0784-insert-into-a-binary-search-tree/README.md b/leetcode/leetcode/0784-insert-into-a-binary-search-tree/README.md
new file mode 100644
index 0000000..f047773
--- /dev/null
+++ b/leetcode/leetcode/0784-insert-into-a-binary-search-tree/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/insert-into-a-binary-search-tree">784. Insert into a Binary Search Tree</a></h2><h3>Medium</h3><hr><p>You are given the <code>root</code> node of a binary search tree (BST) and a <code>value</code> to insert into the tree. Return <em>the root node of the BST after the insertion</em>. It is <strong>guaranteed</strong> that the new value does not exist in the original BST.</p>
+
+<p><strong>Notice</strong>&nbsp;that there may exist&nbsp;multiple valid ways for the&nbsp;insertion, as long as the tree remains a BST after insertion. You can return <strong>any of them</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/05/insertbst.jpg" style="width: 752px; height: 221px;" />
+<pre>
+<strong>Input:</strong> root = [4,2,7,1,3], val = 5
+<strong>Output:</strong> [4,2,7,1,3,5]
+<strong>Explanation:</strong> Another accepted tree is:
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/05/bst.jpg" style="width: 352px; height: 301px;" />
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [40,20,60,10,30,50,70], val = 25
+<strong>Output:</strong> [40,20,60,10,30,50,70,null,null,25]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
+<strong>Output:</strong> [4,2,7,1,3,5]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in&nbsp;the tree will be in the range <code>[0,&nbsp;10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>8</sup> &lt;= Node.val &lt;= 10<sup>8</sup></code></li>
+	<li>All the values <code>Node.val</code> are <strong>unique</strong>.</li>
+	<li><code>-10<sup>8</sup> &lt;= val &lt;= 10<sup>8</sup></code></li>
+	<li>It&#39;s <strong>guaranteed</strong> that <code>val</code> does not exist in the original BST.</li>
+</ul>
diff --git a/leetcode/leetcode/0820-find-eventual-safe-states/0820-find-eventual-safe-states.java b/leetcode/leetcode/0820-find-eventual-safe-states/0820-find-eventual-safe-states.java
new file mode 100644
index 0000000..0f2aa80
--- /dev/null
+++ b/leetcode/leetcode/0820-find-eventual-safe-states/0820-find-eventual-safe-states.java
@@ -0,0 +1,34 @@
+class Solution {
+    public boolean dfs(int[][] graph, int currNode, boolean[] unSafeNode, boolean[] visited){
+        if(unSafeNode[currNode]) return true;
+        if(visited[currNode]) return false;
+
+        visited[currNode] = true;
+        unSafeNode[currNode] = true;
+        for(int node: graph[currNode]){
+            if(dfs(graph,node,unSafeNode,visited)){
+                return true;
+            }
+        }
+        unSafeNode[currNode] = false;
+        return false;
+    }
+    public List<Integer> eventualSafeNodes(int[][] graph) {
+        int n = graph.length;
+        boolean[] visit = new boolean[n];
+        boolean[] inStack = new boolean[n];
+        for (int i = 0; i < n; i++) {
+            dfs(graph, i, inStack, visit);
+        }
+
+        List<Integer> safeNodes = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (!inStack[i]) {
+                safeNodes.add(i);
+            }
+        }
+
+        return safeNodes;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0820-find-eventual-safe-states/README.md b/leetcode/leetcode/0820-find-eventual-safe-states/README.md
new file mode 100644
index 0000000..59c3927
--- /dev/null
+++ b/leetcode/leetcode/0820-find-eventual-safe-states/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/find-eventual-safe-states">820. Find Eventual Safe States</a></h2><h3>Medium</h3><hr><p>There is a directed graph of <code>n</code> nodes with each node labeled from <code>0</code> to <code>n - 1</code>. The graph is represented by a <strong>0-indexed</strong> 2D integer array <code>graph</code> where <code>graph[i]</code> is an integer array of nodes adjacent to node <code>i</code>, meaning there is an edge from node <code>i</code> to each node in <code>graph[i]</code>.</p>
+
+<p>A node is a <strong>terminal node</strong> if there are no outgoing edges. A node is a <strong>safe node</strong> if every possible path starting from that node leads to a <strong>terminal node</strong> (or another safe node).</p>
+
+<p>Return <em>an array containing all the <strong>safe nodes</strong> of the graph</em>. The answer should be sorted in <strong>ascending</strong> order.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="Illustration of graph" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/03/17/picture1.png" style="height: 171px; width: 600px;" />
+<pre>
+<strong>Input:</strong> graph = [[1,2],[2,3],[5],[0],[5],[],[]]
+<strong>Output:</strong> [2,4,5,6]
+<strong>Explanation:</strong> The given graph is shown above.
+Nodes 5 and 6 are terminal nodes as there are no outgoing edges from either of them.
+Every path starting at nodes 2, 4, 5, and 6 all lead to either node 5 or 6.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> graph = [[1,2,3,4],[1,2],[3,4],[0,4],[]]
+<strong>Output:</strong> [4]
+<strong>Explanation:</strong>
+Only node 4 is a terminal node, and every path starting at node 4 leads to node 4.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == graph.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= graph[i].length &lt;= n</code></li>
+	<li><code>0 &lt;= graph[i][j] &lt;= n - 1</code></li>
+	<li><code>graph[i]</code> is sorted in a strictly increasing order.</li>
+	<li>The graph may contain self-loops.</li>
+	<li>The number of edges in the graph will be in the range <code>[1, 4 * 10<sup>4</sup>]</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0838-design-linked-list/0838-design-linked-list.java b/leetcode/leetcode/0838-design-linked-list/0838-design-linked-list.java
new file mode 100644
index 0000000..8cd1124
--- /dev/null
+++ b/leetcode/leetcode/0838-design-linked-list/0838-design-linked-list.java
@@ -0,0 +1,135 @@
+class MyLinkedList {
+    // Double Linked List;
+    class Node{
+        int val;
+        Node next;
+        Node prev;
+        Node(int val){
+            this.val = val;
+            next = null;
+            prev = null;
+        }
+    }
+    Node head;
+    Node tail;
+    int size;
+    public MyLinkedList() {
+        head = null;
+        tail = null;
+        size = 0;
+
+    }
+    
+    public int get(int index) {
+        if(index<0 || index>=size) return -1; // out of index
+
+        Node temp = head;
+        int  currentIndex = 0;
+        while(currentIndex!=index){
+            temp = temp.next;
+            currentIndex++;
+        }
+        return temp.val;
+    }
+    
+    public void addAtHead(int val) {
+        if(size == 0){
+            Node newNode = new Node(val);
+            head = newNode;
+            tail = newNode;
+            size++;
+            return;
+        }else{
+            Node newNode = new Node(val);
+            newNode.next = head;
+            head.prev    = newNode;
+            head = newNode;
+            size++;
+            return;
+        }
+    }
+    // 1<->2<->3<->null
+//     h       t   <>4
+    public void addAtTail(int val) {
+        if(size == 0){
+            addAtHead(val);
+        }else{
+            Node newNode = new Node(val);
+            newNode.prev = tail;
+            tail.next    = newNode;
+            tail = newNode;
+            size++;
+        }
+    }
+    // 1<->2<->3<->4<->null
+    // 0  t  1   2   3
+    //   t   
+
+    public void addAtIndex(int index, int val) {
+        if(index<0 || index>size) return;
+        if(index == 0){
+            addAtHead(val);
+            return;
+        }
+        if(index == size){
+            addAtTail(val);
+            return;
+        }
+        Node newNode = new Node(val);
+        int currentIndex = 0;
+        Node temp        = head;
+        while(currentIndex<index-1){
+            temp = temp.next;
+            currentIndex++;
+        }
+        Node next = temp.next;
+        newNode.next = next;
+        newNode.prev = temp;
+        temp.next = newNode;
+        next.prev = newNode;
+        size++;
+    }
+    
+    public void deleteAtIndex(int index) {
+        if(index<0 || index>=size) return;
+
+        if(index == 0) {
+            if(size == 1){
+                head = tail = null;
+                size = 0;
+                return;
+            }else{
+                head = head.next;
+                head.prev = null;
+                size--;
+                return;
+            }
+        }else if(index == size - 1){
+            tail = tail.prev;
+            tail.next = null;
+            size--;
+            return;
+        }else{
+            int currentIndex = 0;
+            Node temp = head;
+            while(currentIndex<index-1){
+                temp = temp.next;
+                currentIndex++;
+            }
+            temp.next = temp.next.next;
+            temp.next.prev = temp;
+            size--;
+
+        }
+    }
+}
+
+/**
+ * Your MyLinkedList object will be instantiated and called as such:
+ * MyLinkedList obj = new MyLinkedList();
+ * int param_1 = obj.get(index);
+ * obj.addAtHead(val);
+ * obj.addAtTail(val);
+ * obj.addAtIndex(index,val);
+ * obj.deleteAtIndex(index);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/0838-design-linked-list/README.md b/leetcode/leetcode/0838-design-linked-list/README.md
new file mode 100644
index 0000000..59ef517
--- /dev/null
+++ b/leetcode/leetcode/0838-design-linked-list/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/design-linked-list">838. Design Linked List</a></h2><h3>Medium</h3><hr><p>Design your implementation of the linked list. You can choose to use a singly or doubly linked list.<br />
+A node in a singly linked list should have two attributes: <code>val</code> and <code>next</code>. <code>val</code> is the value of the current node, and <code>next</code> is a pointer/reference to the next node.<br />
+If you want to use the doubly linked list, you will need one more attribute <code>prev</code> to indicate the previous node in the linked list. Assume all nodes in the linked list are <strong>0-indexed</strong>.</p>
+
+<p>Implement the <code>MyLinkedList</code> class:</p>
+
+<ul>
+	<li><code>MyLinkedList()</code> Initializes the <code>MyLinkedList</code> object.</li>
+	<li><code>int get(int index)</code> Get the value of the <code>index<sup>th</sup></code> node in the linked list. If the index is invalid, return <code>-1</code>.</li>
+	<li><code>void addAtHead(int val)</code> Add a node of value <code>val</code> before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.</li>
+	<li><code>void addAtTail(int val)</code> Append a node of value <code>val</code> as the last element of the linked list.</li>
+	<li><code>void addAtIndex(int index, int val)</code> Add a node of value <code>val</code> before the <code>index<sup>th</sup></code> node in the linked list. If <code>index</code> equals the length of the linked list, the node will be appended to the end of the linked list. If <code>index</code> is greater than the length, the node <strong>will not be inserted</strong>.</li>
+	<li><code>void deleteAtIndex(int index)</code> Delete the <code>index<sup>th</sup></code> node in the linked list, if the index is valid.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input</strong>
+[&quot;MyLinkedList&quot;, &quot;addAtHead&quot;, &quot;addAtTail&quot;, &quot;addAtIndex&quot;, &quot;get&quot;, &quot;deleteAtIndex&quot;, &quot;get&quot;]
+[[], [1], [3], [1, 2], [1], [1], [1]]
+<strong>Output</strong>
+[null, null, null, null, 2, null, 3]
+
+<strong>Explanation</strong>
+MyLinkedList myLinkedList = new MyLinkedList();
+myLinkedList.addAtHead(1);
+myLinkedList.addAtTail(3);
+myLinkedList.addAtIndex(1, 2);    // linked list becomes 1-&gt;2-&gt;3
+myLinkedList.get(1);              // return 2
+myLinkedList.deleteAtIndex(1);    // now the linked list is 1-&gt;3
+myLinkedList.get(1);              // return 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= index, val &lt;= 1000</code></li>
+	<li>Please do not use the built-in LinkedList library.</li>
+	<li>At most <code>2000</code> calls will be made to <code>get</code>, <code>addAtHead</code>, <code>addAtTail</code>, <code>addAtIndex</code> and <code>deleteAtIndex</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0844-backspace-string-compare/0844-backspace-string-compare.java b/leetcode/leetcode/0844-backspace-string-compare/0844-backspace-string-compare.java
new file mode 100644
index 0000000..93546f5
--- /dev/null
+++ b/leetcode/leetcode/0844-backspace-string-compare/0844-backspace-string-compare.java
@@ -0,0 +1,22 @@
+class Solution {
+    public boolean backspaceCompare(String s, String t) {
+        StringBuilder sb1 = new StringBuilder();
+        for(int i = 0;i<s.length();i++){
+            
+            if(s.charAt(i) == '#') {
+                if(sb1.length() == 0) continue;
+                sb1.deleteCharAt(sb1.length() - 1);
+            }
+            else sb1.append(s.charAt(i));
+        }
+        StringBuilder sb2 = new StringBuilder();
+        for(int i=0;i<t.length();i++){
+            if(t.charAt(i) == '#') {
+                if(sb2.length() == 0) continue;
+                sb2.deleteCharAt(sb2.length() - 1);
+            }
+            else sb2.append(t.charAt(i));
+        }
+        return sb1.toString().equals(sb2.toString());
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0844-backspace-string-compare/NOTES.md b/leetcode/leetcode/0844-backspace-string-compare/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0844-backspace-string-compare/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0844-backspace-string-compare/README.md b/leetcode/leetcode/0844-backspace-string-compare/README.md
new file mode 100644
index 0000000..7b43fce
--- /dev/null
+++ b/leetcode/leetcode/0844-backspace-string-compare/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/backspace-string-compare/">844. Backspace String Compare</a></h2><h3>Easy</h3><hr><div><p>Given two strings <code>s</code> and <code>t</code>, return <code>true</code> <em>if they are equal when both are typed into empty text editors</em>. <code>'#'</code> means a backspace character.</p>
+
+<p>Note that after backspacing an empty text, the text will continue empty.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "ab#c", t = "ad#c"
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Both s and t become "ac".
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "ab##", t = "c#d#"
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Both s and t become "".
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "a#c", t = "b"
+<strong>Output:</strong> false
+<strong>Explanation:</strong> s becomes "c" while t becomes "b".
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code><span>1 &lt;= s.length, t.length &lt;= 200</span></code></li>
+	<li><span><code>s</code> and <code>t</code> only contain lowercase letters and <code>'#'</code> characters.</span></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Can you solve it in <code>O(n)</code> time and <code>O(1)</code> space?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0872-leaf-similar-trees/0872-leaf-similar-trees.java b/leetcode/leetcode/0872-leaf-similar-trees/0872-leaf-similar-trees.java
new file mode 100644
index 0000000..8dba42a
--- /dev/null
+++ b/leetcode/leetcode/0872-leaf-similar-trees/0872-leaf-similar-trees.java
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> lastLevel(TreeNode root){
+        if(root==null) return new ArrayList<>();
+        List<Integer> list = new ArrayList<>();
+        Stack<TreeNode> s = new Stack<>();
+        s.add(root);
+        while(!s.isEmpty()){
+            root = s.pop();
+            if(root.left == null && root.right==null){
+                list.add(root.val);
+                continue;
+            }
+            if(root.left!=null) s.push(root.left);
+            if(root.right!=null) s.push(root.right);
+
+        }
+        return list;
+    }
+    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
+        List<Integer> list1 = lastLevel(root1);
+        List<Integer> list2 = lastLevel(root2);
+        return list1.equals(list2);
+       
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0872-leaf-similar-trees/NOTES.md b/leetcode/leetcode/0872-leaf-similar-trees/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0872-leaf-similar-trees/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0872-leaf-similar-trees/README.md b/leetcode/leetcode/0872-leaf-similar-trees/README.md
new file mode 100644
index 0000000..71da5fe
--- /dev/null
+++ b/leetcode/leetcode/0872-leaf-similar-trees/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/leaf-similar-trees/">872. Leaf-Similar Trees</a></h2><h3>Easy</h3><hr><div><p>Consider all the leaves of a binary tree, from&nbsp;left to right order, the values of those&nbsp;leaves form a <strong>leaf value sequence</strong><em>.</em></p>
+
+<p><img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/16/tree.png" style="width: 400px; height: 336px;"></p>
+
+<p>For example, in the given tree above, the leaf value sequence is <code>(6, 7, 4, 9, 8)</code>.</p>
+
+<p>Two binary trees are considered <em>leaf-similar</em>&nbsp;if their leaf value sequence is the same.</p>
+
+<p>Return <code>true</code> if and only if the two given trees with head nodes <code>root1</code> and <code>root2</code> are leaf-similar.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/03/leaf-similar-1.jpg" style="width: 600px; height: 237px;">
+<pre><strong>Input:</strong> root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/03/leaf-similar-2.jpg" style="width: 300px; height: 110px;">
+<pre><strong>Input:</strong> root1 = [1,2,3], root2 = [1,3,2]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in each tree will be in the range <code>[1, 200]</code>.</li>
+	<li>Both of the given trees will have values in the range <code>[0, 200]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0884-uncommon-words-from-two-sentences/0884-uncommon-words-from-two-sentences.java b/leetcode/leetcode/0884-uncommon-words-from-two-sentences/0884-uncommon-words-from-two-sentences.java
new file mode 100644
index 0000000..af397bd
--- /dev/null
+++ b/leetcode/leetcode/0884-uncommon-words-from-two-sentences/0884-uncommon-words-from-two-sentences.java
@@ -0,0 +1,34 @@
+class Solution {
+    public String[] uncommonFromSentences(String s1, String s2) {
+        HashSet<String> ignore = new HashSet<>();
+        HashSet<String> ans = new HashSet<>();
+        String[] list1 = s1.split(" ");
+        for(String word: list1){
+            if(ignore.contains(word)) continue;
+            if(ans.contains(word)){
+                ans.remove(word);
+                ignore.add(word);
+                continue;
+            }
+            ans.add(word);
+        }
+        String[] list2 = s2.split(" ");
+        for(String word: list2){
+            if(ignore.contains(word)) continue;
+            if(ans.contains(word)){
+                ans.remove(word);
+                ignore.add(word);
+                continue;
+            }
+            ans.add(word);
+        }
+        int n = ans.size(); 
+        String arr[] = new String[n]; 
+  
+        int i = 0; 
+        for (String x :ans) 
+            arr[i++] = x;
+        return arr;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0884-uncommon-words-from-two-sentences/NOTES.md b/leetcode/leetcode/0884-uncommon-words-from-two-sentences/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0884-uncommon-words-from-two-sentences/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0884-uncommon-words-from-two-sentences/README.md b/leetcode/leetcode/0884-uncommon-words-from-two-sentences/README.md
new file mode 100644
index 0000000..1ba5734
--- /dev/null
+++ b/leetcode/leetcode/0884-uncommon-words-from-two-sentences/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/uncommon-words-from-two-sentences/">884. Uncommon Words from Two Sentences</a></h2><h3>Easy</h3><hr><div><p>A <strong>sentence</strong> is a string of single-space separated words where each word consists only of lowercase letters.</p>
+
+<p>A word is <strong>uncommon</strong> if it appears exactly once in one of the sentences, and <strong>does not appear</strong> in the other sentence.</p>
+
+<p>Given two <strong>sentences</strong> <code>s1</code> and <code>s2</code>, return <em>a list of all the <strong>uncommon words</strong></em>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s1 = "this apple is sweet", s2 = "this apple is sour"</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">["sweet","sour"]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The word <code>"sweet"</code> appears only in <code>s1</code>, while the word <code>"sour"</code> appears only in <code>s2</code>.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s1 = "apple apple", s2 = "banana"</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">["banana"]</span></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s1.length, s2.length &lt;= 200</code></li>
+	<li><code>s1</code> and <code>s2</code> consist of lowercase English letters and spaces.</li>
+	<li><code>s1</code> and <code>s2</code> do not have leading or trailing spaces.</li>
+	<li>All the words in <code>s1</code> and <code>s2</code> are separated by a single space.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0894-all-possible-full-binary-trees/0894-all-possible-full-binary-trees.java b/leetcode/leetcode/0894-all-possible-full-binary-trees/0894-all-possible-full-binary-trees.java
new file mode 100644
index 0000000..c5a852e
--- /dev/null
+++ b/leetcode/leetcode/0894-all-possible-full-binary-trees/0894-all-possible-full-binary-trees.java
@@ -0,0 +1,57 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<TreeNode> helper(int n,HashMap<Integer,List<TreeNode>> map){
+        if(n%2 == 0){
+            return new ArrayList<>();
+        }
+        if(map.containsKey(n)) return map.get(n);
+        if(n==1){
+            TreeNode root = new TreeNode(0);
+            List<TreeNode> res = new ArrayList<>();
+            res.add(root);
+            map.put(1,res);
+            return res;
+
+        }
+        List<TreeNode> result = new ArrayList<>();
+        int temp1 = 1;
+        int temp2 = n - 2;
+        while(temp2>0){
+            List<TreeNode> left = helper(temp1,map);
+            List<TreeNode> right = helper(temp2,map);
+            for(int i = 0;i<left.size();i++){
+                for(int j = 0;j<right.size();j++){
+                    TreeNode root = new TreeNode(0);
+                    root.left = left.get(i);
+                    root.right = right.get(j);
+                    result.add(root);
+                }
+            }
+            temp1+=2;
+            temp2-=2;
+        }
+        map.put(n,result);
+        return result;
+
+    }
+    public List<TreeNode> allPossibleFBT(int n) {
+
+        // List<TreeNode>[] list = new List<TreeNode>[n];
+        return helper(n,new HashMap<Integer,List<TreeNode>>());
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0894-all-possible-full-binary-trees/NOTES.md b/leetcode/leetcode/0894-all-possible-full-binary-trees/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0894-all-possible-full-binary-trees/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0894-all-possible-full-binary-trees/README.md b/leetcode/leetcode/0894-all-possible-full-binary-trees/README.md
new file mode 100644
index 0000000..6a00abb
--- /dev/null
+++ b/leetcode/leetcode/0894-all-possible-full-binary-trees/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/all-possible-full-binary-trees/">894. All Possible Full Binary Trees</a></h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, return <em>a list of all possible <strong>full binary trees</strong> with</em> <code>n</code> <em>nodes</em>. Each node of each tree in the answer must have <code>Node.val == 0</code>.</p>
+
+<p>Each element of the answer is the root node of one possible tree. You may return the final list of trees in <strong>any order</strong>.</p>
+
+<p>A <strong>full binary tree</strong> is a binary tree where each node has exactly <code>0</code> or <code>2</code> children.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/08/22/fivetrees.png" style="width: 700px; height: 400px;">
+<pre><strong>Input:</strong> n = 7
+<strong>Output:</strong> [[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> [[0,0,0]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 20</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0907-koko-eating-bananas/0907-koko-eating-bananas.java b/leetcode/leetcode/0907-koko-eating-bananas/0907-koko-eating-bananas.java
new file mode 100644
index 0000000..2f1fe29
--- /dev/null
+++ b/leetcode/leetcode/0907-koko-eating-bananas/0907-koko-eating-bananas.java
@@ -0,0 +1,34 @@
+class Solution {
+    boolean canKokoFinish(int[] piles, int hourLimit, int eatingSpeed){
+        int hourTaken = 0;
+        for(int num: piles){
+            hourTaken += num/eatingSpeed;
+            if(num%eatingSpeed!=0) hourTaken++;
+            if(hourTaken>hourLimit) return false;
+        }
+        return true;
+    }
+    
+    public int minEatingSpeed(int[] piles, int h) {
+        int maxSpeed = 1;
+
+        for(int num: piles){
+            // minSpeed = Math.min(num,minSpeed);
+            maxSpeed = Math.max(num,maxSpeed);
+        }
+        int ans = maxSpeed;
+        int low = 1;
+        int high = maxSpeed;
+        while(low<=high){
+            int mid = low + (high-low)/2;
+            if(canKokoFinish(piles,h,mid)){
+                ans  = Math.min(ans,mid);
+                high = mid - 1;
+            }else{
+                low = mid+1;
+            }
+        }
+        return ans;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0907-koko-eating-bananas/README.md b/leetcode/leetcode/0907-koko-eating-bananas/README.md
new file mode 100644
index 0000000..4fc2146
--- /dev/null
+++ b/leetcode/leetcode/0907-koko-eating-bananas/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/koko-eating-bananas">907. Koko Eating Bananas</a></h2><h3>Medium</h3><hr><p>Koko loves to eat bananas. There are <code>n</code> piles of bananas, the <code>i<sup>th</sup></code> pile has <code>piles[i]</code> bananas. The guards have gone and will come back in <code>h</code> hours.</p>
+
+<p>Koko can decide her bananas-per-hour eating speed of <code>k</code>. Each hour, she chooses some pile of bananas and eats <code>k</code> bananas from that pile. If the pile has less than <code>k</code> bananas, she eats all of them instead and will not eat any more bananas during this hour.</p>
+
+<p>Koko likes to eat slowly but still wants to finish eating all the bananas before the guards return.</p>
+
+<p>Return <em>the minimum integer</em> <code>k</code> <em>such that she can eat all the bananas within</em> <code>h</code> <em>hours</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> piles = [3,6,7,11], h = 8
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> piles = [30,11,23,4,20], h = 5
+<strong>Output:</strong> 30
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> piles = [30,11,23,4,20], h = 6
+<strong>Output:</strong> 23
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= piles.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>piles.length &lt;= h &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= piles[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0908-middle-of-the-linked-list/0908-middle-of-the-linked-list.java b/leetcode/leetcode/0908-middle-of-the-linked-list/0908-middle-of-the-linked-list.java
new file mode 100644
index 0000000..6eb7f3c
--- /dev/null
+++ b/leetcode/leetcode/0908-middle-of-the-linked-list/0908-middle-of-the-linked-list.java
@@ -0,0 +1,58 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode middleNode(ListNode head) {
+        // Approach 1: Count  (Iteratively)
+        // if(head == null) return null;
+        // ListNode temp = head;
+        // int count = 0;
+        // while(temp!=null){
+        //     count++;
+        //     temp = temp.next;
+        // }
+        // int middleIndex = (count)/2;
+        // temp = head;
+        // while(middleIndex !=0){
+        //     temp = temp.next;
+        //     middleIndex--;
+        // }
+        // return temp;
+
+        // Approach 2: Slow and Fast pointer approach
+        if(head == null) return null;
+        ListNode slow = head;
+        ListNode fast = head;
+
+        while(fast!=null && fast.next!=null){
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return slow;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0908-middle-of-the-linked-list/README.md b/leetcode/leetcode/0908-middle-of-the-linked-list/README.md
new file mode 100644
index 0000000..8901a7b
--- /dev/null
+++ b/leetcode/leetcode/0908-middle-of-the-linked-list/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/middle-of-the-linked-list">908. Middle of the Linked List</a></h2><h3>Easy</h3><hr><p>Given the <code>head</code> of a singly linked list, return <em>the middle node of the linked list</em>.</p>
+
+<p>If there are two middle nodes, return <strong>the second middle</strong> node.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/07/23/lc-midlist1.jpg" style="width: 544px; height: 65px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5]
+<strong>Output:</strong> [3,4,5]
+<strong>Explanation:</strong> The middle node of the list is node 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/07/23/lc-midlist2.jpg" style="width: 664px; height: 65px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4,5,6]
+<strong>Output:</strong> [4,5,6]
+<strong>Explanation:</strong> Since the list has two middle nodes with values 3 and 4, we return the second one.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 100]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0925-construct-binary-tree-from-preorder-and-postorder-traversal/0925-construct-binary-tree-from-preorder-and-postorder-traversal.java b/leetcode/leetcode/0925-construct-binary-tree-from-preorder-and-postorder-traversal/0925-construct-binary-tree-from-preorder-and-postorder-traversal.java
new file mode 100644
index 0000000..ba05daa
--- /dev/null
+++ b/leetcode/leetcode/0925-construct-binary-tree-from-preorder-and-postorder-traversal/0925-construct-binary-tree-from-preorder-and-postorder-traversal.java
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    HashMap<Integer,Integer> postorderMap = new HashMap<>();
+    int preOrderIndex = 0;
+    
+    public TreeNode helper(int[] preorder, int[] postorder, int lowPostOrderIndex, int highPostOrderIndex){
+        if(lowPostOrderIndex>highPostOrderIndex) return null;
+        TreeNode root = new TreeNode(preorder[preOrderIndex]);
+        preOrderIndex++;
+        if(lowPostOrderIndex == highPostOrderIndex ) {
+            return root;
+        }
+        int breakingPoint = postorderMap.get(preorder[preOrderIndex]);
+        root.left = helper(preorder,postorder,lowPostOrderIndex,breakingPoint);
+        root.right = helper(preorder,postorder,breakingPoint+1,highPostOrderIndex-1);
+        return root;
+    }
+    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
+        for(int i=0;i<postorder.length;i++){
+            postorderMap.put(postorder[i],i);
+        }
+        TreeNode root = helper(preorder,postorder,0,preorder.length-1);
+        return root;
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0925-construct-binary-tree-from-preorder-and-postorder-traversal/README.md b/leetcode/leetcode/0925-construct-binary-tree-from-preorder-and-postorder-traversal/README.md
new file mode 100644
index 0000000..be31bf3
--- /dev/null
+++ b/leetcode/leetcode/0925-construct-binary-tree-from-preorder-and-postorder-traversal/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/construct-binary-tree-from-preorder-and-postorder-traversal">925. Construct Binary Tree from Preorder and Postorder Traversal</a></h2><h3>Medium</h3><hr><p>Given two integer arrays, <code>preorder</code> and <code>postorder</code> where <code>preorder</code> is the preorder traversal of a binary tree of <strong>distinct</strong> values and <code>postorder</code> is the postorder traversal of the same tree, reconstruct and return <em>the binary tree</em>.</p>
+
+<p>If there exist multiple answers, you can <strong>return any</strong> of them.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/07/24/lc-prepost.jpg" style="width: 304px; height: 265px;" />
+<pre>
+<strong>Input:</strong> preorder = [1,2,4,5,3,6,7], postorder = [4,5,2,6,7,3,1]
+<strong>Output:</strong> [1,2,3,4,5,6,7]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> preorder = [1], postorder = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= preorder.length &lt;= 30</code></li>
+	<li><code>1 &lt;= preorder[i] &lt;= preorder.length</code></li>
+	<li>All the values of <code>preorder</code> are <strong>unique</strong>.</li>
+	<li><code>postorder.length == preorder.length</code></li>
+	<li><code>1 &lt;= postorder[i] &lt;= postorder.length</code></li>
+	<li>All the values of <code>postorder</code> are <strong>unique</strong>.</li>
+	<li>It is guaranteed that <code>preorder</code> and <code>postorder</code> are the preorder traversal and postorder traversal of the same binary tree.</li>
+</ul>
diff --git a/leetcode/leetcode/0926-flip-string-to-monotone-increasing/0926-flip-string-to-monotone-increasing.java b/leetcode/leetcode/0926-flip-string-to-monotone-increasing/0926-flip-string-to-monotone-increasing.java
new file mode 100644
index 0000000..52f76d8
--- /dev/null
+++ b/leetcode/leetcode/0926-flip-string-to-monotone-increasing/0926-flip-string-to-monotone-increasing.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int countZero(String s){
+        int ans = 0;
+        for(int i = 0;i<s.length();i++){
+            if(s.charAt(i) == '0') ans++;
+        }
+        return ans;
+    }
+    public int minFlipsMonoIncr(String s) {
+        int zeros = countZero(s);
+        int ones = s.length() - zeros;
+        int ans = Math.min(zeros,ones);
+        int now = 0;
+        for(int i = 0;i<s.length();i++){
+            if(s.charAt(i) == '1') now++;
+            int curr = now+ (s.length()-i-1)-(ones-now);
+            ans = Math.min(ans,curr);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0926-flip-string-to-monotone-increasing/NOTES.md b/leetcode/leetcode/0926-flip-string-to-monotone-increasing/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0926-flip-string-to-monotone-increasing/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0926-flip-string-to-monotone-increasing/README.md b/leetcode/leetcode/0926-flip-string-to-monotone-increasing/README.md
new file mode 100644
index 0000000..191b2d8
--- /dev/null
+++ b/leetcode/leetcode/0926-flip-string-to-monotone-increasing/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/flip-string-to-monotone-increasing/">926. Flip String to Monotone Increasing</a></h2><h3>Medium</h3><hr><div><p>A binary string is monotone increasing if it consists of some number of <code>0</code>'s (possibly none), followed by some number of <code>1</code>'s (also possibly none).</p>
+
+<p>You are given a binary string <code>s</code>. You can flip <code>s[i]</code> changing it from <code>0</code> to <code>1</code> or from <code>1</code> to <code>0</code>.</p>
+
+<p>Return <em>the minimum number of flips to make </em><code>s</code><em> monotone increasing</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "00110"
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> We flip the last digit to get 00111.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "010110"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> We flip to get 011111, or alternatively 000111.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "00011000"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> We flip to get 00000000.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s[i]</code> is either <code>'0'</code> or <code>'1'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0937-online-stock-span/0937-online-stock-span.java b/leetcode/leetcode/0937-online-stock-span/0937-online-stock-span.java
new file mode 100644
index 0000000..4147826
--- /dev/null
+++ b/leetcode/leetcode/0937-online-stock-span/0937-online-stock-span.java
@@ -0,0 +1,26 @@
+class StockSpanner {
+    ArrayList<Pair<Integer,Integer>> list;
+
+    public StockSpanner() {
+        list = new ArrayList<>();
+    }
+    
+    public int next(int price) {
+        int index = list.size() - 1;
+        int ans = 1;
+        while(index!=-1){
+            if(list.get(index).getKey()>price) break;
+            int span = list.get(index).getValue();
+            ans+=span;
+            index-=span;
+        }
+        list.add(new Pair(price,ans));
+        return ans;
+    }
+}
+
+/**
+ * Your StockSpanner object will be instantiated and called as such:
+ * StockSpanner obj = new StockSpanner();
+ * int param_1 = obj.next(price);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/0937-online-stock-span/README.md b/leetcode/leetcode/0937-online-stock-span/README.md
new file mode 100644
index 0000000..3fcfbc7
--- /dev/null
+++ b/leetcode/leetcode/0937-online-stock-span/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/online-stock-span">937. Online Stock Span</a></h2><h3>Medium</h3><hr><p>Design an algorithm that collects daily price quotes for some stock and returns <strong>the span</strong> of that stock&#39;s price for the current day.</p>
+
+<p>The <strong>span</strong> of the stock&#39;s price in one day is the maximum number of consecutive days (starting from that day and going backward) for which the stock price was less than or equal to the price of that day.</p>
+
+<ul>
+	<li>For example, if the prices of the stock in the last four days is <code>[7,2,1,2]</code> and the price of the stock today is <code>2</code>, then the span of today is <code>4</code> because starting from today, the price of the stock was less than or equal <code>2</code> for <code>4</code> consecutive days.</li>
+	<li>Also, if the prices of the stock in the last four days is <code>[7,34,1,2]</code> and the price of the stock today is <code>8</code>, then the span of today is <code>3</code> because starting from today, the price of the stock was less than or equal <code>8</code> for <code>3</code> consecutive days.</li>
+</ul>
+
+<p>Implement the <code>StockSpanner</code> class:</p>
+
+<ul>
+	<li><code>StockSpanner()</code> Initializes the object of the class.</li>
+	<li><code>int next(int price)</code> Returns the <strong>span</strong> of the stock&#39;s price given that today&#39;s price is <code>price</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input</strong>
+[&quot;StockSpanner&quot;, &quot;next&quot;, &quot;next&quot;, &quot;next&quot;, &quot;next&quot;, &quot;next&quot;, &quot;next&quot;, &quot;next&quot;]
+[[], [100], [80], [60], [70], [60], [75], [85]]
+<strong>Output</strong>
+[null, 1, 1, 1, 2, 1, 4, 6]
+
+<strong>Explanation</strong>
+StockSpanner stockSpanner = new StockSpanner();
+stockSpanner.next(100); // return 1
+stockSpanner.next(80);  // return 1
+stockSpanner.next(60);  // return 1
+stockSpanner.next(70);  // return 2
+stockSpanner.next(60);  // return 1
+stockSpanner.next(75);  // return 4, because the last 4 prices (including today&#39;s price of 75) were less than or equal to today&#39;s price.
+stockSpanner.next(85);  // return 6
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= price &lt;= 10<sup>5</sup></code></li>
+	<li>At most <code>10<sup>4</sup></code> calls will be made to <code>next</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0944-delete-columns-to-make-sorted/0944-delete-columns-to-make-sorted.java b/leetcode/leetcode/0944-delete-columns-to-make-sorted/0944-delete-columns-to-make-sorted.java
new file mode 100644
index 0000000..0b6b162
--- /dev/null
+++ b/leetcode/leetcode/0944-delete-columns-to-make-sorted/0944-delete-columns-to-make-sorted.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int minDeletionSize(String[] strs) {
+        // char[][] mat = new char[strs.length][strs.length];
+        int ans = 0;
+        for(int i = 0; i<strs[0].length();i++){
+            char prev = strs[0].charAt(i);
+            for(int j = 1;j<strs.length;j++){
+                char next = strs[j].charAt(i);
+                if(prev<=next){
+                    prev = next;
+                }else{
+                    ans++;
+                    break;
+                }
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0944-delete-columns-to-make-sorted/NOTES.md b/leetcode/leetcode/0944-delete-columns-to-make-sorted/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0944-delete-columns-to-make-sorted/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0944-delete-columns-to-make-sorted/README.md b/leetcode/leetcode/0944-delete-columns-to-make-sorted/README.md
new file mode 100644
index 0000000..8fb9e24
--- /dev/null
+++ b/leetcode/leetcode/0944-delete-columns-to-make-sorted/README.md
@@ -0,0 +1,56 @@
+<h2><a href="https://leetcode.com/problems/delete-columns-to-make-sorted/">944. Delete Columns to Make Sorted</a></h2><h3>Easy</h3><hr><div><p>You are given an array of <code>n</code> strings <code>strs</code>, all of the same length.</p>
+
+<p>The strings can be arranged such that there is one on each line, making a grid. For example, <code>strs = ["abc", "bce", "cae"]</code> can be arranged as:</p>
+
+<pre>abc
+bce
+cae
+</pre>
+
+<p>You want to <strong>delete</strong> the columns that are <strong>not sorted lexicographically</strong>. In the above example (0-indexed), columns 0 (<code>'a'</code>, <code>'b'</code>, <code>'c'</code>) and 2 (<code>'c'</code>, <code>'e'</code>, <code>'e'</code>) are sorted while column 1 (<code>'b'</code>, <code>'c'</code>, <code>'a'</code>) is not, so you would delete column 1.</p>
+
+<p>Return <em>the number of columns that you will delete</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> strs = ["cba","daf","ghi"]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The grid looks as follows:
+  cba
+  daf
+  ghi
+Columns 0 and 2 are sorted, but column 1 is not, so you only need to delete 1 column.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> strs = ["a","b"]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The grid looks as follows:
+  a
+  b
+Column 0 is the only column and is sorted, so you will not delete any columns.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> strs = ["zyx","wvu","tsr"]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The grid looks as follows:
+  zyx
+  wvu
+  tsr
+All 3 columns are not sorted, so you will delete all 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == strs.length</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>1 &lt;= strs[i].length &lt;= 1000</code></li>
+	<li><code>strs[i]</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/0954-maximum-sum-circular-subarray/0954-maximum-sum-circular-subarray.java b/leetcode/leetcode/0954-maximum-sum-circular-subarray/0954-maximum-sum-circular-subarray.java
new file mode 100644
index 0000000..44e7bd7
--- /dev/null
+++ b/leetcode/leetcode/0954-maximum-sum-circular-subarray/0954-maximum-sum-circular-subarray.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int maxSubarraySumCircular(int[] arr) {
+
+        // kadane's algorithms
+        int totalSum = 0;
+        int maxSum = Integer.MIN_VALUE;
+        int currMaxSum = 0;
+        int minSum = Integer.MAX_VALUE;
+        int currMinSum = 0;
+
+        for(int num: arr){
+            currMaxSum+=num;
+            currMinSum+=num;
+            maxSum = Math.max(maxSum,currMaxSum);
+            minSum = Math.min(minSum,currMinSum);
+            if(currMinSum>0) currMinSum= 0;
+            if(currMaxSum<0) currMaxSum= 0;
+            totalSum+=num;
+        }
+        if(totalSum==minSum) return maxSum;
+        return Math.max(totalSum-minSum,maxSum);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0954-maximum-sum-circular-subarray/README.md b/leetcode/leetcode/0954-maximum-sum-circular-subarray/README.md
new file mode 100644
index 0000000..03a38e4
--- /dev/null
+++ b/leetcode/leetcode/0954-maximum-sum-circular-subarray/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/maximum-sum-circular-subarray">954. Maximum Sum Circular Subarray</a></h2><h3>Medium</h3><hr><p>Given a <strong>circular integer array</strong> <code>nums</code> of length <code>n</code>, return <em>the maximum possible sum of a non-empty <strong>subarray</strong> of </em><code>nums</code>.</p>
+
+<p>A <strong>circular array</strong> means the end of the array connects to the beginning of the array. Formally, the next element of <code>nums[i]</code> is <code>nums[(i + 1) % n]</code> and the previous element of <code>nums[i]</code> is <code>nums[(i - 1 + n) % n]</code>.</p>
+
+<p>A <strong>subarray</strong> may only include each element of the fixed buffer <code>nums</code> at most once. Formally, for a subarray <code>nums[i], nums[i + 1], ..., nums[j]</code>, there does not exist <code>i &lt;= k1</code>, <code>k2 &lt;= j</code> with <code>k1 % n == k2 % n</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,-2,3,-2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Subarray [3] has maximum sum 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [5,-3,5]
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> Subarray [5,5] has maximum sum 5 + 5 = 10.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [-3,-2,-3]
+<strong>Output:</strong> -2
+<strong>Explanation:</strong> Subarray [-2] has maximum sum -2.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-3 * 10<sup>4</sup> &lt;= nums[i] &lt;= 3 * 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/0966-binary-subarrays-with-sum/0966-binary-subarrays-with-sum.java b/leetcode/leetcode/0966-binary-subarrays-with-sum/0966-binary-subarrays-with-sum.java
new file mode 100644
index 0000000..4a03011
--- /dev/null
+++ b/leetcode/leetcode/0966-binary-subarrays-with-sum/0966-binary-subarrays-with-sum.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int helper(int[] nums, int goal){
+        int ans = 0;
+        int currentSum = 0;
+        for(int start = 0, end =0;end<nums.length;){
+            currentSum+=nums[end];
+            while(start<=end && currentSum>goal){
+                currentSum-=nums[start];
+                start++;
+            }
+            ans+=(end-start+1);
+            end++;
+            
+        }
+        return ans;
+    }
+    public int numSubarraysWithSum(int[] nums, int goal) {
+        return helper(nums,goal) - helper(nums,goal-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0966-binary-subarrays-with-sum/README.md b/leetcode/leetcode/0966-binary-subarrays-with-sum/README.md
new file mode 100644
index 0000000..f239330
--- /dev/null
+++ b/leetcode/leetcode/0966-binary-subarrays-with-sum/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/binary-subarrays-with-sum">966. Binary Subarrays With Sum</a></h2><h3>Medium</h3><hr><p>Given a binary array <code>nums</code> and an integer <code>goal</code>, return <em>the number of non-empty <strong>subarrays</strong> with a sum</em> <code>goal</code>.</p>
+
+<p>A <strong>subarray</strong> is a contiguous part of the array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,0,1,0,1], goal = 2
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The 4 subarrays are bolded and underlined below:
+[<u><strong>1,0,1</strong></u>,0,1]
+[<u><strong>1,0,1,0</strong></u>,1]
+[1,<u><strong>0,1,0,1</strong></u>]
+[1,0,<u><strong>1,0,1</strong></u>]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,0,0,0,0], goal = 0
+<strong>Output:</strong> 15
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
+	<li><code>0 &lt;= goal &lt;= nums.length</code></li>
+</ul>
diff --git a/leetcode/leetcode/0967-minimum-falling-path-sum/0967-minimum-falling-path-sum.java b/leetcode/leetcode/0967-minimum-falling-path-sum/0967-minimum-falling-path-sum.java
new file mode 100644
index 0000000..89387c8
--- /dev/null
+++ b/leetcode/leetcode/0967-minimum-falling-path-sum/0967-minimum-falling-path-sum.java
@@ -0,0 +1,91 @@
+class Solution {
+    // Method 1: Recusion TLE
+    // public int helper(int[][] mat, int row, int col){
+    //     if(col>=mat.length || col< 0) return Integer.MAX_VALUE;
+    //     if(row == mat.length) return 0;
+
+    //     int choice1 = helper(mat,row+1,col);
+    //     int choice2 = helper(mat,row+1,col-1);
+    //     int choice3 = helper(mat,row+1,col+1);
+
+    //     return mat[row][col] + Math.min(choice1,Math.min(choice2, choice3));
+    // }
+    // public int minFallingPathSum(int[][] matrix) {
+    //     int ans = Integer.MAX_VALUE;
+    //     for(int i = 0;i<matrix.length;i++){
+    //         ans = Math.min(ans,helper(matrix,0,i));
+    //     }
+    //     return ans;
+    // }
+
+    // Method 2: Memoization (TLE)
+    // public int helper(int[][] mat,int[][] memo, int row, int col){
+    //     if(col>=mat.length || col< 0) return Integer.MAX_VALUE;
+    //     if(row == mat.length) return 0;
+    //     if(memo[row][col]!=-1) return memo[row][col];
+
+    //     int choice1 = helper(mat,memo,row+1,col);
+    //     int choice2 = helper(mat,memo,row+1,col-1);
+    //     int choice3 = helper(mat,memo,row+1,col+1);
+
+    //     memo[row][col] =  mat[row][col] + Math.min(choice1,Math.min(choice2, choice3));
+    //     return memo[row][col];
+    // }
+    // public int minFallingPathSum(int[][] matrix) {
+    //     int ans = Integer.MAX_VALUE;
+    //     int[][] memo = new int[matrix.length][matrix.length];
+    //     for(int i = 0;i<memo.length;i++){
+    //         for(int j = 0;j<memo.length;j++){
+    //             memo[i][j] = -1;
+    //         }
+    //     }
+    //     for(int i = 0;i<matrix.length;i++){
+    //         ans = Math.min(ans,helper(matrix,memo,0,i));
+    //     }
+    //     return ans;
+    // }
+
+    // Method 3: DP
+
+    // public int minFallingPathSum(int[][] matrix) {
+    //     int[][] dp = new int[matrix.length+1][matrix.length+1];
+    //     for(int i = matrix.length - 1;i!=-1;i--){
+    //         for(int j = matrix.length - 1;j!=-1;j--){
+    //             if(j == 0){
+    //                 dp[i][j] = matrix[i][j] + Math.min(dp[i+1][j],dp[i+1][j+1]) ;
+    //             }else if(j == matrix.length -1){
+    //                 dp[i][j] = matrix[i][j] + Math.min(dp[i+1][j],dp[i+1][j-1]);
+    //             }
+    //             else dp[i][j] = matrix[i][j] + Math.min(dp[i+1][j],Math.min(dp[i+1][j-1],dp[i+1][j+1]));
+    //         }
+    //     }
+    //     int ans = Integer.MAX_VALUE;
+    //     for(int i = 0;i<matrix.length;i++){
+    //         ans = Math.min(ans,dp[0][i]);
+    //     }
+
+    //     return ans;
+    // }
+
+
+    // No extra memory
+    public int minFallingPathSum(int[][] matrix) {
+        // int[][] dp = new int[matrix.length+1][matrix.length+1];
+        for(int i = matrix.length - 2;i!=-1;i--){
+            for(int j = matrix.length - 1;j!=-1;j--){
+                if(j == 0){
+                    matrix[i][j] = matrix[i][j] + Math.min(matrix[i+1][j],matrix[i+1][j+1]) ;
+                }else if(j == matrix.length -1){
+                    matrix[i][j] = matrix[i][j] + Math.min(matrix[i+1][j],matrix[i+1][j-1]);
+                }
+                else matrix[i][j] = matrix[i][j] + Math.min(matrix[i+1][j],Math.min(matrix[i+1][j-1],matrix[i+1][j+1]));
+            }
+        }
+        int ans = Integer.MAX_VALUE;
+        for(int i = 0;i<matrix.length;i++){
+            ans = Math.min(ans,matrix[0][i]);
+        }
+
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0967-minimum-falling-path-sum/README.md b/leetcode/leetcode/0967-minimum-falling-path-sum/README.md
new file mode 100644
index 0000000..e08a2b3
--- /dev/null
+++ b/leetcode/leetcode/0967-minimum-falling-path-sum/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/minimum-falling-path-sum">967. Minimum Falling Path Sum</a></h2><h3>Medium</h3><hr><p>Given an <code>n x n</code> array of integers <code>matrix</code>, return <em>the <strong>minimum sum</strong> of any <strong>falling path</strong> through</em> <code>matrix</code>.</p>
+
+<p>A <strong>falling path</strong> starts at any element in the first row and chooses the element in the next row that is either directly below or diagonally left/right. Specifically, the next element from position <code>(row, col)</code> will be <code>(row + 1, col - 1)</code>, <code>(row + 1, col)</code>, or <code>(row + 1, col + 1)</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/03/failing1-grid.jpg" style="width: 499px; height: 500px;" />
+<pre>
+<strong>Input:</strong> matrix = [[2,1,3],[6,5,4],[7,8,9]]
+<strong>Output:</strong> 13
+<strong>Explanation:</strong> There are two falling paths with a minimum sum as shown.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/03/failing2-grid.jpg" style="width: 164px; height: 365px;" />
+<pre>
+<strong>Input:</strong> matrix = [[-19,57],[-40,-5]]
+<strong>Output:</strong> -59
+<strong>Explanation:</strong> The falling path with a minimum sum is shown.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == matrix.length == matrix[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>-100 &lt;= matrix[i][j] &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/0988-flip-equivalent-binary-trees/0988-flip-equivalent-binary-trees.java b/leetcode/leetcode/0988-flip-equivalent-binary-trees/0988-flip-equivalent-binary-trees.java
new file mode 100644
index 0000000..15fc642
--- /dev/null
+++ b/leetcode/leetcode/0988-flip-equivalent-binary-trees/0988-flip-equivalent-binary-trees.java
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean flipEquiv(TreeNode root1, TreeNode root2) {
+        if(root1==null && root2== null) return true;
+        if(root1==null || root2 == null) return false;
+
+        if(root1.val!=root2.val) return false;
+
+        return (flipEquiv(root1.left,root2.right) && flipEquiv(root1.right,root2.left)) || 
+                (flipEquiv(root1.left,root2.left) && flipEquiv(root1.right,root2.right)) ;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/0988-flip-equivalent-binary-trees/README.md b/leetcode/leetcode/0988-flip-equivalent-binary-trees/README.md
new file mode 100644
index 0000000..e48d4b2
--- /dev/null
+++ b/leetcode/leetcode/0988-flip-equivalent-binary-trees/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/flip-equivalent-binary-trees">988. Flip Equivalent Binary Trees</a></h2><h3>Medium</h3><hr><p>For a binary tree <strong>T</strong>, we can define a <strong>flip operation</strong> as follows: choose any node, and swap the left and right child subtrees.</p>
+
+<p>A binary tree <strong>X</strong>&nbsp;is <em>flip equivalent</em> to a binary tree <strong>Y</strong> if and only if we can make <strong>X</strong> equal to <strong>Y</strong> after some number of flip operations.</p>
+
+<p>Given the roots of two binary trees <code>root1</code> and <code>root2</code>, return <code>true</code> if the two trees are flip equivalent or <code>false</code> otherwise.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="Flipped Trees Diagram" src="https://assets.leetcode.com/uploads/2018/11/29/tree_ex.png" style="width: 500px; height: 220px;" />
+<pre>
+<strong>Input:</strong> root1 = [1,2,3,4,5,6,null,null,null,7,8], root2 = [1,3,2,null,6,4,5,null,null,null,null,8,7]
+<strong>Output:</strong> true
+<strong>Explanation: </strong>We flipped at nodes with values 1, 3, and 5.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> root1 = [], root2 = []
+<strong>Output:</strong> true
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root1 = [], root2 = [1]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in each tree is in the range <code>[0, 100]</code>.</li>
+	<li>Each tree will have <strong>unique node values</strong> in the range <code>[0, 99]</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/0997-find-the-town-judge/NOTES.md b/leetcode/leetcode/0997-find-the-town-judge/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/0997-find-the-town-judge/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/0997-find-the-town-judge/README.md b/leetcode/leetcode/0997-find-the-town-judge/README.md
new file mode 100644
index 0000000..2927b11
--- /dev/null
+++ b/leetcode/leetcode/0997-find-the-town-judge/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/find-the-town-judge/">997. Find the Town Judge</a></h2><h3>Easy</h3><hr><div><p>In a town, there are <code>n</code> people labeled from <code>1</code> to <code>n</code>. There is a rumor that one of these people is secretly the town judge.</p>
+
+<p>If the town judge exists, then:</p>
+
+<ol>
+	<li>The town judge trusts nobody.</li>
+	<li>Everybody (except for the town judge) trusts the town judge.</li>
+	<li>There is exactly one person that satisfies properties <strong>1</strong> and <strong>2</strong>.</li>
+</ol>
+
+<p>You are given an array <code>trust</code> where <code>trust[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> representing that the person labeled <code>a<sub>i</sub></code> trusts the person labeled <code>b<sub>i</sub></code>.</p>
+
+<p>Return <em>the label of the town judge if the town judge exists and can be identified, or return </em><code>-1</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2, trust = [[1,2]]
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 3, trust = [[1,3],[2,3]]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 3, trust = [[1,3],[2,3],[3,1]]
+<strong>Output:</strong> -1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 1000</code></li>
+	<li><code>0 &lt;= trust.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>trust[i].length == 2</code></li>
+	<li>All the pairs of <code>trust</code> are <strong>unique</strong>.</li>
+	<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
+	<li><code>1 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt;= n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1-two-sum/1-two-sum.java b/leetcode/leetcode/1-two-sum/1-two-sum.java
new file mode 100644
index 0000000..286948e
--- /dev/null
+++ b/leetcode/leetcode/1-two-sum/1-two-sum.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int[] arr = new int[2];
+        for(int i = 0; i<nums.length;i++){
+            if(map.containsKey(target-nums[i])  ){
+                arr[0] =i;
+                arr[1] = (int) map.get(target-nums[i]);
+                return arr;
+            }
+            map.put(nums[i],i);
+        }
+        return arr;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1-two-sum/NOTES.md b/leetcode/leetcode/1-two-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1-two-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1-two-sum/README.md b/leetcode/leetcode/1-two-sum/README.md
new file mode 100644
index 0000000..2776ef3
--- /dev/null
+++ b/leetcode/leetcode/1-two-sum/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/two-sum/">1. Two Sum</a></h2><h3>Easy</h3><hr><div><p>Given an array of integers <code>nums</code>&nbsp;and an integer <code>target</code>, return <em>indices of the two numbers such that they add up to <code>target</code></em>.</p>
+
+<p>You may assume that each input would have <strong><em>exactly</em> one solution</strong>, and you may not use the <em>same</em> element twice.</p>
+
+<p>You can return the answer in any order.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,7,11,15], target = 9
+<strong>Output:</strong> [0,1]
+<strong>Explanation:</strong> Because nums[0] + nums[1] == 9, we return [0, 1].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,2,4], target = 6
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,3], target = 6
+<strong>Output:</strong> [0,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= target &lt;= 10<sup>9</sup></code></li>
+	<li><strong>Only one valid answer exists.</strong></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow-up:&nbsp;</strong>Can you come up with an algorithm that is less than&nbsp;<code>O(n<sup>2</sup>)&nbsp;</code>time complexity?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1004-max-consecutive-ones-iii/1004-max-consecutive-ones-iii.java b/leetcode/leetcode/1004-max-consecutive-ones-iii/1004-max-consecutive-ones-iii.java
new file mode 100644
index 0000000..e0f0384
--- /dev/null
+++ b/leetcode/leetcode/1004-max-consecutive-ones-iii/1004-max-consecutive-ones-iii.java
@@ -0,0 +1,48 @@
+class Solution {
+    public int longestOnes(int[] arr, int k) {
+        int low  = 0;
+        int high = 0;
+        int fixK = k;
+        int ans  = 0;
+        if(k==0){
+            for(int i = 0;i<arr.length;i++){
+                if(arr[i]==0) continue;
+                low = i;
+                while(i!=arr.length){
+                    if(arr[i]==1) i++;
+                    else break;
+                }
+                ans = Math.max(ans,i-low);
+            }
+            return ans;
+        }
+        for(int i = 0;i<arr.length;i++){
+            if(arr[i] == 1) high++;
+            else if(k!=0){
+                k--;
+                high++;
+            }
+            else break;
+        }
+        ans =high-low;
+        while(high!=arr.length){
+            while(k!=0 || high!= arr.length){
+                if(arr[high]==1) high++;
+                else if(k!=0) {
+                    k--;
+                    high++;
+                }else break;
+            }
+            if(high >= arr.length){
+                ans = Math.max(ans,high-low);
+                break;
+            }
+            ans = Math.max(ans,high-low);
+            if(arr[low] == 0) k++;
+            if(k>fixK) k = fixK;
+            low++;
+             
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1004-max-consecutive-ones-iii/NOTES.md b/leetcode/leetcode/1004-max-consecutive-ones-iii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1004-max-consecutive-ones-iii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1004-max-consecutive-ones-iii/README.md b/leetcode/leetcode/1004-max-consecutive-ones-iii/README.md
new file mode 100644
index 0000000..e3742b8
--- /dev/null
+++ b/leetcode/leetcode/1004-max-consecutive-ones-iii/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/max-consecutive-ones-iii/">1004. Max Consecutive Ones III</a></h2><h3>Medium</h3><hr><div><p>Given a binary array <code>nums</code> and an integer <code>k</code>, return <em>the maximum number of consecutive </em><code>1</code><em>'s in the array if you can flip at most</em> <code>k</code> <code>0</code>'s.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> [1,1,1,0,0,<u><strong>1</strong>,1,1,1,1,<strong>1</strong></u>]
+Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], k = 3
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> [0,0,<u>1,1,<strong>1</strong>,<strong>1</strong>,1,1,1,<strong>1</strong>,1,1</u>,0,0,0,1,1,1,1]
+Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
+	<li><code>0 &lt;= k &lt;= nums.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/1008-construct-binary-search-tree-from-preorder-traversal.java b/leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/1008-construct-binary-search-tree-from-preorder-traversal.java
new file mode 100644
index 0000000..46f93db
--- /dev/null
+++ b/leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/1008-construct-binary-search-tree-from-preorder-traversal.java
@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode bstFromPreorder(int[] preorder, int startIndex, int endIndex) {
+        if(startIndex>endIndex) return null;
+        int val = preorder[startIndex];
+        TreeNode root = new TreeNode(val);
+        int index = startIndex+1;
+        while(index<=endIndex && preorder[index]<val) index++;
+        root.left = bstFromPreorder(preorder,startIndex+1,index-1);
+        root.right = bstFromPreorder(preorder,index,endIndex);
+        return root;
+        
+            
+    }
+    public TreeNode bstFromPreorder(int[] preorder) {
+        return bstFromPreorder(preorder,0,preorder.length-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/NOTES.md b/leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/README.md b/leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/README.md
new file mode 100644
index 0000000..2cc9ca2
--- /dev/null
+++ b/leetcode/leetcode/1008-construct-binary-search-tree-from-preorder-traversal/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal/">1008. Construct Binary Search Tree from Preorder Traversal</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers preorder, which represents the <strong>preorder traversal</strong> of a BST (i.e., <strong>binary search tree</strong>), construct the tree and return <em>its root</em>.</p>
+
+<p>It is <strong>guaranteed</strong> that there is always possible to find a binary search tree with the given requirements for the given test cases.</p>
+
+<p>A <strong>binary search tree</strong> is a binary tree where for every node, any descendant of <code>Node.left</code> has a value <strong>strictly less than</strong> <code>Node.val</code>, and any descendant of <code>Node.right</code> has a value <strong>strictly greater than</strong> <code>Node.val</code>.</p>
+
+<p>A <strong>preorder traversal</strong> of a binary tree displays the value of the node first, then traverses <code>Node.left</code>, then traverses <code>Node.right</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/03/06/1266.png" style="height: 386px; width: 590px;">
+<pre><strong>Input:</strong> preorder = [8,5,1,7,10,12]
+<strong>Output:</strong> [8,5,10,1,7,null,12]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> preorder = [1,3]
+<strong>Output:</strong> [1,null,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= preorder.length &lt;= 100</code></li>
+	<li><code>1 &lt;= preorder[i] &lt;= 1000</code></li>
+	<li>All the values of <code>preorder</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1009-complement-of-base-10-integer/1009-complement-of-base-10-integer.java b/leetcode/leetcode/1009-complement-of-base-10-integer/1009-complement-of-base-10-integer.java
new file mode 100644
index 0000000..ce6ee53
--- /dev/null
+++ b/leetcode/leetcode/1009-complement-of-base-10-integer/1009-complement-of-base-10-integer.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int bitwiseComplement(int n) {
+        if(n==0) return 1;
+        int counter = 0;
+        int res = 0;
+        while(n!=0){
+            if(n%2==0){
+                res = res + (int)Math.pow(2,counter);
+            }
+            n = n/2;
+            counter++;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1009-complement-of-base-10-integer/NOTES.md b/leetcode/leetcode/1009-complement-of-base-10-integer/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1009-complement-of-base-10-integer/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1009-complement-of-base-10-integer/README.md b/leetcode/leetcode/1009-complement-of-base-10-integer/README.md
new file mode 100644
index 0000000..428c4b9
--- /dev/null
+++ b/leetcode/leetcode/1009-complement-of-base-10-integer/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/complement-of-base-10-integer/">1009. Complement of Base 10 Integer</a></h2><h3>Easy</h3><hr><div><p>The <strong>complement</strong> of an integer is the integer you get when you flip all the <code>0</code>'s to <code>1</code>'s and all the <code>1</code>'s to <code>0</code>'s in its binary representation.</p>
+
+<ul>
+	<li>For example, The integer <code>5</code> is <code>"101"</code> in binary and its <strong>complement</strong> is <code>"010"</code> which is the integer <code>2</code>.</li>
+</ul>
+
+<p>Given an integer <code>n</code>, return <em>its complement</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 5 is "101" in binary, with complement "010" in binary, which is 2 in base-10.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 7
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> 7 is "111" in binary, with complement "000" in binary, which is 0 in base-10.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 10
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> 10 is "1010" in binary, with complement "0101" in binary, which is 5 in base-10.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt; 10<sup>9</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as 476: <a href="https://leetcode.com/problems/number-complement/" target="_blank">https://leetcode.com/problems/number-complement/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/101-symmetric-tree/101-symmetric-tree.java b/leetcode/leetcode/101-symmetric-tree/101-symmetric-tree.java
new file mode 100644
index 0000000..4571572
--- /dev/null
+++ b/leetcode/leetcode/101-symmetric-tree/101-symmetric-tree.java
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    private boolean helper(TreeNode root1, TreeNode root2){
+        if(root1 == null && root2 == null) return true;
+        if((root1 == null && root2!=null) || (root1!=null && root2==null)) return false;
+        if(root1.val != root2.val) return false;
+        return helper(root1.left,root2.right) && helper(root1.right,root2.left);
+        
+    }
+    public boolean isSymmetric(TreeNode root) {
+        if(root == null) return true;
+        return helper(root.left,root.right);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/101-symmetric-tree/NOTES.md b/leetcode/leetcode/101-symmetric-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/101-symmetric-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/101-symmetric-tree/README.md b/leetcode/leetcode/101-symmetric-tree/README.md
new file mode 100644
index 0000000..e348797
--- /dev/null
+++ b/leetcode/leetcode/101-symmetric-tree/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/symmetric-tree/">101. Symmetric Tree</a></h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, <em>check whether it is a mirror of itself</em> (i.e., symmetric around its center).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/symtree1.jpg" style="width: 354px; height: 291px;">
+<pre><strong>Input:</strong> root = [1,2,2,3,4,4,3]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/symtree2.jpg" style="width: 308px; height: 258px;">
+<pre><strong>Input:</strong> root = [1,2,2,null,3,null,3]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 1000]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you solve it both recursively and iteratively?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1014-k-closest-points-to-origin/1014-k-closest-points-to-origin.java b/leetcode/leetcode/1014-k-closest-points-to-origin/1014-k-closest-points-to-origin.java
new file mode 100644
index 0000000..6bc0f55
--- /dev/null
+++ b/leetcode/leetcode/1014-k-closest-points-to-origin/1014-k-closest-points-to-origin.java
@@ -0,0 +1,53 @@
+class Solution {
+    class Pair implements Comparable<Pair>{
+        int x;
+        int y;
+        double d;
+
+        Pair(int x, int y, double d){
+            this.x = x;
+            this.y = y;
+            this.d = d;
+        }
+        @Override
+        public int compareTo(Pair p){
+            return Double.compare(p.d,this.d);
+        }
+    }
+    public int[][] kClosest(int[][] points, int k) {
+        PriorityQueue<Pair> pq = new PriorityQueue<>();
+        for(int i = 0;i<points.length;i++){
+            int x = points[i][0];
+            int y = points[i][1];
+
+            double d = Math.sqrt(x*x + y*y);
+            pq.add(new Pair(x,y,d));
+
+            if(pq.size()>k) pq.remove();
+        }
+        int[][] ans = new int[k][2];
+        for(int i = 0;i<k;i++){
+            Pair p = pq.remove();
+            ans[i][0] = p.x;
+            ans[i][1] = p.y;
+        }
+        return ans;
+
+        
+
+
+
+        // Approach 1: Sorting entire points based on distance from origin.
+        // Arrays.sort(points,(a,b)->Double.compare(
+        //     Math.sqrt(a[0]*a[0] +a[1]*a[1]),
+        //     Math.sqrt(b[0]*b[0] +b[1]*b[1])
+        //     ));
+        // int[][] ans = new int[k][2];
+        // for(int i = 0;i<k;i++){
+        //     ans[i][0] = points[i][0];
+        //     ans[i][1] = points[i][1];
+        // }
+        // return ans;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1014-k-closest-points-to-origin/README.md b/leetcode/leetcode/1014-k-closest-points-to-origin/README.md
new file mode 100644
index 0000000..2380f2d
--- /dev/null
+++ b/leetcode/leetcode/1014-k-closest-points-to-origin/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/k-closest-points-to-origin">1014. K Closest Points to Origin</a></h2><h3>Medium</h3><hr><p>Given an array of <code>points</code> where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the <strong>X-Y</strong> plane and an integer <code>k</code>, return the <code>k</code> closest points to the origin <code>(0, 0)</code>.</p>
+
+<p>The distance between two points on the <strong>X-Y</strong> plane is the Euclidean distance (i.e., <code>&radic;(x<sub>1</sub> - x<sub>2</sub>)<sup>2</sup> + (y<sub>1</sub> - y<sub>2</sub>)<sup>2</sup></code>).</p>
+
+<p>You may return the answer in <strong>any order</strong>. The answer is <strong>guaranteed</strong> to be <strong>unique</strong> (except for the order that it is in).</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/closestplane1.jpg" style="width: 400px; height: 400px;" />
+<pre>
+<strong>Input:</strong> points = [[1,3],[-2,2]], k = 1
+<strong>Output:</strong> [[-2,2]]
+<strong>Explanation:</strong>
+The distance between (1, 3) and the origin is sqrt(10).
+The distance between (-2, 2) and the origin is sqrt(8).
+Since sqrt(8) &lt; sqrt(10), (-2, 2) is closer to the origin.
+We only want the closest k = 1 points from the origin, so the answer is just [[-2,2]].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> points = [[3,3],[5,-1],[-2,4]], k = 2
+<strong>Output:</strong> [[3,3],[-2,4]]
+<strong>Explanation:</strong> The answer [[-2,4],[3,3]] would also be accepted.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= points.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= x<sub>i</sub>, y<sub>i</sub> &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/1019-next-greater-node-in-linked-list/1019-next-greater-node-in-linked-list.java b/leetcode/leetcode/1019-next-greater-node-in-linked-list/1019-next-greater-node-in-linked-list.java
new file mode 100644
index 0000000..bf21125
--- /dev/null
+++ b/leetcode/leetcode/1019-next-greater-node-in-linked-list/1019-next-greater-node-in-linked-list.java
@@ -0,0 +1,46 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    class pair{
+        int val;
+        int index;
+        pair(int index, int val){
+            this.index = index;
+            this.val = val;
+        }
+    }
+    public int[] nextLargerNodes(ListNode head) {
+        int size = 0;
+        ListNode temp = head;
+        while(temp!=null){
+            temp = temp.next;
+            size++;
+        }
+        int[] res = new int[size];
+        Stack<pair> s = new Stack<>();
+        temp = head;
+        size = 0;
+        while(temp!=null){
+            if(s.isEmpty()){
+                s.push(new pair(size++,temp.val));
+                temp = temp.next;
+            }
+            if(temp == null) return res;
+            while(!s.isEmpty() && s.peek().val<temp.val){
+                res[s.peek().index] = temp.val;
+                s.pop();
+            }
+            s.push(new pair(size++,temp.val));
+            temp = temp.next;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1019-next-greater-node-in-linked-list/NOTES.md b/leetcode/leetcode/1019-next-greater-node-in-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1019-next-greater-node-in-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1019-next-greater-node-in-linked-list/README.md b/leetcode/leetcode/1019-next-greater-node-in-linked-list/README.md
new file mode 100644
index 0000000..3292e36
--- /dev/null
+++ b/leetcode/leetcode/1019-next-greater-node-in-linked-list/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/next-greater-node-in-linked-list/">1019. Next Greater Node In Linked List</a></h2><h3>Medium</h3><hr><div><p>You are given the <code>head</code> of a linked list with <code>n</code> nodes.</p>
+
+<p>For each node in the list, find the value of the <strong>next greater node</strong>. That is, for each node, find the value of the first node that is next to it and has a <strong>strictly larger</strong> value than it.</p>
+
+<p>Return an integer array <code>answer</code> where <code>answer[i]</code> is the value of the next greater node of the <code>i<sup>th</sup></code> node (<strong>1-indexed</strong>). If the <code>i<sup>th</sup></code> node does not have a next greater node, set <code>answer[i] = 0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/05/linkedlistnext1.jpg" style="width: 304px; height: 133px;">
+<pre><strong>Input:</strong> head = [2,1,5]
+<strong>Output:</strong> [5,5,0]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/05/linkedlistnext2.jpg" style="width: 500px; height: 113px;">
+<pre><strong>Input:</strong> head = [2,7,4,3,5]
+<strong>Output:</strong> [7,0,5,5,0]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is <code>n</code>.</li>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.java b/leetcode/leetcode/102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.java
new file mode 100644
index 0000000..99168b0
--- /dev/null
+++ b/leetcode/leetcode/102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.java
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        if(root == null) return new ArrayList<>();
+        List<List<Integer>> list = new ArrayList<>();
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+        while(!q.isEmpty()){
+            List<Integer> temp = new ArrayList<>(q.size());
+            for(int i = q.size();i>0;i--){
+                TreeNode front = q.remove();
+                temp.add(front.val);
+                if(front.left!=null) q.add(front.left);
+                if(front.right!=null) q.add(front.right);
+            }
+            list.add(temp); 
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/102-binary-tree-level-order-traversal/NOTES.md b/leetcode/leetcode/102-binary-tree-level-order-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/102-binary-tree-level-order-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/102-binary-tree-level-order-traversal/README.md b/leetcode/leetcode/102-binary-tree-level-order-traversal/README.md
new file mode 100644
index 0000000..f7470bf
--- /dev/null
+++ b/leetcode/leetcode/102-binary-tree-level-order-traversal/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-level-order-traversal/">102. Binary Tree Level Order Traversal</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the level order traversal of its nodes' values</em>. (i.e., from left to right, level by level).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> [[3],[9,20],[15,7]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> [[1]]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/1022-sum-of-root-to-leaf-binary-numbers.java b/leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/1022-sum-of-root-to-leaf-binary-numbers.java
new file mode 100644
index 0000000..5ab6fc1
--- /dev/null
+++ b/leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/1022-sum-of-root-to-leaf-binary-numbers.java
@@ -0,0 +1,51 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    
+    public List<String> toList(TreeNode root){
+         List<String> list = new ArrayList<>();
+        if(root == null) return list;
+        if(root.left==null && root.right == null){
+           
+            list.add(Integer.toString(root.val));
+            return list;
+        }
+        list = toList(root.left);
+        list.addAll(toList(root.right));
+        for(int i =0;i<list.size();i++){
+            list.set(i,Integer.toString(root.val) + list.get(i));
+        }
+        return list;
+    }
+    public int binaryToInt(String s){
+        int res = 0;
+        int len = s.length();
+        for(int i= 0;i<len;i++){
+            int c = s.charAt(len - i -1) - '0';
+            res+=((int)c * Math.pow(2,i));
+        }
+        return res;
+    }
+    public int sumRootToLeaf(TreeNode root) {
+        List<String> list = toList(root);
+        int res = 0;
+        for(int i = 0;i<list.size();i++){
+            res+=binaryToInt(list.get(i));
+        }
+        return res;
+    }
+
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/NOTES.md b/leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/README.md b/leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/README.md
new file mode 100644
index 0000000..5f1c1ad
--- /dev/null
+++ b/leetcode/leetcode/1022-sum-of-root-to-leaf-binary-numbers/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers/">1022. Sum of Root To Leaf Binary Numbers</a></h2><h3>Easy</h3><hr><div><p>You are given the <code>root</code> of a binary tree where each node has a value <code>0</code> or <code>1</code>. Each root-to-leaf path represents a binary number starting with the most significant bit.</p>
+
+<ul>
+	<li>For example, if the path is <code>0 -&gt; 1 -&gt; 1 -&gt; 0 -&gt; 1</code>, then this could represent <code>01101</code> in binary, which is <code>13</code>.</li>
+</ul>
+
+<p>For all leaves in the tree, consider the numbers represented by the path from the root to that leaf. Return <em>the sum of these numbers</em>.</p>
+
+<p>The test cases are generated so that the answer fits in a <strong>32-bits</strong> integer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/04/04/sum-of-root-to-leaf-binary-numbers.png" style="width: 400px; height: 263px;">
+<pre><strong>Input:</strong> root = [1,0,1,0,1,0,1]
+<strong>Output:</strong> 22
+<strong>Explanation: </strong>(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [0]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 1000]</code>.</li>
+	<li><code>Node.val</code> is <code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/1026-maximum-difference-between-node-and-ancestor.java b/leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/1026-maximum-difference-between-node-and-ancestor.java
new file mode 100644
index 0000000..2f503f1
--- /dev/null
+++ b/leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/1026-maximum-difference-between-node-and-ancestor.java
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int helper(TreeNode root, int currMax, int currMin){
+        if(root==null) return currMax-currMin;
+        currMax = Math.max(currMax,root.val);
+        currMin = Math.min(currMin,root.val);
+        int left = helper(root.left,currMax,currMin);
+        int right = helper(root.right,currMax,currMin);
+        return Math.max(left,right);
+    }
+    public int maxAncestorDiff(TreeNode root) {
+        return helper(root,root.val,root.val);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/NOTES.md b/leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/README.md b/leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/README.md
new file mode 100644
index 0000000..69743db
--- /dev/null
+++ b/leetcode/leetcode/1026-maximum-difference-between-node-and-ancestor/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/maximum-difference-between-node-and-ancestor/">1026. Maximum Difference Between Node and Ancestor</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, find the maximum value <code>v</code> for which there exist <strong>different</strong> nodes <code>a</code> and <code>b</code> where <code>v = |a.val - b.val|</code> and <code>a</code> is an ancestor of <code>b</code>.</p>
+
+<p>A node <code>a</code> is an ancestor of <code>b</code> if either: any child of <code>a</code> is equal to <code>b</code>&nbsp;or any child of <code>a</code> is an ancestor of <code>b</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/09/tmp-tree.jpg" style="width: 400px; height: 390px;">
+<pre><strong>Input:</strong> root = [8,3,10,1,6,null,14,null,null,4,7,13]
+<strong>Output:</strong> 7
+<strong>Explanation: </strong>We have various ancestor-node differences, some of which are given below :
+|8 - 3| = 5
+|3 - 7| = 4
+|8 - 1| = 7
+|10 - 13| = 3
+Among all possible differences, the maximum value of 7 is obtained by |8 - 1| = 7.</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/09/tmp-tree-1.jpg" style="width: 250px; height: 349px;">
+<pre><strong>Input:</strong> root = [1,null,2,null,0,3]
+<strong>Output:</strong> 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[2, 5000]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1029-vertical-order-traversal-of-a-binary-tree/1029-vertical-order-traversal-of-a-binary-tree.java b/leetcode/leetcode/1029-vertical-order-traversal-of-a-binary-tree/1029-vertical-order-traversal-of-a-binary-tree.java
new file mode 100644
index 0000000..172db7c
--- /dev/null
+++ b/leetcode/leetcode/1029-vertical-order-traversal-of-a-binary-tree/1029-vertical-order-traversal-of-a-binary-tree.java
@@ -0,0 +1,74 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    class Pair{
+        TreeNode node;
+        int verticalLevel;
+        Pair(TreeNode node, int verticalLevel){
+            this.node          = node;
+            this.verticalLevel = verticalLevel;
+        }
+    }
+    public List<List<Integer>> verticalTraversal(TreeNode root) {
+        HashMap<Integer, List<List<Integer>>> map = new HashMap<>();
+        Queue<Pair> q = new LinkedList<>();
+
+        q.add(new Pair(root,0));
+        int min = 0;
+        int max = 0;
+        int horizontalLevel = 0;
+
+        while(!q.isEmpty()){
+            int k = q.size();
+            for(int i = 0;i<k;i++){
+                Pair p = q.poll();
+                if(!map.containsKey(p.verticalLevel)){
+                    List<List<Integer>> list = new ArrayList<>();
+                    map.put(p.verticalLevel, list);
+                }
+                List<List<Integer>> list = map.get(p.verticalLevel);
+                while(list.size()!=horizontalLevel+1){
+                    List<Integer> temp = new ArrayList<>();
+                    list.add(temp);
+                }
+                List<Integer> temp = list.get(horizontalLevel);
+                temp.add(p.node.val);
+
+                if(p.node.left!=null){
+                    q.add(new Pair(p.node.left,p.verticalLevel-1));
+                }
+                if(p.node.right!=null){
+                    q.add(new Pair(p.node.right,p.verticalLevel+1));
+                }
+                max = Math.max(max, p.verticalLevel);
+                min = Math.min(min, p.verticalLevel);
+            }
+            horizontalLevel++;
+        }
+        List<List<Integer>> result = new ArrayList<>();
+        for(int i = min;i<=max;i++){
+            // if(!map.containsKey(i)) continue;
+            List<List<Integer>> list = map.get(i);
+            List<Integer> interResult = new ArrayList<>();
+            for(int j =0;j<list.size();j++){
+                Collections.sort(list.get(j));
+                interResult.addAll(list.get(j));
+            }
+            result.add(interResult);
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1029-vertical-order-traversal-of-a-binary-tree/README.md b/leetcode/leetcode/1029-vertical-order-traversal-of-a-binary-tree/README.md
new file mode 100644
index 0000000..cc712da
--- /dev/null
+++ b/leetcode/leetcode/1029-vertical-order-traversal-of-a-binary-tree/README.md
@@ -0,0 +1,52 @@
+<h2><a href="https://leetcode.com/problems/vertical-order-traversal-of-a-binary-tree">1029. Vertical Order Traversal of a Binary Tree</a></h2><h3>Hard</h3><hr><p>Given the <code>root</code> of a binary tree, calculate the <strong>vertical order traversal</strong> of the binary tree.</p>
+
+<p>For each node at position <code>(row, col)</code>, its left and right children will be at positions <code>(row + 1, col - 1)</code> and <code>(row + 1, col + 1)</code> respectively. The root of the tree is at <code>(0, 0)</code>.</p>
+
+<p>The <strong>vertical order traversal</strong> of a binary tree is a list of top-to-bottom orderings for each column index starting from the leftmost column and ending on the rightmost column. There may be multiple nodes in the same row and same column. In such a case, sort these nodes by their values.</p>
+
+<p>Return <em>the <strong>vertical order traversal</strong> of the binary tree</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/29/vtree1.jpg" style="width: 431px; height: 304px;" />
+<pre>
+<strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> [[9],[3,15],[20],[7]]
+<strong>Explanation:</strong>
+Column -1: Only node 9 is in this column.
+Column 0: Nodes 3 and 15 are in this column in that order from top to bottom.
+Column 1: Only node 20 is in this column.
+Column 2: Only node 7 is in this column.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/29/vtree2.jpg" style="width: 512px; height: 304px;" />
+<pre>
+<strong>Input:</strong> root = [1,2,3,4,5,6,7]
+<strong>Output:</strong> [[4],[2],[1,5,6],[3],[7]]
+<strong>Explanation:</strong>
+Column -2: Only node 4 is in this column.
+Column -1: Only node 2 is in this column.
+Column 0: Nodes 1, 5, and 6 are in this column.
+          1 is at the top, so it comes first.
+          5 and 6 are at the same position (2, 0), so we order them by their value, 5 before 6.
+Column 1: Only node 3 is in this column.
+Column 2: Only node 7 is in this column.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/29/vtree3.jpg" style="width: 512px; height: 304px;" />
+<pre>
+<strong>Input:</strong> root = [1,2,3,4,6,5,7]
+<strong>Output:</strong> [[4],[2],[1,5,6],[3],[7]]
+<strong>Explanation:</strong>
+This case is the exact same as example 2, but with nodes 5 and 6 swapped.
+Note that the solution remains the same since 5 and 6 are in the same location and should be ordered by their values.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 1000]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/103-binary-tree-zigzag-level-order-traversal.java b/leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/103-binary-tree-zigzag-level-order-traversal.java
new file mode 100644
index 0000000..31a833a
--- /dev/null
+++ b/leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/103-binary-tree-zigzag-level-order-traversal.java
@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> list = new ArrayList<>();
+        if(root == null) return list;
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+        boolean zigzag =  true;
+        while(!q.isEmpty()){
+            List<Integer> temp = new ArrayList<>();
+            for(int i = q.size();i!=0;i--){
+                TreeNode front = q.remove();
+                if(front.left!=null) q.add(front.left);
+                if(front.right!=null) q.add(front.right);
+                if(zigzag){
+                    temp.add(front.val);
+                }else{
+                    temp.add(0,front.val);
+                }
+            }
+            list.add(temp);
+            zigzag = !zigzag;
+        }
+    return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/NOTES.md b/leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/README.md b/leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/README.md
new file mode 100644
index 0000000..d5e31c0
--- /dev/null
+++ b/leetcode/leetcode/103-binary-tree-zigzag-level-order-traversal/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/">103. Binary Tree Zigzag Level Order Traversal</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the zigzag level order traversal of its nodes' values</em>. (i.e., from left to right, then right to left for the next level and alternate between).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> [[3],[20,9],[15,7]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> [[1]]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1030-smallest-string-starting-from-leaf/1030-smallest-string-starting-from-leaf.java b/leetcode/leetcode/1030-smallest-string-starting-from-leaf/1030-smallest-string-starting-from-leaf.java
new file mode 100644
index 0000000..d592fbb
--- /dev/null
+++ b/leetcode/leetcode/1030-smallest-string-starting-from-leaf/1030-smallest-string-starting-from-leaf.java
@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    String ans = "";
+    public void dfs(TreeNode root, String currString){
+        if(root == null) return;
+
+        currString  = (char) (root.val + 'a') + currString;
+
+        if(root.left==null && root.right == null){
+            if(ans.isEmpty() || currString.compareTo(ans)<0){
+                ans = currString;
+            }
+        }
+        dfs(root.left,currString);
+        dfs(root.right,currString);
+
+    }
+    public String smallestFromLeaf(TreeNode root) {
+        dfs(root,"");
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1030-smallest-string-starting-from-leaf/README.md b/leetcode/leetcode/1030-smallest-string-starting-from-leaf/README.md
new file mode 100644
index 0000000..57325b9
--- /dev/null
+++ b/leetcode/leetcode/1030-smallest-string-starting-from-leaf/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/smallest-string-starting-from-leaf">1030. Smallest String Starting From Leaf</a></h2><h3>Medium</h3><hr><p>You are given the <code>root</code> of a binary tree where each node has a value in the range <code>[0, 25]</code> representing the letters <code>&#39;a&#39;</code> to <code>&#39;z&#39;</code>.</p>
+
+<p>Return <em>the <strong>lexicographically smallest</strong> string that starts at a leaf of this tree and ends at the root</em>.</p>
+
+<p>As a reminder, any shorter prefix of a string is <strong>lexicographically smaller</strong>.</p>
+
+<ul>
+	<li>For example, <code>&quot;ab&quot;</code> is lexicographically smaller than <code>&quot;aba&quot;</code>.</li>
+</ul>
+
+<p>A leaf of a node is a node that has no children.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/01/30/tree1.png" style="width: 534px; height: 358px;" />
+<pre>
+<strong>Input:</strong> root = [0,1,2,3,4,3,4]
+<strong>Output:</strong> &quot;dba&quot;
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/01/30/tree2.png" style="width: 534px; height: 358px;" />
+<pre>
+<strong>Input:</strong> root = [25,1,3,1,3,0,2]
+<strong>Output:</strong> &quot;adz&quot;
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/02/01/tree3.png" style="height: 490px; width: 468px;" />
+<pre>
+<strong>Input:</strong> root = [2,2,1,null,1,0,null,0]
+<strong>Output:</strong> &quot;abc&quot;
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 8500]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 25</code></li>
+</ul>
diff --git a/leetcode/leetcode/1034-subarrays-with-k-different-integers/README.md b/leetcode/leetcode/1034-subarrays-with-k-different-integers/README.md
new file mode 100644
index 0000000..d2ebd74
--- /dev/null
+++ b/leetcode/leetcode/1034-subarrays-with-k-different-integers/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/subarrays-with-k-different-integers">1034. Subarrays with K Different Integers</a></h2><h3>Hard</h3><hr><p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <em>the number of <strong>good subarrays</strong> of </em><code>nums</code>.</p>
+
+<p>A <strong>good array</strong> is an array where the number of different integers in that array is exactly <code>k</code>.</p>
+
+<ul>
+	<li>For example, <code>[1,2,3,1,2]</code> has <code>3</code> different integers: <code>1</code>, <code>2</code>, and <code>3</code>.</li>
+</ul>
+
+<p>A <strong>subarray</strong> is a <strong>contiguous</strong> part of an array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,1,2,3], k = 2
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Subarrays formed with exactly 2 different integers: [1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,1,3,4], k = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Subarrays formed with exactly 3 different integers: [1,2,1,3], [2,1,3], [1,3,4].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= nums[i], k &lt;= nums.length</code></li>
+</ul>
diff --git a/leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/1038-binary-search-tree-to-greater-sum-tree.java b/leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/1038-binary-search-tree-to-greater-sum-tree.java
new file mode 100644
index 0000000..505d6ef
--- /dev/null
+++ b/leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/1038-binary-search-tree-to-greater-sum-tree.java
@@ -0,0 +1,24 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    int pre = 0;
+    public TreeNode bstToGst(TreeNode root) {
+        if(root.right!=null) bstToGst(root.right);
+        pre = root.val = pre+root.val;
+        if (root.left != null) bstToGst(root.left);
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/NOTES.md b/leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/README.md b/leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/README.md
new file mode 100644
index 0000000..31498ac
--- /dev/null
+++ b/leetcode/leetcode/1038-binary-search-tree-to-greater-sum-tree/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/">1038. Binary Search Tree to Greater Sum Tree</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus the sum of all keys greater than the original key in BST.</p>
+
+<p>As a reminder, a <em>binary search tree</em> is a tree that satisfies these constraints:</p>
+
+<ul>
+	<li>The left subtree of a node contains only nodes with keys <strong>less than</strong> the node's key.</li>
+	<li>The right subtree of a node contains only nodes with keys <strong>greater than</strong> the node's key.</li>
+	<li>Both the left and right subtrees must also be binary search trees.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/05/02/tree.png" style="width: 400px; height: 273px;">
+<pre><strong>Input:</strong> root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
+<strong>Output:</strong> [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [0,null,1]
+<strong>Output:</strong> [1,null,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 100]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 100</code></li>
+	<li>All the values in the tree are <strong>unique</strong>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as 538: <a href="https://leetcode.com/problems/convert-bst-to-greater-tree/" target="_blank">https://leetcode.com/problems/convert-bst-to-greater-tree/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/104-maximum-depth-of-binary-tree/104-maximum-depth-of-binary-tree.java b/leetcode/leetcode/104-maximum-depth-of-binary-tree/104-maximum-depth-of-binary-tree.java
new file mode 100644
index 0000000..3abacb8
--- /dev/null
+++ b/leetcode/leetcode/104-maximum-depth-of-binary-tree/104-maximum-depth-of-binary-tree.java
@@ -0,0 +1,21 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if(root == null) return 0;
+        return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/104-maximum-depth-of-binary-tree/NOTES.md b/leetcode/leetcode/104-maximum-depth-of-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/104-maximum-depth-of-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/104-maximum-depth-of-binary-tree/README.md b/leetcode/leetcode/104-maximum-depth-of-binary-tree/README.md
new file mode 100644
index 0000000..48ceddf
--- /dev/null
+++ b/leetcode/leetcode/104-maximum-depth-of-binary-tree/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/maximum-depth-of-binary-tree/">104. Maximum Depth of Binary Tree</a></h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>its maximum depth</em>.</p>
+
+<p>A binary tree's <strong>maximum depth</strong>&nbsp;is the number of nodes along the longest path from the root node down to the farthest leaf node.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg" style="width: 400px; height: 277px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,null,2]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/105-construct-binary-tree-from-preorder-and-inorder-traversal.java b/leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/105-construct-binary-tree-from-preorder-and-inorder-traversal.java
new file mode 100644
index 0000000..3257e2a
--- /dev/null
+++ b/leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/105-construct-binary-tree-from-preorder-and-inorder-traversal.java
@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    private TreeNode helper(int[] preorder, int[] inorder, int preStart, int preEnd, int inStart, int inEnd,HashMap<Integer,Integer> map){
+        if(preStart>preEnd) return null;
+        TreeNode root = new TreeNode(preorder[preStart]);
+        int index = map.get(preorder[preStart]);
+        root.left = helper(preorder,inorder,preStart+1,preStart+index - inStart,inStart,index,map);
+        root.right  = helper(preorder,inorder,preStart+1+index - inStart,preEnd,index+1,inEnd,map);
+        return root;
+    }
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        int len = preorder.length;
+        HashMap<Integer,Integer> map = new HashMap<>(len);
+        for(int i = 0;i<len;i++) map.put(inorder[i],i);
+        return helper(preorder,inorder,0,len-1,0,len-1,map);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/NOTES.md b/leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/README.md b/leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/README.md
new file mode 100644
index 0000000..050dde7
--- /dev/null
+++ b/leetcode/leetcode/105-construct-binary-tree-from-preorder-and-inorder-traversal/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/">105. Construct Binary Tree from Preorder and Inorder Traversal</a></h2><h3>Medium</h3><hr><div><p>Given two integer arrays <code>preorder</code> and <code>inorder</code> where <code>preorder</code> is the preorder traversal of a binary tree and <code>inorder</code> is the inorder traversal of the same tree, construct and return <em>the binary tree</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree.jpg" style="width: 277px; height: 302px;">
+<pre><strong>Input:</strong> preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
+<strong>Output:</strong> [3,9,20,null,null,15,7]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> preorder = [-1], inorder = [-1]
+<strong>Output:</strong> [-1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= preorder.length &lt;= 3000</code></li>
+	<li><code>inorder.length == preorder.length</code></li>
+	<li><code>-3000 &lt;= preorder[i], inorder[i] &lt;= 3000</code></li>
+	<li><code>preorder</code> and <code>inorder</code> consist of <strong>unique</strong> values.</li>
+	<li>Each value of <code>inorder</code> also appears in <code>preorder</code>.</li>
+	<li><code>preorder</code> is <strong>guaranteed</strong> to be the preorder traversal of the tree.</li>
+	<li><code>inorder</code> is <strong>guaranteed</strong> to be the inorder traversal of the tree.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1050-construct-binary-search-tree-from-preorder-traversal/1050-construct-binary-search-tree-from-preorder-traversal.java b/leetcode/leetcode/1050-construct-binary-search-tree-from-preorder-traversal/1050-construct-binary-search-tree-from-preorder-traversal.java
new file mode 100644
index 0000000..6e14216
--- /dev/null
+++ b/leetcode/leetcode/1050-construct-binary-search-tree-from-preorder-traversal/1050-construct-binary-search-tree-from-preorder-traversal.java
@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    int index = 0;
+    public TreeNode helper(int[] preorder, int upperBound){
+        if(index == preorder.length) return null;
+        if(preorder[index]>=upperBound) return null;
+        TreeNode root = new TreeNode(preorder[index++]);
+        root.left = helper(preorder,root.val);
+        root.right = helper(preorder,upperBound);
+        return root;
+
+    }
+    public TreeNode bstFromPreorder(int[] preorder) {
+        return helper(preorder, Integer.MAX_VALUE);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1050-construct-binary-search-tree-from-preorder-traversal/README.md b/leetcode/leetcode/1050-construct-binary-search-tree-from-preorder-traversal/README.md
new file mode 100644
index 0000000..d3d0510
--- /dev/null
+++ b/leetcode/leetcode/1050-construct-binary-search-tree-from-preorder-traversal/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal">1050. Construct Binary Search Tree from Preorder Traversal</a></h2><h3>Medium</h3><hr><p>Given an array of integers preorder, which represents the <strong>preorder traversal</strong> of a BST (i.e., <strong>binary search tree</strong>), construct the tree and return <em>its root</em>.</p>
+
+<p>It is <strong>guaranteed</strong> that there is always possible to find a binary search tree with the given requirements for the given test cases.</p>
+
+<p>A <strong>binary search tree</strong> is a binary tree where for every node, any descendant of <code>Node.left</code> has a value <strong>strictly less than</strong> <code>Node.val</code>, and any descendant of <code>Node.right</code> has a value <strong>strictly greater than</strong> <code>Node.val</code>.</p>
+
+<p>A <strong>preorder traversal</strong> of a binary tree displays the value of the node first, then traverses <code>Node.left</code>, then traverses <code>Node.right</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/03/06/1266.png" style="height: 386px; width: 590px;" />
+<pre>
+<strong>Input:</strong> preorder = [8,5,1,7,10,12]
+<strong>Output:</strong> [8,5,10,1,7,null,12]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> preorder = [1,3]
+<strong>Output:</strong> [1,null,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= preorder.length &lt;= 100</code></li>
+	<li><code>1 &lt;= preorder[i] &lt;= 1000</code></li>
+	<li>All the values of <code>preorder</code> are <strong>unique</strong>.</li>
+</ul>
diff --git a/leetcode/leetcode/1056-capacity-to-ship-packages-within-d-days/1056-capacity-to-ship-packages-within-d-days.java b/leetcode/leetcode/1056-capacity-to-ship-packages-within-d-days/1056-capacity-to-ship-packages-within-d-days.java
new file mode 100644
index 0000000..3dd9b46
--- /dev/null
+++ b/leetcode/leetcode/1056-capacity-to-ship-packages-within-d-days/1056-capacity-to-ship-packages-within-d-days.java
@@ -0,0 +1,36 @@
+class Solution {
+    public boolean canShip(int[] weight, int cap, int days){
+        int currentDays = 1;
+        int currentCap = 0;
+        for(int num: weight){
+            if(currentCap + num > cap ){
+                currentDays++;
+                currentCap = num;
+            }else{
+                currentCap+=num;
+            }
+        }
+        return currentDays<=days;
+    }
+    public int shipWithinDays(int[] weights, int days) {
+        int low = 0;
+        int high = 0;
+        for(int num: weights){
+            low = Math.max(num,low);
+            high+=num;
+        }
+
+        int ans = 0;
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(canShip(weights,mid,days)){
+                ans = mid;
+                high = mid-1;
+            }else{
+                low = mid+1;
+            }
+        }
+        return ans;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1056-capacity-to-ship-packages-within-d-days/README.md b/leetcode/leetcode/1056-capacity-to-ship-packages-within-d-days/README.md
new file mode 100644
index 0000000..e2211f0
--- /dev/null
+++ b/leetcode/leetcode/1056-capacity-to-ship-packages-within-d-days/README.md
@@ -0,0 +1,52 @@
+<h2><a href="https://leetcode.com/problems/capacity-to-ship-packages-within-d-days">1056. Capacity To Ship Packages Within D Days</a></h2><h3>Medium</h3><hr><p>A conveyor belt has packages that must be shipped from one port to another within <code>days</code> days.</p>
+
+<p>The <code>i<sup>th</sup></code> package on the conveyor belt has a weight of <code>weights[i]</code>. Each day, we load the ship with packages on the conveyor belt (in the order given by <code>weights</code>). We may not load more weight than the maximum weight capacity of the ship.</p>
+
+<p>Return the least weight capacity of the ship that will result in all the packages on the conveyor belt being shipped within <code>days</code> days.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> weights = [1,2,3,4,5,6,7,8,9,10], days = 5
+<strong>Output:</strong> 15
+<strong>Explanation:</strong> A ship capacity of 15 is the minimum to ship all the packages in 5 days like this:
+1st day: 1, 2, 3, 4, 5
+2nd day: 6, 7
+3rd day: 8
+4th day: 9
+5th day: 10
+
+Note that the cargo must be shipped in the order given, so using a ship of capacity 14 and splitting the packages into parts like (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) is not allowed.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> weights = [3,2,2,4,1,4], days = 3
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> A ship capacity of 6 is the minimum to ship all the packages in 3 days like this:
+1st day: 3, 2
+2nd day: 2, 4
+3rd day: 1, 4
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> weights = [1,2,3,1,1], days = 4
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+1st day: 1
+2nd day: 2
+3rd day: 3
+4th day: 1, 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= days &lt;= weights.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= weights[i] &lt;= 500</code></li>
+</ul>
diff --git a/leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/106-construct-binary-tree-from-inorder-and-postorder-traversal.java b/leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/106-construct-binary-tree-from-inorder-and-postorder-traversal.java
new file mode 100644
index 0000000..d80ed47
--- /dev/null
+++ b/leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/106-construct-binary-tree-from-inorder-and-postorder-traversal.java
@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode buildTreeHelper(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd){
+        if(inStart>inEnd) return null;
+        int val = postorder[postEnd];
+        TreeNode root = new TreeNode(val);
+        int index = inStart;
+        for(;index<=inEnd;index++){
+            if(inorder[index] == val) break;
+        }
+        int leftTreeSize = index - inStart;
+        int rightTreeSize = inEnd - index;
+        root.left = buildTreeHelper(inorder,inStart,index-1,postorder,postStart,postStart + leftTreeSize - 1);
+        root.right = buildTreeHelper(inorder,index+1,inEnd,postorder,postEnd -rightTreeSize ,postEnd-1);
+        return root;
+    }
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        return buildTreeHelper(inorder,0,inorder.length-1,postorder,0,postorder.length-1);
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/NOTES.md b/leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/README.md b/leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/README.md
new file mode 100644
index 0000000..6ee8e39
--- /dev/null
+++ b/leetcode/leetcode/106-construct-binary-tree-from-inorder-and-postorder-traversal/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/">106. Construct Binary Tree from Inorder and Postorder Traversal</a></h2><h3>Medium</h3><hr><div><p>Given two integer arrays <code>inorder</code> and <code>postorder</code> where <code>inorder</code> is the inorder traversal of a binary tree and <code>postorder</code> is the postorder traversal of the same tree, construct and return <em>the binary tree</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree.jpg" style="width: 277px; height: 302px;">
+<pre><strong>Input:</strong> inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
+<strong>Output:</strong> [3,9,20,null,null,15,7]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> inorder = [-1], postorder = [-1]
+<strong>Output:</strong> [-1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= inorder.length &lt;= 3000</code></li>
+	<li><code>postorder.length == inorder.length</code></li>
+	<li><code>-3000 &lt;= inorder[i], postorder[i] &lt;= 3000</code></li>
+	<li><code>inorder</code> and <code>postorder</code> consist of <strong>unique</strong> values.</li>
+	<li>Each value of <code>postorder</code> also appears in <code>inorder</code>.</li>
+	<li><code>inorder</code> is <strong>guaranteed</strong> to be the inorder traversal of the tree.</li>
+	<li><code>postorder</code> is <strong>guaranteed</strong> to be the postorder traversal of the tree.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1061-lexicographically-smallest-equivalent-string/1061-lexicographically-smallest-equivalent-string.java b/leetcode/leetcode/1061-lexicographically-smallest-equivalent-string/1061-lexicographically-smallest-equivalent-string.java
new file mode 100644
index 0000000..efc1e8b
--- /dev/null
+++ b/leetcode/leetcode/1061-lexicographically-smallest-equivalent-string/1061-lexicographically-smallest-equivalent-string.java
@@ -0,0 +1,27 @@
+class Solution {
+    int[] representation = new int[26];
+    int find(int x){
+        if(x == representation[x]) return x;
+        representation[x] = find(representation[x]);
+        return representation[x];
+    }
+    void performUnion(int x, int y){
+        x = find(x);
+        y = find(y);
+        if(x == y) return;
+        if(x<y) representation[y] = x;
+        else representation[x] = y;
+    }
+    public String smallestEquivalentString(String s1, String s2, String baseStr) {
+        for(int i = 0;i<26;i++){
+            representation[i] = i;
+        }
+        for(int i = 0;i<s1.length();i++){
+            performUnion(s1.charAt(i)-'a',s2.charAt(i)-'a');
+        }
+        StringBuilder sb = new StringBuilder(baseStr.length());
+        for(int i = 0;i<baseStr.length();i++) sb.append((char) (find(baseStr.charAt(i)-'a')+'a'));
+        return sb.toString();
+    
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1061-lexicographically-smallest-equivalent-string/README.md b/leetcode/leetcode/1061-lexicographically-smallest-equivalent-string/README.md
new file mode 100644
index 0000000..0cdfde4
--- /dev/null
+++ b/leetcode/leetcode/1061-lexicographically-smallest-equivalent-string/README.md
@@ -0,0 +1,54 @@
+<h2><a href="https://leetcode.com/problems/lexicographically-smallest-equivalent-string/">1061. Lexicographically Smallest Equivalent String</a></h2><h3>Medium</h3><hr><div><p>You are given two strings of the same length <code>s1</code> and <code>s2</code> and a string <code>baseStr</code>.</p>
+
+<p>We say <code>s1[i]</code> and <code>s2[i]</code> are equivalent characters.</p>
+
+<ul>
+	<li>For example, if <code>s1 = "abc"</code> and <code>s2 = "cde"</code>, then we have <code>'a' == 'c'</code>, <code>'b' == 'd'</code>, and <code>'c' == 'e'</code>.</li>
+</ul>
+
+<p>Equivalent characters follow the usual rules of any equivalence relation:</p>
+
+<ul>
+	<li><strong>Reflexivity:</strong> <code>'a' == 'a'</code>.</li>
+	<li><strong>Symmetry:</strong> <code>'a' == 'b'</code> implies <code>'b' == 'a'</code>.</li>
+	<li><strong>Transitivity:</strong> <code>'a' == 'b'</code> and <code>'b' == 'c'</code> implies <code>'a' == 'c'</code>.</li>
+</ul>
+
+<p>For example, given the equivalency information from <code>s1 = "abc"</code> and <code>s2 = "cde"</code>, <code>"acd"</code> and <code>"aab"</code> are equivalent strings of <code>baseStr = "eed"</code>, and <code>"aab"</code> is the lexicographically smallest equivalent string of <code>baseStr</code>.</p>
+
+<p>Return <em>the lexicographically smallest equivalent string of </em><code>baseStr</code><em> by using the equivalency information from </em><code>s1</code><em> and </em><code>s2</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s1 = "parker", s2 = "morris", baseStr = "parser"
+<strong>Output:</strong> "makkek"
+<strong>Explanation:</strong> Based on the equivalency information in s1 and s2, we can group their characters as [m,p], [a,o], [k,r,s], [e,i].
+The characters in each group are equivalent and sorted in lexicographical order.
+So the answer is "makkek".
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s1 = "hello", s2 = "world", baseStr = "hold"
+<strong>Output:</strong> "hdld"
+<strong>Explanation: </strong>Based on the equivalency information in s1 and s2, we can group their characters as [h,w], [d,e,o], [l,r].
+So only the second letter 'o' in baseStr is changed to 'd', the answer is "hdld".
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s1 = "leetcode", s2 = "programs", baseStr = "sourcecode"
+<strong>Output:</strong> "aauaaaaada"
+<strong>Explanation:</strong> We group the equivalent characters in s1 and s2 as [a,o,e,r,s,c], [l,p], [g,t] and [d,m], thus all letters in baseStr except 'u' and 'd' are transformed to 'a', the answer is "aauaaaaada".
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s1.length, s2.length, baseStr &lt;= 1000</code></li>
+	<li><code>s1.length == s2.length</code></li>
+	<li><code>s1</code>, <code>s2</code>, and <code>baseStr</code> consist of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/107-binary-tree-level-order-traversal-ii/107-binary-tree-level-order-traversal-ii.java b/leetcode/leetcode/107-binary-tree-level-order-traversal-ii/107-binary-tree-level-order-traversal-ii.java
new file mode 100644
index 0000000..87c2e26
--- /dev/null
+++ b/leetcode/leetcode/107-binary-tree-level-order-traversal-ii/107-binary-tree-level-order-traversal-ii.java
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> levelOrderBottom(TreeNode root) {
+        List<List<Integer>> list = new LinkedList<List<Integer>>();
+        if(root == null) return list;
+        Queue<TreeNode> q = new LinkedList<>();
+        q.offer(root);
+        while(!q.isEmpty()){
+            List<Integer> temp = new ArrayList<>();
+            for(int i = q.size();i!=0;i--){
+                TreeNode front = q.remove();
+                temp.add(front.val);
+                if(front.left!=null) q.offer(front.left);
+                if(front.right!=null) q.offer(front.right);
+            }
+            list.add(0,temp);
+        }
+        // Collections.reverse(list);
+        return list;
+        
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/107-binary-tree-level-order-traversal-ii/NOTES.md b/leetcode/leetcode/107-binary-tree-level-order-traversal-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/107-binary-tree-level-order-traversal-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/107-binary-tree-level-order-traversal-ii/README.md b/leetcode/leetcode/107-binary-tree-level-order-traversal-ii/README.md
new file mode 100644
index 0000000..6b423cf
--- /dev/null
+++ b/leetcode/leetcode/107-binary-tree-level-order-traversal-ii/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-level-order-traversal-ii/">107. Binary Tree Level Order Traversal II</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the bottom-up level order traversal of its nodes' values</em>. (i.e., from left to right, level by level from leaf to root).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg" style="width: 277px; height: 302px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> [[15,7],[9,20],[3]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> [[1]]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1071-greatest-common-divisor-of-strings/1071-greatest-common-divisor-of-strings.java b/leetcode/leetcode/1071-greatest-common-divisor-of-strings/1071-greatest-common-divisor-of-strings.java
new file mode 100644
index 0000000..bbb55fe
--- /dev/null
+++ b/leetcode/leetcode/1071-greatest-common-divisor-of-strings/1071-greatest-common-divisor-of-strings.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int gcd(int x, int y) {
+        if (y == 0) {
+            return x;
+        } else {
+            return gcd(y, x % y);
+        }    
+    }
+    
+    public String gcdOfStrings(String str1, String str2) {
+        if (!(str1 + str2).equals(str2 + str1)) {
+            return "";
+        }
+        int gcdLength = gcd(str1.length(), str2.length());
+        return str1.substring(0, gcdLength);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1071-greatest-common-divisor-of-strings/NOTES.md b/leetcode/leetcode/1071-greatest-common-divisor-of-strings/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1071-greatest-common-divisor-of-strings/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1071-greatest-common-divisor-of-strings/README.md b/leetcode/leetcode/1071-greatest-common-divisor-of-strings/README.md
new file mode 100644
index 0000000..67a8a3a
--- /dev/null
+++ b/leetcode/leetcode/1071-greatest-common-divisor-of-strings/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/greatest-common-divisor-of-strings/">1071. Greatest Common Divisor of Strings</a></h2><h3>Easy</h3><hr><div><p>For two strings <code>s</code> and <code>t</code>, we say "<code>t</code> divides <code>s</code>" if and only if <code>s = t + ... + t</code> (i.e., <code>t</code> is concatenated with itself one or more times).</p>
+
+<p>Given two strings <code>str1</code> and <code>str2</code>, return <em>the largest string </em><code>x</code><em> such that </em><code>x</code><em> divides both </em><code>str1</code><em> and </em><code>str2</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> str1 = "ABCABC", str2 = "ABC"
+<strong>Output:</strong> "ABC"
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> str1 = "ABABAB", str2 = "ABAB"
+<strong>Output:</strong> "AB"
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> str1 = "LEET", str2 = "CODE"
+<strong>Output:</strong> ""
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= str1.length, str2.length &lt;= 1000</code></li>
+	<li><code>str1</code> and <code>str2</code> consist of English uppercase letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/1081-smallest-subsequence-of-distinct-characters.java b/leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/1081-smallest-subsequence-of-distinct-characters.java
new file mode 100644
index 0000000..6f6d2f7
--- /dev/null
+++ b/leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/1081-smallest-subsequence-of-distinct-characters.java
@@ -0,0 +1,51 @@
+class Solution {
+    public String smallestSubsequence(String s) {
+        if(s.length()<2) return s;
+        boolean[] exist = new boolean[26];
+        StringBuilder sb = new StringBuilder();
+        int[] freq = new int[26];
+        for(int i = 0;i<s.length();i++){
+            freq[s.charAt(i) - 'a']++;
+        }
+        int size = 0;
+        int i = 0;
+        while(i<s.length()){
+            if(size == 0){
+                sb.append(s.charAt(i));
+                exist[s.charAt(i) - 'a'] = true;
+                freq[s.charAt(i) - 'a']--;
+                size++;
+                i++;
+                continue;
+            }
+            if(!exist[s.charAt(i) - 'a']){
+                if(sb.charAt(size-1)<s.charAt(i)){
+                    sb.append(s.charAt(i));
+                    size++;
+                    freq[s.charAt(i) - 'a']--;
+                    exist[s.charAt(i) - 'a'] = true;
+                }else{
+                    if(freq[sb.charAt(size - 1)-'a']>=1){
+                        exist[sb.charAt(size-1) - 'a'] = false;
+                        sb.deleteCharAt(size - 1);
+                        size--;
+                        continue;
+                        
+                    }else{
+                        sb.append(s.charAt(i));
+                        size++;
+                        freq[s.charAt(i) - 'a']--;
+                        exist[s.charAt(i) - 'a'] = true;
+
+                    }
+                }
+            }else {
+                freq[s.charAt(i) - 'a']--;
+                
+            }
+            i++;
+                
+        }
+        return sb.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/NOTES.md b/leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/README.md b/leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/README.md
new file mode 100644
index 0000000..ec5bff0
--- /dev/null
+++ b/leetcode/leetcode/1081-smallest-subsequence-of-distinct-characters/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/smallest-subsequence-of-distinct-characters/">1081. Smallest Subsequence of Distinct Characters</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code>, return <em>the lexicographically smallest subsequence of</em> <code>s</code> <em>that contains all the distinct characters of</em> <code>s</code> <em>exactly once</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "bcabc"
+<strong>Output:</strong> "abc"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "cbacdcbc"
+<strong>Output:</strong> "acdb"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 1000</code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Note:</strong> This question is the same as 316: <a href="https://leetcode.com/problems/remove-duplicate-letters/" target="_blank">https://leetcode.com/problems/remove-duplicate-letters/</a></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1089-duplicate-zeros/1089-duplicate-zeros.java b/leetcode/leetcode/1089-duplicate-zeros/1089-duplicate-zeros.java
new file mode 100644
index 0000000..ff01f36
--- /dev/null
+++ b/leetcode/leetcode/1089-duplicate-zeros/1089-duplicate-zeros.java
@@ -0,0 +1,23 @@
+class Solution {
+    private void rightShift(int[] arr, int startIndex){
+        int endIndex = arr.length - 2;
+        while(endIndex>=startIndex){
+            swap(arr,endIndex,endIndex +1);
+            endIndex--;
+        }
+    }
+    private void swap(int[] arr, int i , int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    public void duplicateZeros(int[] arr) {
+        for(int i = 0 ;i<arr.length-1;i++){
+            if(arr[i] == 0){
+                rightShift(arr,i+1);
+                arr[i+1] = 0;
+                i++;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1089-duplicate-zeros/README.md b/leetcode/leetcode/1089-duplicate-zeros/README.md
new file mode 100644
index 0000000..3ed8693
--- /dev/null
+++ b/leetcode/leetcode/1089-duplicate-zeros/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/duplicate-zeros/">1089. Duplicate Zeros</a></h2><h3>Easy</h3><hr><div><p>Given a fixed-length integer array <code>arr</code>, duplicate each occurrence of zero, shifting the remaining elements to the right.</p>
+
+<p><strong>Note</strong> that elements beyond the length of the original array are not written. Do the above modifications to the input array in place and do not return anything.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,0,2,3,0,4,5,0]
+<strong>Output:</strong> [1,0,0,2,3,0,0,4]
+<strong>Explanation:</strong> After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,3]
+<strong>Output:</strong> [1,2,3]
+<strong>Explanation:</strong> After calling your function, the input array is modified to: [1,2,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= arr[i] &lt;= 9</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1093-recover-a-tree-from-preorder-traversal/1093-recover-a-tree-from-preorder-traversal.java b/leetcode/leetcode/1093-recover-a-tree-from-preorder-traversal/1093-recover-a-tree-from-preorder-traversal.java
new file mode 100644
index 0000000..e2472fa
--- /dev/null
+++ b/leetcode/leetcode/1093-recover-a-tree-from-preorder-traversal/1093-recover-a-tree-from-preorder-traversal.java
@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    int index = 0;
+    public TreeNode helper(ArrayList<Pair<Integer,Integer>> list, int level){
+        if(index==list.size()) return null;
+        if(list.get(index).getKey() != level) return null;
+        TreeNode root = new TreeNode(list.get(index).getValue());
+        index++;
+        root.left  = helper(list,level+1);
+        root.right = helper(list,level+1);
+        return root;
+    }
+    public TreeNode recoverFromPreorder(String traversal) {
+        ArrayList<Pair<Integer,Integer>> list = new ArrayList<>();
+        int index = 0;
+        while(index<traversal.length()){
+            int currentLevel = 0;
+            while(traversal.charAt(index)=='-' ){
+                currentLevel++;
+                index++;
+            }
+            int number = 0;
+            while(index<traversal.length() && traversal.charAt(index)!='-' ){
+                number = number*10 + (int) traversal.charAt(index) - '0';
+                index++;
+            }
+            list.add(new Pair(currentLevel,number));
+        }
+        return helper(list,0);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1093-recover-a-tree-from-preorder-traversal/README.md b/leetcode/leetcode/1093-recover-a-tree-from-preorder-traversal/README.md
new file mode 100644
index 0000000..b70ae54
--- /dev/null
+++ b/leetcode/leetcode/1093-recover-a-tree-from-preorder-traversal/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/recover-a-tree-from-preorder-traversal">1093. Recover a Tree From Preorder Traversal</a></h2><h3>Hard</h3><hr><p>We run a&nbsp;preorder&nbsp;depth-first search (DFS) on the <code>root</code> of a binary tree.</p>
+
+<p>At each node in this traversal, we output <code>D</code> dashes (where <code>D</code> is the depth of this node), then we output the value of this node.&nbsp; If the depth of a node is <code>D</code>, the depth of its immediate child is <code>D + 1</code>.&nbsp; The depth of the <code>root</code> node is <code>0</code>.</p>
+
+<p>If a node has only one child, that child is guaranteed to be <strong>the left child</strong>.</p>
+
+<p>Given the output <code>traversal</code> of this traversal, recover the tree and return <em>its</em> <code>root</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2024/09/10/recover_tree_ex1.png" style="width: 423px; height: 200px;" />
+<pre>
+<strong>Input:</strong> traversal = &quot;1-2--3--4-5--6--7&quot;
+<strong>Output:</strong> [1,2,5,3,4,6,7]
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2024/09/10/recover_tree_ex2.png" style="width: 432px; height: 250px;" />
+<pre>
+<strong>Input:</strong> traversal = &quot;1-2--3---4-5--6---7&quot;
+<strong>Output:</strong> [1,2,5,3,null,6,null,4,null,7]
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2024/09/10/recover_tree_ex3.png" style="width: 305px; height: 250px;" />
+<pre>
+<strong>Input:</strong> traversal = &quot;1-401--349---90--88&quot;
+<strong>Output:</strong> [1,401,null,349,88,90]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the original tree is in the range <code>[1, 1000]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/11-container-with-most-water/11-container-with-most-water.java b/leetcode/leetcode/11-container-with-most-water/11-container-with-most-water.java
new file mode 100644
index 0000000..76afd9b
--- /dev/null
+++ b/leetcode/leetcode/11-container-with-most-water/11-container-with-most-water.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxArea(int[] height) {
+        int i = 0;
+        int j = height.length -1;
+        int max = 0;
+        while(i<j){
+            if(height[i]>height[j]){
+                max = Math.max(max,(j-i)*height[j]);
+                j--;
+            }else{
+                max = Math.max(max,(j-i)*height[i]);
+                i++;
+            }
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/11-container-with-most-water/NOTES.md b/leetcode/leetcode/11-container-with-most-water/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/11-container-with-most-water/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/11-container-with-most-water/README.md b/leetcode/leetcode/11-container-with-most-water/README.md
new file mode 100644
index 0000000..fcf8ccc
--- /dev/null
+++ b/leetcode/leetcode/11-container-with-most-water/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/container-with-most-water/">11. Container With Most Water</a></h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>height</code> of length <code>n</code>. There are <code>n</code> vertical lines drawn such that the two endpoints of the <code>i<sup>th</sup></code> line are <code>(i, 0)</code> and <code>(i, height[i])</code>.</p>
+
+<p>Find two lines that together with the x-axis form a container, such that the container contains the most water.</p>
+
+<p>Return <em>the maximum amount of water a container can store</em>.</p>
+
+<p><strong>Notice</strong> that you may not slant the container.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/17/question_11.jpg" style="width: 600px; height: 287px;">
+<pre><strong>Input:</strong> height = [1,8,6,2,5,4,8,3,7]
+<strong>Output:</strong> 49
+<strong>Explanation:</strong> The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> height = [1,1]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == height.length</code></li>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= height[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1110-delete-nodes-and-return-forest/1110-delete-nodes-and-return-forest.java b/leetcode/leetcode/1110-delete-nodes-and-return-forest/1110-delete-nodes-and-return-forest.java
new file mode 100644
index 0000000..10c39e8
--- /dev/null
+++ b/leetcode/leetcode/1110-delete-nodes-and-return-forest/1110-delete-nodes-and-return-forest.java
@@ -0,0 +1,60 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<TreeNode> delNodesHelper(TreeNode root, HashSet<Integer> set){
+        List<TreeNode> list = new ArrayList<>();
+        if(root == null) return list;
+        if(set.contains(root.val)){
+            set.remove(root.val);
+            list.addAll(delNodesHelper(root.left,set));            
+            list.addAll(delNodesHelper(root.right,set));
+            return list;
+        }
+        Queue<TreeNode> q = new LinkedList<>();
+        TreeNode root1 = root;
+        q.add(root);
+        while(!q.isEmpty()){
+            for(int i = q.size();i!=0;i--){
+                root = q.remove();
+                if(root.left !=null){
+                    if(set.contains(root.left.val)){
+                        list.addAll(delNodesHelper(root.left,set));
+                        root.left = null;
+                    }else{
+                        q.add(root.left);
+                    }
+                }               
+                if(root.right !=null){
+                    if(set.contains(root.right.val)){
+                        list.addAll(delNodesHelper(root.right,set));
+                        root.right = null;
+                    }else{
+                        q.add(root.right);
+                    }
+                }
+            }
+        }
+        list.add(root1);
+        return list;
+    }
+    public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
+        HashSet<Integer> set = new HashSet<>();
+        for(int n: to_delete){
+            set.add(n);
+        }
+        return delNodesHelper(root,set);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1110-delete-nodes-and-return-forest/NOTES.md b/leetcode/leetcode/1110-delete-nodes-and-return-forest/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1110-delete-nodes-and-return-forest/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1110-delete-nodes-and-return-forest/README.md b/leetcode/leetcode/1110-delete-nodes-and-return-forest/README.md
new file mode 100644
index 0000000..8424099
--- /dev/null
+++ b/leetcode/leetcode/1110-delete-nodes-and-return-forest/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/delete-nodes-and-return-forest/">1110. Delete Nodes And Return Forest</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, each node in the tree has a distinct value.</p>
+
+<p>After deleting all nodes with a value in <code>to_delete</code>, we are left with a forest (a disjoint union of trees).</p>
+
+<p>Return the roots of the trees in the remaining forest. You may return the result in any order.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/07/01/screen-shot-2019-07-01-at-53836-pm.png" style="width: 237px; height: 150px;">
+<pre><strong>Input:</strong> root = [1,2,3,4,5,6,7], to_delete = [3,5]
+<strong>Output:</strong> [[1,2,null,4],[6],[7]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,2,4,null,3], to_delete = [3]
+<strong>Output:</strong> [[1,2,4]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the given tree is at most <code>1000</code>.</li>
+	<li>Each node has a distinct value between <code>1</code> and <code>1000</code>.</li>
+	<li><code>to_delete.length &lt;= 1000</code></li>
+	<li><code>to_delete</code> contains distinct values between <code>1</code> and <code>1000</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1122-relative-sort-array/1122-relative-sort-array.java b/leetcode/leetcode/1122-relative-sort-array/1122-relative-sort-array.java
new file mode 100644
index 0000000..79e9d83
--- /dev/null
+++ b/leetcode/leetcode/1122-relative-sort-array/1122-relative-sort-array.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int[] relativeSortArray(int[] arr1, int[] arr2) {
+        int[] freq = new int[1001];
+        for(int ele: arr1)
+            freq[ele]++;
+        int index = 0;
+        for(int ele: arr2){
+            while(freq[ele]>0){
+                arr1[index++] = ele;
+                freq[ele]--;
+            }
+        }
+        for(int i = 0;i<1001;i++){
+            while(freq[i]>0){
+                arr1[index++] = i;
+                freq[i]--;
+            }
+        }
+        return arr1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1122-relative-sort-array/NOTES.md b/leetcode/leetcode/1122-relative-sort-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1122-relative-sort-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1122-relative-sort-array/README.md b/leetcode/leetcode/1122-relative-sort-array/README.md
new file mode 100644
index 0000000..5023300
--- /dev/null
+++ b/leetcode/leetcode/1122-relative-sort-array/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/relative-sort-array/">1122. Relative Sort Array</a></h2><h3>Easy</h3><hr><div><p>Given two arrays <code>arr1</code> and <code>arr2</code>, the elements of <code>arr2</code> are distinct, and all elements in <code>arr2</code> are also in <code>arr1</code>.</p>
+
+<p>Sort the elements of <code>arr1</code> such that the relative ordering of items in <code>arr1</code> are the same as in <code>arr2</code>. Elements that do not appear in <code>arr2</code> should be placed at the end of <code>arr1</code> in <strong>ascending</strong> order.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
+<strong>Output:</strong> [2,2,2,1,4,3,3,9,6,7,19]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr1 = [28,6,22,8,44,17], arr2 = [22,28,8,6]
+<strong>Output:</strong> [22,28,8,6,17,44]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr1.length, arr2.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= arr1[i], arr2[i] &lt;= 1000</code></li>
+	<li>All the elements of <code>arr2</code> are <strong>distinct</strong>.</li>
+	<li>Each&nbsp;<code>arr2[i]</code> is in <code>arr1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1137-n-th-tribonacci-number/1137-n-th-tribonacci-number.java b/leetcode/leetcode/1137-n-th-tribonacci-number/1137-n-th-tribonacci-number.java
new file mode 100644
index 0000000..8495c93
--- /dev/null
+++ b/leetcode/leetcode/1137-n-th-tribonacci-number/1137-n-th-tribonacci-number.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int tribonacci(int n) {
+        if(n<2) return n;
+        if(n==2) return 1;
+        int first = 0;
+        int second = 1;
+        int third = 1;
+        int current = first + second + third;
+        while(--n!=1){
+            current = first + second + third;
+            first = second;
+            second = third;
+            third = current;
+        }
+        return current;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1137-n-th-tribonacci-number/NOTES.md b/leetcode/leetcode/1137-n-th-tribonacci-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1137-n-th-tribonacci-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1137-n-th-tribonacci-number/README.md b/leetcode/leetcode/1137-n-th-tribonacci-number/README.md
new file mode 100644
index 0000000..15d85bc
--- /dev/null
+++ b/leetcode/leetcode/1137-n-th-tribonacci-number/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/n-th-tribonacci-number/">1137. N-th Tribonacci Number</a></h2><h3>Easy</h3><hr><div><p>The Tribonacci sequence T<sub>n</sub> is defined as follows:&nbsp;</p>
+
+<p>T<sub>0</sub> = 0, T<sub>1</sub> = 1, T<sub>2</sub> = 1, and T<sub>n+3</sub> = T<sub>n</sub> + T<sub>n+1</sub> + T<sub>n+2</sub> for n &gt;= 0.</p>
+
+<p>Given <code>n</code>, return the value of T<sub>n</sub>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+T_3 = 0 + 1 + 1 = 2
+T_4 = 1 + 1 + 2 = 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 25
+<strong>Output:</strong> 1389537
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 37</code></li>
+	<li>The answer is guaranteed to fit within a 32-bit integer, ie. <code>answer &lt;= 2^31 - 1</code>.</li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1143-longest-common-subsequence/1143-longest-common-subsequence.java b/leetcode/leetcode/1143-longest-common-subsequence/1143-longest-common-subsequence.java
new file mode 100644
index 0000000..d9c645d
--- /dev/null
+++ b/leetcode/leetcode/1143-longest-common-subsequence/1143-longest-common-subsequence.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int lcs(String text1, String text2, int i, int j, int[][] dp){
+        if(i == text1.length() || j == text2.length()) return 0;
+        if(dp[i][j]!=-1) return dp[i][j];
+        if(text1.charAt(i) == text2.charAt(j)){
+            dp[i][j] = 1 + lcs(text1,text2,i+1,j+1,dp);
+        }else{
+            dp[i][j] = Math.max(lcs(text1,text2,i+1,j,dp),lcs(text1,text2,i,j+1,dp));
+        }
+        return dp[i][j];
+               
+    }
+    public int longestCommonSubsequence(String text1, String text2) {
+        int[][] dp = new int[text1.length()][text2.length()];
+        for(int i = 0;i<text1.length();i++){
+            for(int j = 0;j<text2.length();j++){
+                dp[i][j] = -1;
+            }
+        }
+        return lcs(text1,text2,0,0,dp);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1143-longest-common-subsequence/NOTES.md b/leetcode/leetcode/1143-longest-common-subsequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1143-longest-common-subsequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1143-longest-common-subsequence/README.md b/leetcode/leetcode/1143-longest-common-subsequence/README.md
new file mode 100644
index 0000000..4455115
--- /dev/null
+++ b/leetcode/leetcode/1143-longest-common-subsequence/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/longest-common-subsequence/">1143. Longest Common Subsequence</a></h2><h3>Medium</h3><hr><div><p>Given two strings <code>text1</code> and <code>text2</code>, return <em>the length of their longest <strong>common subsequence</strong>. </em>If there is no <strong>common subsequence</strong>, return <code>0</code>.</p>
+
+<p>A <strong>subsequence</strong> of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.</p>
+
+<ul>
+	<li>For example, <code>"ace"</code> is a subsequence of <code>"abcde"</code>.</li>
+</ul>
+
+<p>A <strong>common subsequence</strong> of two strings is a subsequence that is common to both strings.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> text1 = "abcde", text2 = "ace" 
+<strong>Output:</strong> 3  
+<strong>Explanation:</strong> The longest common subsequence is "ace" and its length is 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> text1 = "abc", text2 = "abc"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The longest common subsequence is "abc" and its length is 3.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> text1 = "abc", text2 = "def"
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There is no such common subsequence, so the result is 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= text1.length, text2.length &lt;= 1000</code></li>
+	<li><code>text1</code> and <code>text2</code> consist of only lowercase English characters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1153-product-sales-analysis-i/README.md b/leetcode/leetcode/1153-product-sales-analysis-i/README.md
new file mode 100644
index 0000000..a079828
--- /dev/null
+++ b/leetcode/leetcode/1153-product-sales-analysis-i/README.md
@@ -0,0 +1,75 @@
+<h2><a href="https://leetcode.com/problems/product-sales-analysis-i">1153. Product Sales Analysis I</a></h2><h3>Easy</h3><hr><p>Table: <code>Sales</code></p>
+
+<pre>
++-------------+-------+
+| Column Name | Type  |
++-------------+-------+
+| sale_id     | int   |
+| product_id  | int   |
+| year        | int   |
+| quantity    | int   |
+| price       | int   |
++-------------+-------+
+(sale_id, year) is the primary key (combination of columns with unique values) of this table.
+product_id is a foreign key (reference column) to <code>Product</code> table.
+Each row of this table shows a sale on the product product_id in a certain year.
+Note that the price is per unit.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Table: <code>Product</code></p>
+
+<pre>
++--------------+---------+
+| Column Name  | Type    |
++--------------+---------+
+| product_id   | int     |
+| product_name | varchar |
++--------------+---------+
+product_id is the primary key (column with unique values) of this table.
+Each row of this table indicates the product name of each product.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write a solution to report the <code>product_name</code>, <code>year</code>, and <code>price</code> for each <code>sale_id</code> in the <code>Sales</code> table.</p>
+
+<p>Return the resulting table in <strong>any order</strong>.</p>
+
+<p>The result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> 
+Sales table:
++---------+------------+------+----------+-------+
+| sale_id | product_id | year | quantity | price |
++---------+------------+------+----------+-------+ 
+| 1       | 100        | 2008 | 10       | 5000  |
+| 2       | 100        | 2009 | 12       | 5000  |
+| 7       | 200        | 2011 | 15       | 9000  |
++---------+------------+------+----------+-------+
+Product table:
++------------+--------------+
+| product_id | product_name |
++------------+--------------+
+| 100        | Nokia        |
+| 200        | Apple        |
+| 300        | Samsung      |
++------------+--------------+
+<strong>Output:</strong> 
++--------------+-------+-------+
+| product_name | year  | price |
++--------------+-------+-------+
+| Nokia        | 2008  | 5000  |
+| Nokia        | 2009  | 5000  |
+| Apple        | 2011  | 9000  |
++--------------+-------+-------+
+<strong>Explanation:</strong> 
+From sale_id = 1, we can conclude that Nokia was sold for 5000 in the year 2008.
+From sale_id = 2, we can conclude that Nokia was sold for 5000 in the year 2009.
+From sale_id = 7, we can conclude that Apple was sold for 9000 in the year 2011.
+</pre>
diff --git a/leetcode/leetcode/116-populating-next-right-pointers-in-each-node/116-populating-next-right-pointers-in-each-node.java b/leetcode/leetcode/116-populating-next-right-pointers-in-each-node/116-populating-next-right-pointers-in-each-node.java
new file mode 100644
index 0000000..ca80bb6
--- /dev/null
+++ b/leetcode/leetcode/116-populating-next-right-pointers-in-each-node/116-populating-next-right-pointers-in-each-node.java
@@ -0,0 +1,42 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() {}
+    
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+};
+*/
+
+class Solution {
+    public Node connect(Node root) {
+        if(root == null) return root;
+        Queue<Node> q = new LinkedList<>();
+        q.offer(root);
+        while(q.size()!=0){
+            Node back = null;
+            for(int i = q.size();i!=-0;i--){
+                back = q.peek();
+                Node front = q.remove();
+                if(q.size()!=0) front.next = q.peek();
+                if(front.left!=null) q.offer(front.left);
+                if(front.right!=null) q.offer(front.right);
+            }
+            back.next = null;
+        }
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/116-populating-next-right-pointers-in-each-node/NOTES.md b/leetcode/leetcode/116-populating-next-right-pointers-in-each-node/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/116-populating-next-right-pointers-in-each-node/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/116-populating-next-right-pointers-in-each-node/README.md b/leetcode/leetcode/116-populating-next-right-pointers-in-each-node/README.md
new file mode 100644
index 0000000..99d6a63
--- /dev/null
+++ b/leetcode/leetcode/116-populating-next-right-pointers-in-each-node/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/populating-next-right-pointers-in-each-node/">116. Populating Next Right Pointers in Each Node</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>perfect binary tree</strong> where all leaves are on the same level, and every parent has two children. The binary tree has the following definition:</p>
+
+<pre>struct Node {
+  int val;
+  Node *left;
+  Node *right;
+  Node *next;
+}
+</pre>
+
+<p>Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to <code>NULL</code>.</p>
+
+<p>Initially, all next pointers are set to <code>NULL</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/02/14/116_sample.png" style="width: 500px; height: 171px;">
+<pre><strong>Input:</strong> root = [1,2,3,4,5,6,7]
+<strong>Output:</strong> [1,#,2,3,#,4,5,6,7,#]
+<strong>Explanation: </strong>Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 2<sup>12</sup> - 1]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong></p>
+
+<ul>
+	<li>You may only use constant extra space.</li>
+	<li>The recursive approach is fine. You may assume implicit stack space does not count as extra space for this problem.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/1160-find-words-that-can-be-formed-by-characters.java b/leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/1160-find-words-that-can-be-formed-by-characters.java
new file mode 100644
index 0000000..c29c4db
--- /dev/null
+++ b/leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/1160-find-words-that-can-be-formed-by-characters.java
@@ -0,0 +1,26 @@
+class Solution {
+    public int checkWord(int[] arr, String s){
+        int[] tempArray = new int[26];
+        for(int i = 0;i<s.length();i++){
+            int index = (int) (s.charAt(i)-'a');
+            tempArray[index]++;
+            if(tempArray[index]>arr[index]) return -1;
+        }
+        return s.length();
+        
+    }
+    public int countCharacters(String[] words, String chars) {
+        int[] arr = new int[26];
+        int ans = 0;
+        for(int i = 0;i<chars.length();i++){
+            arr[(int) (chars.charAt(i)-'a')]++;
+        }
+        for(int i = 0;i<words.length;i++){
+            int val = checkWord(arr,words[i]);
+            if(val>0){
+                ans+=val;
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/NOTES.md b/leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/README.md b/leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/README.md
new file mode 100644
index 0000000..62067b2
--- /dev/null
+++ b/leetcode/leetcode/1160-find-words-that-can-be-formed-by-characters/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/find-words-that-can-be-formed-by-characters/">1160. Find Words That Can Be Formed by Characters</a></h2><h3>Easy</h3><hr><div><p>You are given an array of strings <code>words</code> and a string <code>chars</code>.</p>
+
+<p>A string is <strong>good</strong> if it can be formed by characters from chars (each character can only be used once).</p>
+
+<p>Return <em>the sum of lengths of all good strings in words</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> words = ["cat","bt","hat","tree"], chars = "atach"
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The strings that can be formed are "cat" and "hat" so the answer is 3 + 3 = 6.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words = ["hello","world","leetcode"], chars = "welldonehoneyr"
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> The strings that can be formed are "hello" and "world" so the answer is 5 + 5 = 10.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= words.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= words[i].length, chars.length &lt;= 100</code></li>
+	<li><code>words[i]</code> and <code>chars</code> consist of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/1161-maximum-level-sum-of-a-binary-tree.java b/leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/1161-maximum-level-sum-of-a-binary-tree.java
new file mode 100644
index 0000000..6c084ec
--- /dev/null
+++ b/leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/1161-maximum-level-sum-of-a-binary-tree.java
@@ -0,0 +1,43 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int maxLevelSum(TreeNode root) {
+        if(root == null) return 0;
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+        int maxSum = root.val;
+        int maxLevel = 1;
+        int tempLevel = 0;
+        while(!q.isEmpty()){
+            int tempSum = 0;
+            for(int i = q.size();i>0;i--){
+                TreeNode front = q.remove();
+                tempSum+=front.val;
+                if(front.left!=null){
+                    q.add(front.left);
+                }if(front.right!=null){
+                    q.add(front.right);
+                }
+            }
+            tempLevel++;
+            if(tempSum>maxSum){
+                maxSum = tempSum;
+                maxLevel = tempLevel;
+            }
+        }
+        return maxLevel;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/NOTES.md b/leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/README.md b/leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/README.md
new file mode 100644
index 0000000..02a80b8
--- /dev/null
+++ b/leetcode/leetcode/1161-maximum-level-sum-of-a-binary-tree/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/maximum-level-sum-of-a-binary-tree/">1161. Maximum Level Sum of a Binary Tree</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, the level of its root is <code>1</code>, the level of its children is <code>2</code>, and so on.</p>
+
+<p>Return the <strong>smallest</strong> level <code>x</code> such that the sum of all the values of nodes at level <code>x</code> is <strong>maximal</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/05/03/capture.JPG" style="width: 200px; height: 175px;">
+<pre><strong>Input:</strong> root = [1,7,0,7,-8,null,null]
+<strong>Output:</strong> 2
+<strong>Explanation: </strong>
+Level 1 sum = 1.
+Level 2 sum = 7 + 0 = 7.
+Level 3 sum = 7 + -8 = -1.
+So we return the level with the maximum sum which is level 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [989,null,10250,98693,-89388,null,null,null,-32127]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/117-populating-next-right-pointers-in-each-node-ii.java b/leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/117-populating-next-right-pointers-in-each-node-ii.java
new file mode 100644
index 0000000..ca80bb6
--- /dev/null
+++ b/leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/117-populating-next-right-pointers-in-each-node-ii.java
@@ -0,0 +1,42 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() {}
+    
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+};
+*/
+
+class Solution {
+    public Node connect(Node root) {
+        if(root == null) return root;
+        Queue<Node> q = new LinkedList<>();
+        q.offer(root);
+        while(q.size()!=0){
+            Node back = null;
+            for(int i = q.size();i!=-0;i--){
+                back = q.peek();
+                Node front = q.remove();
+                if(q.size()!=0) front.next = q.peek();
+                if(front.left!=null) q.offer(front.left);
+                if(front.right!=null) q.offer(front.right);
+            }
+            back.next = null;
+        }
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/NOTES.md b/leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/README.md b/leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/README.md
new file mode 100644
index 0000000..66e0993
--- /dev/null
+++ b/leetcode/leetcode/117-populating-next-right-pointers-in-each-node-ii/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/">117. Populating Next Right Pointers in Each Node II</a></h2><h3>Medium</h3><hr><div><p>Given a binary tree</p>
+
+<pre>struct Node {
+  int val;
+  Node *left;
+  Node *right;
+  Node *next;
+}
+</pre>
+
+<p>Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to <code>NULL</code>.</p>
+
+<p>Initially, all next pointers are set to <code>NULL</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/02/15/117_sample.png" style="width: 500px; height: 171px;">
+<pre><strong>Input:</strong> root = [1,2,3,4,5,null,7]
+<strong>Output:</strong> [1,#,2,3,#,4,5,7,#]
+<strong>Explanation: </strong>Given the above binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 6000]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong></p>
+
+<ul>
+	<li>You may only use constant extra space.</li>
+	<li>The recursive approach is fine. You may assume implicit stack space does not count as extra space for this problem.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1170-shortest-common-supersequence/1170-shortest-common-supersequence.java b/leetcode/leetcode/1170-shortest-common-supersequence/1170-shortest-common-supersequence.java
new file mode 100644
index 0000000..fbc4fb0
--- /dev/null
+++ b/leetcode/leetcode/1170-shortest-common-supersequence/1170-shortest-common-supersequence.java
@@ -0,0 +1,42 @@
+class Solution {
+
+    public String shortestCommonSupersequence(String str1, String str2) {
+        int str1Length = str1.length();
+        int str2Length = str2.length();
+
+        // Initialize the first row (when str1 is empty, the supersequence is str2's prefix)
+        String[] prevRow = new String[str2Length + 1];
+        for (int col = 0; col <= str2Length; col++) {
+            prevRow[col] = str2.substring(0, col);
+        }
+
+        // Fill the DP table row by row
+        for (int row = 1; row <= str1Length; row++) {
+            // Initialize the first column (when str2 is empty, the supersequence is str1's prefix)
+            String[] currRow = new String[str2Length + 1];
+            currRow[0] = str1.substring(0, row);
+
+            for (int col = 1; col <= str2Length; col++) {
+                // If characters match, extend the supersequence from the diagonal value
+                if (str1.charAt(row - 1) == str2.charAt(col - 1)) {
+                    currRow[col] = prevRow[col - 1] + str1.charAt(row - 1);
+                } else {
+                    // If characters do not match, choose the shorter supersequence
+                    // From previous row (exclude current str1 char)
+                    String pickS1 = prevRow[col];
+                    // From previous column (exclude current str2 char)
+                    String pickS2 = currRow[col - 1];
+
+                    currRow[col] = (pickS1.length() < pickS2.length())
+                        ? pickS1 + str1.charAt(row - 1)
+                        : pickS2 + str2.charAt(col - 1);
+                }
+            }
+            // Move to the next row (update previous row reference)
+            prevRow = currRow;
+        }
+
+        // Return the shortest common supersequence from the last cell
+        return prevRow[str2Length];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1170-shortest-common-supersequence/README.md b/leetcode/leetcode/1170-shortest-common-supersequence/README.md
new file mode 100644
index 0000000..7a916ce
--- /dev/null
+++ b/leetcode/leetcode/1170-shortest-common-supersequence/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/shortest-common-supersequence">1170. Shortest Common Supersequence </a></h2><h3>Hard</h3><hr><p>Given two strings <code>str1</code> and <code>str2</code>, return <em>the shortest string that has both </em><code>str1</code><em> and </em><code>str2</code><em> as <strong>subsequences</strong></em>. If there are multiple valid strings, return <strong>any</strong> of them.</p>
+
+<p>A string <code>s</code> is a <strong>subsequence</strong> of string <code>t</code> if deleting some number of characters from <code>t</code> (possibly <code>0</code>) results in the string <code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> str1 = &quot;abac&quot;, str2 = &quot;cab&quot;
+<strong>Output:</strong> &quot;cabac&quot;
+<strong>Explanation:</strong> 
+str1 = &quot;abac&quot; is a subsequence of &quot;cabac&quot; because we can delete the first &quot;c&quot;.
+str2 = &quot;cab&quot; is a subsequence of &quot;cabac&quot; because we can delete the last &quot;ac&quot;.
+The answer provided is the shortest such string that satisfies these properties.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> str1 = &quot;aaaaaaaa&quot;, str2 = &quot;aaaaaaaa&quot;
+<strong>Output:</strong> &quot;aaaaaaaa&quot;
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= str1.length, str2.length &lt;= 1000</code></li>
+	<li><code>str1</code> and <code>str2</code> consist of lowercase English letters.</li>
+</ul>
diff --git a/leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/1171-remove-zero-sum-consecutive-nodes-from-linked-list.java b/leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/1171-remove-zero-sum-consecutive-nodes-from-linked-list.java
new file mode 100644
index 0000000..943e304
--- /dev/null
+++ b/leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/1171-remove-zero-sum-consecutive-nodes-from-linked-list.java
@@ -0,0 +1,36 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode removeZeroSumSublists(ListNode head) {
+        ListNode dummy = new ListNode(0), cur = dummy;
+        dummy.next = head;
+        int prefix = 0;
+        Map<Integer, ListNode> m = new HashMap<>();
+        while (cur != null) {
+            prefix += cur.val;
+            if (m.containsKey(prefix)) {
+                cur =  m.get(prefix).next;
+                int p = prefix + cur.val;
+                while (p != prefix) {
+                    m.remove(p);
+                    cur = cur.next;
+                    p += cur.val;
+                }
+                m.get(prefix).next = cur.next;
+            } else {
+                m.put(prefix, cur);
+            }
+            cur = cur.next;
+        }
+        return dummy.next;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/NOTES.md b/leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/README.md b/leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/README.md
new file mode 100644
index 0000000..f23d340
--- /dev/null
+++ b/leetcode/leetcode/1171-remove-zero-sum-consecutive-nodes-from-linked-list/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/remove-zero-sum-consecutive-nodes-from-linked-list/">1171. Remove Zero Sum Consecutive Nodes from Linked List</a></h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a linked list, we repeatedly delete consecutive sequences of nodes that sum to <code>0</code> until there are no such sequences.</p>
+
+<p>After doing so, return the head of the final linked list.&nbsp; You may return any such answer.</p>
+
+<p>&nbsp;</p>
+<p>(Note that in the examples below, all sequences are serializations of <code>ListNode</code> objects.)</p>
+
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,2,-3,3,1]
+<strong>Output:</strong> [3,1]
+<strong>Note:</strong> The answer [1,2,1] would also be accepted.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,2,3,-3,4]
+<strong>Output:</strong> [1,2,4]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,2,3,-3,-2]
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The given linked list will contain between <code>1</code> and <code>1000</code> nodes.</li>
+	<li>Each node in the linked list has <code>-1000 &lt;= node.val &lt;= 1000</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/118-pascals-triangle/118-pascals-triangle.java b/leetcode/leetcode/118-pascals-triangle/118-pascals-triangle.java
new file mode 100644
index 0000000..3abb1cd
--- /dev/null
+++ b/leetcode/leetcode/118-pascals-triangle/118-pascals-triangle.java
@@ -0,0 +1,23 @@
+class Solution {
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> list = new ArrayList<>();
+        int start = 1;
+        List<Integer> first = new ArrayList(start);
+        first.add(1);
+        list.add(first);
+        if(numRows==start) return list;
+        while(numRows!=1){
+            start = start+1;
+            List<Integer> newList = new ArrayList<Integer>(start);
+            newList.add(1);
+            for(int i=1;i<start - 1;i++){
+                newList.add(list.get(start-2).get(i-1)+list.get(start-2).get(i));
+            }
+            newList.add(1);
+            list.add(newList);
+            numRows--;
+        }
+        return list;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/118-pascals-triangle/NOTES.md b/leetcode/leetcode/118-pascals-triangle/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/118-pascals-triangle/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/118-pascals-triangle/README.md b/leetcode/leetcode/118-pascals-triangle/README.md
new file mode 100644
index 0000000..9750c83
--- /dev/null
+++ b/leetcode/leetcode/118-pascals-triangle/README.md
@@ -0,0 +1,19 @@
+<h2><a href="https://leetcode.com/problems/pascals-triangle/">118. Pascal's Triangle</a></h2><h3>Easy</h3><hr><div><p>Given an integer <code>numRows</code>, return the first numRows of <strong>Pascal's triangle</strong>.</p>
+
+<p>In <strong>Pascal's triangle</strong>, each number is the sum of the two numbers directly above it as shown:</p>
+<img alt="" src="https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif" style="height:240px; width:260px">
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> numRows = 5
+<strong>Output:</strong> [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> numRows = 1
+<strong>Output:</strong> [[1]]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= numRows &lt;= 30</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1190-reverse-substrings-between-each-pair-of-parentheses/1190-reverse-substrings-between-each-pair-of-parentheses.java b/leetcode/leetcode/1190-reverse-substrings-between-each-pair-of-parentheses/1190-reverse-substrings-between-each-pair-of-parentheses.java
new file mode 100644
index 0000000..51baf37
--- /dev/null
+++ b/leetcode/leetcode/1190-reverse-substrings-between-each-pair-of-parentheses/1190-reverse-substrings-between-each-pair-of-parentheses.java
@@ -0,0 +1,24 @@
+class Solution {
+    private void reverse(StringBuilder sb, int start, int end) {
+        while (start < end) {
+            char temp = sb.charAt(start);
+            sb.setCharAt(start++, sb.charAt(end));
+            sb.setCharAt(end--, temp);
+        }
+    }
+    public String reverseParentheses(String s) {
+        Stack<Integer> openParenthesesIndices = new Stack<>();
+        StringBuilder result = new StringBuilder();
+        for (char currentChar : s.toCharArray()) {
+            if (currentChar == '(') {
+                openParenthesesIndices.push(result.length());
+            } else if (currentChar == ')') {
+                int start = openParenthesesIndices.pop();
+                reverse(result, start, result.length() - 1);
+            } else {
+                result.append(currentChar);
+            }
+        }
+        return result.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1207-unique-number-of-occurrences/1207-unique-number-of-occurrences.java b/leetcode/leetcode/1207-unique-number-of-occurrences/1207-unique-number-of-occurrences.java
new file mode 100644
index 0000000..acf5b19
--- /dev/null
+++ b/leetcode/leetcode/1207-unique-number-of-occurrences/1207-unique-number-of-occurrences.java
@@ -0,0 +1,15 @@
+class Solution {
+    public boolean uniqueOccurrences(int[] arr) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: arr){
+            map.put(num, map.getOrDefault(num,0)+1);
+        }
+        boolean[] testArray = new boolean[1001];
+        for (Map.Entry<Integer,Integer> mapElement : map.entrySet()) {
+            int value = mapElement.getValue();
+            if(testArray[value]==true) return false;
+            testArray[value] = true;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1207-unique-number-of-occurrences/NOTES.md b/leetcode/leetcode/1207-unique-number-of-occurrences/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1207-unique-number-of-occurrences/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1207-unique-number-of-occurrences/README.md b/leetcode/leetcode/1207-unique-number-of-occurrences/README.md
new file mode 100644
index 0000000..2970e61
--- /dev/null
+++ b/leetcode/leetcode/1207-unique-number-of-occurrences/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/unique-number-of-occurrences/">1207. Unique Number of Occurrences</a></h2><h3>Easy</h3><hr><div><p>Given an array of integers <code>arr</code>, return <code>true</code> <em>if the number of occurrences of each value in the array is <strong>unique</strong> or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,2,1,1,3]
+<strong>Output:</strong> true
+<strong>Explanation:</strong>&nbsp;The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [-3,0,1,-3,1,1,1,-3,10,0]
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 1000</code></li>
+	<li><code>-1000 &lt;= arr[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/121-best-time-to-buy-and-sell-stock/121-best-time-to-buy-and-sell-stock.java b/leetcode/leetcode/121-best-time-to-buy-and-sell-stock/121-best-time-to-buy-and-sell-stock.java
new file mode 100644
index 0000000..26cce07
--- /dev/null
+++ b/leetcode/leetcode/121-best-time-to-buy-and-sell-stock/121-best-time-to-buy-and-sell-stock.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        int minTillNow = Integer.MAX_VALUE;
+        int max = 0;
+        for(int i = 0;i<prices.length;i++){
+            int val = prices[i] - minTillNow;
+            if(val>max) max = val;
+            minTillNow = Math.min(minTillNow,prices[i]);
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/121-best-time-to-buy-and-sell-stock/NOTES.md b/leetcode/leetcode/121-best-time-to-buy-and-sell-stock/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/121-best-time-to-buy-and-sell-stock/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/121-best-time-to-buy-and-sell-stock/README.md b/leetcode/leetcode/121-best-time-to-buy-and-sell-stock/README.md
new file mode 100644
index 0000000..9350a49
--- /dev/null
+++ b/leetcode/leetcode/121-best-time-to-buy-and-sell-stock/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/best-time-to-buy-and-sell-stock/">121. Best Time to Buy and Sell Stock</a></h2><h3>Easy</h3><hr><div><p>You are given an array <code>prices</code> where <code>prices[i]</code> is the price of a given stock on the <code>i<sup>th</sup></code> day.</p>
+
+<p>You want to maximize your profit by choosing a <strong>single day</strong> to buy one stock and choosing a <strong>different day in the future</strong> to sell that stock.</p>
+
+<p>Return <em>the maximum profit you can achieve from this transaction</em>. If you cannot achieve any profit, return <code>0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> prices = [7,1,5,3,6,4]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
+Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> prices = [7,6,4,3,1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> In this case, no transactions are done and the max profit = 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= prices.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= prices[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1224-minimum-falling-path-sum-ii/1224-minimum-falling-path-sum-ii.java b/leetcode/leetcode/1224-minimum-falling-path-sum-ii/1224-minimum-falling-path-sum-ii.java
new file mode 100644
index 0000000..4e3cc82
--- /dev/null
+++ b/leetcode/leetcode/1224-minimum-falling-path-sum-ii/1224-minimum-falling-path-sum-ii.java
@@ -0,0 +1,27 @@
+class Solution {
+    public int minFallingPathSum(int[][] matrix) {
+        int ans = Integer.MAX_VALUE;
+        for (int i = 1; i < matrix.length; i++) {
+            for(int j = 0;j<matrix.length;j++){
+                int min = Integer.MAX_VALUE;
+                for(int k =0;k<matrix.length;k++){
+                    if(j == k) continue;
+                    min = Math.min(min,matrix[i-1][k]);
+                }
+                // if(j == 0){
+                //     matrix[i][j] = matrix[i][j] + matrix[i-1][j+1];
+                // }else if(j == matrix.length -1){
+                //     matrix[i][j] = matrix[i][j] + matrix[i-1][j-1];
+                // }else{
+                //     matrix[i][j] = matrix[i][j] + Math.min(matrix[i-1][j-1],matrix[i-1][j+1]);
+                // }
+                matrix[i][j] = matrix[i][j] + min;
+            }
+        }
+
+        for(int i = 0;i<matrix.length;i++){
+            ans = Math.min(ans,matrix[matrix.length-1][i]);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1224-minimum-falling-path-sum-ii/README.md b/leetcode/leetcode/1224-minimum-falling-path-sum-ii/README.md
new file mode 100644
index 0000000..52a7625
--- /dev/null
+++ b/leetcode/leetcode/1224-minimum-falling-path-sum-ii/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/minimum-falling-path-sum-ii">1224. Minimum Falling Path Sum II</a></h2><h3>Hard</h3><hr><p>Given an <code>n x n</code> integer matrix <code>grid</code>, return <em>the minimum sum of a <strong>falling path with non-zero shifts</strong></em>.</p>
+
+<p>A <strong>falling path with non-zero shifts</strong> is a choice of exactly one element from each row of <code>grid</code> such that no two elements chosen in adjacent rows are in the same column.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/falling-grid.jpg" style="width: 244px; height: 245px;" />
+<pre>
+<strong>Input:</strong> grid = [[1,2,3],[4,5,6],[7,8,9]]
+<strong>Output:</strong> 13
+<strong>Explanation:</strong> 
+The possible falling paths are:
+[1,5,9], [1,5,7], [1,6,7], [1,6,8],
+[2,4,8], [2,4,9], [2,6,7], [2,6,8],
+[3,4,8], [3,4,9], [3,5,7], [3,5,9]
+The falling path with the smallest sum is&nbsp;[1,5,7], so the answer is&nbsp;13.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[7]]
+<strong>Output:</strong> 7
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == grid.length == grid[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 200</code></li>
+	<li><code>-99 &lt;= grid[i][j] &lt;= 99</code></li>
+</ul>
diff --git a/leetcode/leetcode/1249-minimum-remove-to-make-valid-parentheses/1249-minimum-remove-to-make-valid-parentheses.java b/leetcode/leetcode/1249-minimum-remove-to-make-valid-parentheses/1249-minimum-remove-to-make-valid-parentheses.java
new file mode 100644
index 0000000..f271f20
--- /dev/null
+++ b/leetcode/leetcode/1249-minimum-remove-to-make-valid-parentheses/1249-minimum-remove-to-make-valid-parentheses.java
@@ -0,0 +1,24 @@
+class Solution {
+    public String minRemoveToMakeValid(String string) {
+        Stack<Integer> s = new Stack<>();
+        // s.add(-1);
+        for(int i = 0;i<string.length();i++){
+            if(string.charAt(i) != ')' && string.charAt(i) !='(') continue;
+            if(string.charAt(i) == ')' && s.size()!=0 && string.charAt(s.peek()) == '('){
+                s.pop();
+            }else{
+                s.push(i);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for(int i = string.length()-1;i!=-1;i--){
+            if(!s.isEmpty() && s.peek() == i){
+                s.pop();
+                continue;
+            }else{
+                sb.append(string.charAt(i));
+            } 
+        }
+        return sb.reverse().toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1249-minimum-remove-to-make-valid-parentheses/README.md b/leetcode/leetcode/1249-minimum-remove-to-make-valid-parentheses/README.md
new file mode 100644
index 0000000..fcbd31b
--- /dev/null
+++ b/leetcode/leetcode/1249-minimum-remove-to-make-valid-parentheses/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/">1249. Minimum Remove to Make Valid Parentheses</a></h2><h3>Medium</h3><hr><div><p>Given a string <font face="monospace">s</font> of <code>'('</code> , <code>')'</code> and lowercase English characters.</p>
+
+<p>Your task is to remove the minimum number of parentheses ( <code>'('</code> or <code>')'</code>, in any positions ) so that the resulting <em>parentheses string</em> is valid and return <strong>any</strong> valid string.</p>
+
+<p>Formally, a <em>parentheses string</em> is valid if and only if:</p>
+
+<ul>
+	<li>It is the empty string, contains only lowercase characters, or</li>
+	<li>It can be written as <code>AB</code> (<code>A</code> concatenated with <code>B</code>), where <code>A</code> and <code>B</code> are valid strings, or</li>
+	<li>It can be written as <code>(A)</code>, where <code>A</code> is a valid string.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "lee(t(c)o)de)"
+<strong>Output:</strong> "lee(t(c)o)de"
+<strong>Explanation:</strong> "lee(t(co)de)" , "lee(t(c)ode)" would also be accepted.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "a)b(c)d"
+<strong>Output:</strong> "ab(c)d"
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "))(("
+<strong>Output:</strong> ""
+<strong>Explanation:</strong> An empty string is also valid.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s[i]</code> is either&nbsp;<code>'('</code> , <code>')'</code>, or lowercase English letter.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1250-longest-common-subsequence/1250-longest-common-subsequence.java b/leetcode/leetcode/1250-longest-common-subsequence/1250-longest-common-subsequence.java
new file mode 100644
index 0000000..2354b44
--- /dev/null
+++ b/leetcode/leetcode/1250-longest-common-subsequence/1250-longest-common-subsequence.java
@@ -0,0 +1,25 @@
+class Solution {
+    public int LCS(int[][] memo, String s1, String s2, int m, int n){
+        if(m<0 || n<0) return 0;
+        if(memo[m][n] != -1) return memo[m][n];
+        if(s1.charAt(m) == s2.charAt(n)){
+            memo[m][n] = 1 + LCS(memo, s1, s2, m-1,n-1);
+        }else{
+            memo[m][n] = Math.max(LCS(memo,s1,s2,m-1,n),LCS(memo,s1,s2,m,n-1));
+        }
+        return memo[m][n];
+    }
+    
+    public int longestCommonSubsequence(String str1, String str2) {
+        int m = str1.length();
+        int n = str2.length();
+        int[][] memo = new int[m][n];
+
+        for(int i = 0;i<m;i++){
+            for(int j = 0;j<n;j++){
+                memo[i][j] = -1;
+            }
+        }
+        return LCS(memo,str1,str2,m-1,n-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1250-longest-common-subsequence/README.md b/leetcode/leetcode/1250-longest-common-subsequence/README.md
new file mode 100644
index 0000000..fac5f44
--- /dev/null
+++ b/leetcode/leetcode/1250-longest-common-subsequence/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/longest-common-subsequence">1250. Longest Common Subsequence</a></h2><h3>Medium</h3><hr><p>Given two strings <code>text1</code> and <code>text2</code>, return <em>the length of their longest <strong>common subsequence</strong>. </em>If there is no <strong>common subsequence</strong>, return <code>0</code>.</p>
+
+<p>A <strong>subsequence</strong> of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.</p>
+
+<ul>
+	<li>For example, <code>&quot;ace&quot;</code> is a subsequence of <code>&quot;abcde&quot;</code>.</li>
+</ul>
+
+<p>A <strong>common subsequence</strong> of two strings is a subsequence that is common to both strings.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> text1 = &quot;abcde&quot;, text2 = &quot;ace&quot; 
+<strong>Output:</strong> 3  
+<strong>Explanation:</strong> The longest common subsequence is &quot;ace&quot; and its length is 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> text1 = &quot;abc&quot;, text2 = &quot;abc&quot;
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The longest common subsequence is &quot;abc&quot; and its length is 3.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> text1 = &quot;abc&quot;, text2 = &quot;def&quot;
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There is no such common subsequence, so the result is 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= text1.length, text2.length &lt;= 1000</code></li>
+	<li><code>text1</code> and <code>text2</code> consist of only lowercase English characters.</li>
+</ul>
diff --git a/leetcode/leetcode/1258-article-views-i/1258-article-views-i.sql b/leetcode/leetcode/1258-article-views-i/1258-article-views-i.sql
new file mode 100644
index 0000000..d94a74d
--- /dev/null
+++ b/leetcode/leetcode/1258-article-views-i/1258-article-views-i.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+Select DISTINCT author_id as id from Views where author_id = viewer_id ORDER by author_id ;
\ No newline at end of file
diff --git a/leetcode/leetcode/1258-article-views-i/README.md b/leetcode/leetcode/1258-article-views-i/README.md
new file mode 100644
index 0000000..efe35a7
--- /dev/null
+++ b/leetcode/leetcode/1258-article-views-i/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/article-views-i">1258. Article Views I</a></h2><h3>Easy</h3><hr><p>Table: <code>Views</code></p>
+
+<pre>
++---------------+---------+
+| Column Name   | Type    |
++---------------+---------+
+| article_id    | int     |
+| author_id     | int     |
+| viewer_id     | int     |
+| view_date     | date    |
++---------------+---------+
+There is no primary key (column with unique values) for this table, the table may have duplicate rows.
+Each row of this table indicates that some viewer viewed an article (written by some author) on some date. 
+Note that equal author_id and viewer_id indicate the same person.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write a solution to find all the authors that viewed at least one of their own articles.</p>
+
+<p>Return the result table sorted by <code>id</code> in ascending order.</p>
+
+<p>The result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> 
+Views table:
++------------+-----------+-----------+------------+
+| article_id | author_id | viewer_id | view_date  |
++------------+-----------+-----------+------------+
+| 1          | 3         | 5         | 2019-08-01 |
+| 1          | 3         | 6         | 2019-08-02 |
+| 2          | 7         | 7         | 2019-08-01 |
+| 2          | 7         | 6         | 2019-08-02 |
+| 4          | 7         | 1         | 2019-07-22 |
+| 3          | 4         | 4         | 2019-07-21 |
+| 3          | 4         | 4         | 2019-07-21 |
++------------+-----------+-----------+------------+
+<strong>Output:</strong> 
++------+
+| id   |
++------+
+| 4    |
+| 7    |
++------+
+</pre>
diff --git a/leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/1261-find-elements-in-a-contaminated-binary-tree.java b/leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/1261-find-elements-in-a-contaminated-binary-tree.java
new file mode 100644
index 0000000..ff86fdf
--- /dev/null
+++ b/leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/1261-find-elements-in-a-contaminated-binary-tree.java
@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class FindElements {
+    
+    HashSet<Integer> set = new HashSet<>();
+
+    public FindElements(TreeNode root) {
+        set.add(0);
+        recovers(root,0);
+    }
+    public void recovers(TreeNode root,int val){
+        if(root == null) return;
+        set.add(val);
+        recovers(root.left,2*val+1);
+        recovers(root.right,2*val+2);
+    }
+    public boolean find(int target) {
+        return set.contains(target);
+    }
+}
+
+/**
+ * Your FindElements object will be instantiated and called as such:
+ * FindElements obj = new FindElements(root);
+ * boolean param_1 = obj.find(target);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/NOTES.md b/leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/README.md b/leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/README.md
new file mode 100644
index 0000000..3df7853
--- /dev/null
+++ b/leetcode/leetcode/1261-find-elements-in-a-contaminated-binary-tree/README.md
@@ -0,0 +1,69 @@
+<h2><a href="https://leetcode.com/problems/find-elements-in-a-contaminated-binary-tree/">1261. Find Elements in a Contaminated Binary Tree</a></h2><h3>Medium</h3><hr><div><p>Given a binary tree with the following rules:</p>
+
+<ol>
+	<li><code>root.val == 0</code></li>
+	<li>If <code>treeNode.val == x</code> and <code>treeNode.left != null</code>, then <code>treeNode.left.val == 2 * x + 1</code></li>
+	<li>If <code>treeNode.val == x</code> and <code>treeNode.right != null</code>, then <code>treeNode.right.val == 2 * x + 2</code></li>
+</ol>
+
+<p>Now the binary tree is contaminated, which means all <code>treeNode.val</code> have been changed to <code>-1</code>.</p>
+
+<p>Implement the <code>FindElements</code> class:</p>
+
+<ul>
+	<li><code>FindElements(TreeNode* root)</code> Initializes the object with a contaminated binary tree and recovers it.</li>
+	<li><code>bool find(int target)</code> Returns <code>true</code> if the <code>target</code> value exists in the recovered binary tree.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/06/untitled-diagram-4-1.jpg" style="width: 320px; height: 119px;">
+<pre><strong>Input</strong>
+["FindElements","find","find"]
+[[[-1,null,-1]],[1],[2]]
+<strong>Output</strong>
+[null,false,true]
+<strong>Explanation</strong>
+FindElements findElements = new FindElements([-1,null,-1]); 
+findElements.find(1); // return False 
+findElements.find(2); // return True </pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/06/untitled-diagram-4.jpg" style="width: 400px; height: 198px;">
+<pre><strong>Input</strong>
+["FindElements","find","find","find"]
+[[[-1,-1,-1,-1,-1]],[1],[3],[5]]
+<strong>Output</strong>
+[null,true,true,false]
+<strong>Explanation</strong>
+FindElements findElements = new FindElements([-1,-1,-1,-1,-1]);
+findElements.find(1); // return True
+findElements.find(3); // return True
+findElements.find(5); // return False</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/07/untitled-diagram-4-1-1.jpg" style="width: 306px; height: 274px;">
+<pre><strong>Input</strong>
+["FindElements","find","find","find","find"]
+[[[-1,null,-1,-1,null,-1]],[2],[3],[4],[5]]
+<strong>Output</strong>
+[null,true,false,false,true]
+<strong>Explanation</strong>
+FindElements findElements = new FindElements([-1,null,-1,-1,null,-1]);
+findElements.find(2); // return True
+findElements.find(3); // return False
+findElements.find(4); // return False
+findElements.find(5); // return True
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>TreeNode.val == -1</code></li>
+	<li>The height of the binary tree is less than or equal to <code>20</code></li>
+	<li>The total number of nodes is between <code>[1, 10<sup>4</sup>]</code></li>
+	<li>Total calls of <code>find()</code> is between <code>[1, 10<sup>4</sup>]</code></li>
+	<li><code>0 &lt;= target &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1266-minimum-time-visiting-all-points/1266-minimum-time-visiting-all-points.java b/leetcode/leetcode/1266-minimum-time-visiting-all-points/1266-minimum-time-visiting-all-points.java
new file mode 100644
index 0000000..3fc7441
--- /dev/null
+++ b/leetcode/leetcode/1266-minimum-time-visiting-all-points/1266-minimum-time-visiting-all-points.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int minTimeToVisitAllPoints(int[][] points) {
+        int ans = 0;
+        for (int i = 0; i < points.length - 1; i++) {
+            int currX = points[i][0];
+            int currY = points[i][1];
+            int targetX = points[i + 1][0];
+            int targetY = points[i + 1][1];
+            ans += Math.max(Math.abs(targetX - currX), Math.abs(targetY - currY));
+        }
+        
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1266-minimum-time-visiting-all-points/README.md b/leetcode/leetcode/1266-minimum-time-visiting-all-points/README.md
new file mode 100644
index 0000000..dea5824
--- /dev/null
+++ b/leetcode/leetcode/1266-minimum-time-visiting-all-points/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/minimum-time-visiting-all-points/">1266. Minimum Time Visiting All Points</a></h2><h3>Easy</h3><hr><div><p>On a 2D plane, there are <code>n</code> points with integer coordinates <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>. Return <em>the <strong>minimum time</strong> in seconds to visit all the points in the order given by </em><code>points</code>.</p>
+
+<p>You can move according to these rules:</p>
+
+<ul>
+	<li>In <code>1</code> second, you can either:
+
+	<ul>
+		<li>move vertically by one&nbsp;unit,</li>
+		<li>move horizontally by one unit, or</li>
+		<li>move diagonally <code>sqrt(2)</code> units (in other words, move one unit vertically then one unit horizontally in <code>1</code> second).</li>
+	</ul>
+	</li>
+	<li>You have to visit the points in the same order as they appear in the array.</li>
+	<li>You are allowed to pass through points that appear later in the order, but these do not count as visits.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/14/1626_example_1.PNG" style="width: 500px; height: 428px;">
+<pre><strong>Input:</strong> points = [[1,1],[3,4],[-1,0]]
+<strong>Output:</strong> 7
+<strong>Explanation: </strong>One optimal path is <strong>[1,1]</strong> -&gt; [2,2] -&gt; [3,3] -&gt; <strong>[3,4] </strong>-&gt; [2,3] -&gt; [1,2] -&gt; [0,1] -&gt; <strong>[-1,0]</strong>   
+Time from [1,1] to [3,4] = 3 seconds 
+Time from [3,4] to [-1,0] = 4 seconds
+Total time = 7 seconds</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> points = [[3,2],[-2,2]]
+<strong>Output:</strong> 5
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>points.length == n</code></li>
+	<li><code>1 &lt;= n&nbsp;&lt;= 100</code></li>
+	<li><code>points[i].length == 2</code></li>
+	<li><code>-1000&nbsp;&lt;= points[i][0], points[i][1]&nbsp;&lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/128-longest-consecutive-sequence/128-longest-consecutive-sequence.java b/leetcode/leetcode/128-longest-consecutive-sequence/128-longest-consecutive-sequence.java
new file mode 100644
index 0000000..de1bb2c
--- /dev/null
+++ b/leetcode/leetcode/128-longest-consecutive-sequence/128-longest-consecutive-sequence.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        HashSet<Integer> set = new HashSet<>();
+        for(int num: nums){
+            set.add(num);
+        }
+        int streak = 0;
+        for(int num: set){
+            if(!set.contains(num-1)){
+                int currentNum = num;
+                int currentStreak = 1;
+                while(set.contains(currentNum+1)){
+                    currentNum++;
+                    currentStreak++;
+                }
+                streak = Math.max(streak,currentStreak);
+            }
+        }
+        return streak;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/128-longest-consecutive-sequence/NOTES.md b/leetcode/leetcode/128-longest-consecutive-sequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/128-longest-consecutive-sequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/1287-element-appearing-more-than-25-in-sorted-array.java b/leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/1287-element-appearing-more-than-25-in-sorted-array.java
new file mode 100644
index 0000000..ce84dd5
--- /dev/null
+++ b/leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/1287-element-appearing-more-than-25-in-sorted-array.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int findSpecialInteger(int[] arr) {
+        int target = (int) (0.25*arr.length);
+        for(int i = 0;i<arr.length;i++){
+            if(arr[i] == arr[i+target])
+                return arr[i];
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/NOTES.md b/leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/README.md b/leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/README.md
new file mode 100644
index 0000000..d7dfbbf
--- /dev/null
+++ b/leetcode/leetcode/1287-element-appearing-more-than-25-in-sorted-array/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/element-appearing-more-than-25-in-sorted-array/">1287. Element Appearing More Than 25% In Sorted Array</a></h2><h3>Easy</h3><hr><div><p>Given an integer array <strong>sorted</strong> in non-decreasing order, there is exactly one integer in the array that occurs more than 25% of the time, return that integer.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,2,6,6,6,6,7,10]
+<strong>Output:</strong> 6
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,1]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= arr[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/129-sum-root-to-leaf-numbers/129-sum-root-to-leaf-numbers.java b/leetcode/leetcode/129-sum-root-to-leaf-numbers/129-sum-root-to-leaf-numbers.java
new file mode 100644
index 0000000..003c4cb
--- /dev/null
+++ b/leetcode/leetcode/129-sum-root-to-leaf-numbers/129-sum-root-to-leaf-numbers.java
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int helper(TreeNode root, int currentNum){
+        if(root == null) return 0;
+        currentNum = currentNum*10+root.val;
+        if(root.left == null && root.right == null) return currentNum;
+        return helper(root.left,currentNum) + helper(root.right,currentNum);
+    }
+    public int sumNumbers(TreeNode root) {
+        return helper(root,0);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/129-sum-root-to-leaf-numbers/NOTES.md b/leetcode/leetcode/129-sum-root-to-leaf-numbers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/129-sum-root-to-leaf-numbers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/129-sum-root-to-leaf-numbers/README.md b/leetcode/leetcode/129-sum-root-to-leaf-numbers/README.md
new file mode 100644
index 0000000..e7578aa
--- /dev/null
+++ b/leetcode/leetcode/129-sum-root-to-leaf-numbers/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/sum-root-to-leaf-numbers/">129. Sum Root to Leaf Numbers</a></h2><h3>Medium</h3><hr><div><p>You are given the <code>root</code> of a binary tree containing digits from <code>0</code> to <code>9</code> only.</p>
+
+<p>Each root-to-leaf path in the tree represents a number.</p>
+
+<ul>
+	<li>For example, the root-to-leaf path <code>1 -&gt; 2 -&gt; 3</code> represents the number <code>123</code>.</li>
+</ul>
+
+<p>Return <em>the total sum of all root-to-leaf numbers</em>. Test cases are generated so that the answer will fit in a <strong>32-bit</strong> integer.</p>
+
+<p>A <strong>leaf</strong> node is a node with no children.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/num1tree.jpg" style="width: 212px; height: 182px;">
+<pre><strong>Input:</strong> root = [1,2,3]
+<strong>Output:</strong> 25
+<strong>Explanation:</strong>
+The root-to-leaf path <code>1-&gt;2</code> represents the number <code>12</code>.
+The root-to-leaf path <code>1-&gt;3</code> represents the number <code>13</code>.
+Therefore, sum = 12 + 13 = <code>25</code>.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/num2tree.jpg" style="width: 292px; height: 302px;">
+<pre><strong>Input:</strong> root = [4,9,0,5,1]
+<strong>Output:</strong> 1026
+<strong>Explanation:</strong>
+The root-to-leaf path <code>4-&gt;9-&gt;5</code> represents the number 495.
+The root-to-leaf path <code>4-&gt;9-&gt;1</code> represents the number 491.
+The root-to-leaf path <code>4-&gt;0</code> represents the number 40.
+Therefore, sum = 495 + 491 + 40 = <code>1026</code>.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 1000]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 9</code></li>
+	<li>The depth of the tree will not exceed <code>10</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1291-sequential-digits/1291-sequential-digits.java b/leetcode/leetcode/1291-sequential-digits/1291-sequential-digits.java
new file mode 100644
index 0000000..cbcc22c
--- /dev/null
+++ b/leetcode/leetcode/1291-sequential-digits/1291-sequential-digits.java
@@ -0,0 +1,22 @@
+class Solution {
+    public List<Integer> sequentialDigits(int low, int high) {
+        List<Integer> list = new ArrayList<>(36);
+        int to_ADD = 11;
+        int currentNum = 12;
+        int last_to_ADD = 12;
+        while(currentNum<=high){
+            if(currentNum%10!=0){
+                if(currentNum>=low){
+                    list.add(currentNum);
+                }
+            }else{
+                to_ADD = to_ADD*10+1;
+                currentNum = last_to_ADD;
+                last_to_ADD =currentNum + to_ADD;
+            }
+
+            currentNum+=to_ADD;
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1291-sequential-digits/NOTES.md b/leetcode/leetcode/1291-sequential-digits/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1291-sequential-digits/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1291-sequential-digits/README.md b/leetcode/leetcode/1291-sequential-digits/README.md
new file mode 100644
index 0000000..c3dc79c
--- /dev/null
+++ b/leetcode/leetcode/1291-sequential-digits/README.md
@@ -0,0 +1,19 @@
+<h2><a href="https://leetcode.com/problems/sequential-digits/">1291. Sequential Digits</a></h2><h3>Medium</h3><hr><div><p>An&nbsp;integer has <em>sequential digits</em> if and only if each digit in the number is one more than the previous digit.</p>
+
+<p>Return a <strong>sorted</strong> list of all the integers&nbsp;in the range <code>[low, high]</code>&nbsp;inclusive that have sequential digits.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> low = 100, high = 300
+<strong>Output:</strong> [123,234]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> low = 1000, high = 13000
+<strong>Output:</strong> [1234,2345,3456,4567,5678,6789,12345]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>10 &lt;= low &lt;= high &lt;= 10^9</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/1296-divide-array-in-sets-of-k-consecutive-numbers.java b/leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/1296-divide-array-in-sets-of-k-consecutive-numbers.java
new file mode 100644
index 0000000..5ee742f
--- /dev/null
+++ b/leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/1296-divide-array-in-sets-of-k-consecutive-numbers.java
@@ -0,0 +1,33 @@
+class Solution {
+    public boolean isPossibleDivide(int[] nums, int k) {
+        if(nums.length%k!=0) return false;
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int start = Integer.MAX_VALUE;
+        int max = Integer.MIN_VALUE;
+        for(int num: nums){
+            map.put(num,map.getOrDefault(num,0)+1);
+            start = Math.min(start,num);
+            max = Math.max(max,num);
+        }
+        while(start<=max){
+            int nextMin=-1;
+            int K = k;
+            if(map.containsKey(start)){
+                while(K!=0){
+                    if(!map.containsKey(start)) return false;
+                    map.put(start,map.get(start)-1);
+                    if(map.get(start) == 0){
+                        map.remove(start);
+                    }
+                    if(nextMin == -1 && map.containsKey(start)) nextMin = start;
+                    start++;
+                    K--;
+                }
+                if(nextMin!=-1) start = nextMin;
+            }else{
+                start++;
+            }
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/NOTES.md b/leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/README.md b/leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/README.md
new file mode 100644
index 0000000..f672ea5
--- /dev/null
+++ b/leetcode/leetcode/1296-divide-array-in-sets-of-k-consecutive-numbers/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/">1296. Divide Array in Sets of K Consecutive Numbers</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>nums</code> and a positive integer <code>k</code>, check whether it is possible to divide this array into sets of <code>k</code> consecutive numbers.</p>
+
+<p>Return <code>true</code> <em>if it is possible</em>.<strong> </strong>Otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,3,4,4,5,6], k = 4
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Array can be divided into [1,2,3,4] and [3,4,5,6].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Array can be divided into [1,2,3] , [2,3,4] , [3,4,5] and [9,10,11].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4], k = 3
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Each array should be divided in subarrays of size 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Note:</strong> This question is the same as&nbsp;846:&nbsp;<a href="https://leetcode.com/problems/hand-of-straights/" target="_blank">https://leetcode.com/problems/hand-of-straights/</a></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/1299-replace-elements-with-greatest-element-on-right-side.java b/leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/1299-replace-elements-with-greatest-element-on-right-side.java
new file mode 100644
index 0000000..c5d425d
--- /dev/null
+++ b/leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/1299-replace-elements-with-greatest-element-on-right-side.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int[] replaceElements(int[] arr) {
+        int greatest = -1;
+        int counter = arr.length - 1;
+        while(counter>=0){
+            int temp = arr[counter];
+            arr[counter] = greatest;
+            greatest = Math.max(greatest,temp);
+            counter--;
+        }
+        return arr;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/NOTES.md b/leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/README.md b/leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/README.md
new file mode 100644
index 0000000..88ac0e6
--- /dev/null
+++ b/leetcode/leetcode/1299-replace-elements-with-greatest-element-on-right-side/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/replace-elements-with-greatest-element-on-right-side/">1299. Replace Elements with Greatest Element on Right Side</a></h2><h3>Easy</h3><hr><div><p>Given an array <code>arr</code>,&nbsp;replace every element in that array with the greatest element among the elements to its&nbsp;right, and replace the last element with <code>-1</code>.</p>
+
+<p>After doing so, return the array.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [17,18,5,4,6,1]
+<strong>Output:</strong> [18,6,6,6,1,-1]
+<strong>Explanation:</strong> 
+- index 0 --&gt; the greatest element to the right of index 0 is index 1 (18).
+- index 1 --&gt; the greatest element to the right of index 1 is index 4 (6).
+- index 2 --&gt; the greatest element to the right of index 2 is index 4 (6).
+- index 3 --&gt; the greatest element to the right of index 3 is index 4 (6).
+- index 4 --&gt; the greatest element to the right of index 4 is index 5 (1).
+- index 5 --&gt; there are no elements to the right of index 5, so we put -1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [400]
+<strong>Output:</strong> [-1]
+<strong>Explanation:</strong> There are no elements to the right of index 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1302-deepest-leaves-sum/1302-deepest-leaves-sum.java b/leetcode/leetcode/1302-deepest-leaves-sum/1302-deepest-leaves-sum.java
new file mode 100644
index 0000000..39a7ca8
--- /dev/null
+++ b/leetcode/leetcode/1302-deepest-leaves-sum/1302-deepest-leaves-sum.java
@@ -0,0 +1,17 @@
+class Solution {
+
+    public int depth(TreeNode root,int depth){
+        if(root == null) return depth;
+        return Math.max(depth(root.left,depth),depth(root.right,depth)) + 1;
+    }
+
+    public int maxdepthSum(TreeNode root, int currDepth, int maxDepth){
+        if(root == null) return 0;
+        if(currDepth == maxDepth) return root.val;
+        return maxdepthSum(root.left,currDepth+1,maxDepth) + maxdepthSum(root.right,currDepth+1,maxDepth);
+    }
+
+    public int deepestLeavesSum(TreeNode root) {
+        return maxdepthSum(root,1,depth(root,0));
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1302-deepest-leaves-sum/NOTES.md b/leetcode/leetcode/1302-deepest-leaves-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1302-deepest-leaves-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1302-deepest-leaves-sum/README.md b/leetcode/leetcode/1302-deepest-leaves-sum/README.md
new file mode 100644
index 0000000..4d1127e
--- /dev/null
+++ b/leetcode/leetcode/1302-deepest-leaves-sum/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/deepest-leaves-sum/">1302. Deepest Leaves Sum</a></h2><h3>Medium</h3><hr><div>Given the <code>root</code> of a binary tree, return <em>the sum of values of its deepest leaves</em>.
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/07/31/1483_ex1.png" style="width: 273px; height: 265px;">
+<pre><strong>Input:</strong> root = [1,2,3,4,5,null,6,7,null,null,null,null,8]
+<strong>Output:</strong> 15
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
+<strong>Output:</strong> 19
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/1305-all-elements-in-two-binary-search-trees.java b/leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/1305-all-elements-in-two-binary-search-trees.java
new file mode 100644
index 0000000..0f7a170
--- /dev/null
+++ b/leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/1305-all-elements-in-two-binary-search-trees.java
@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+
+class Solution {
+    public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
+        Stack<TreeNode> st1 = new Stack<>();
+        Stack<TreeNode> st2 = new Stack<>();
+        
+        List<Integer> res = new ArrayList<>();
+        
+        while(root1 != null || root2 != null || !st1.empty() || !st2.empty()){
+            while(root1 != null){
+                st1.push(root1);
+                root1 = root1.left;
+            }
+            while(root2 != null){
+                st2.push(root2);
+                root2 = root2.left;
+            }
+            if(st2.empty() || (!st1.empty() && st1.peek().val <= st2.peek().val)){
+                root1 = st1.pop();
+                res.add(root1.val);
+                root1 = root1.right;
+            }
+            else{
+                root2 = st2.pop();
+                res.add(root2.val);
+                root2 = root2.right;
+            }
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/NOTES.md b/leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/README.md b/leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/README.md
new file mode 100644
index 0000000..b199713
--- /dev/null
+++ b/leetcode/leetcode/1305-all-elements-in-two-binary-search-trees/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/all-elements-in-two-binary-search-trees/">1305. All Elements in Two Binary Search Trees</a></h2><h3>Medium</h3><hr><div><p>Given two binary search trees <code>root1</code> and <code>root2</code>, return <em>a list containing all the integers from both trees sorted in <strong>ascending</strong> order</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/q2-e1.png" style="width: 457px; height: 207px;">
+<pre><strong>Input:</strong> root1 = [2,1,4], root2 = [1,0,3]
+<strong>Output:</strong> [0,1,1,2,3,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/q2-e5-.png" style="width: 352px; height: 197px;">
+<pre><strong>Input:</strong> root1 = [1,null,8], root2 = [8,1]
+<strong>Output:</strong> [1,1,8,8]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in each tree is in the range <code>[0, 5000]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1310-xor-queries-of-a-subarray/1310-xor-queries-of-a-subarray.java b/leetcode/leetcode/1310-xor-queries-of-a-subarray/1310-xor-queries-of-a-subarray.java
new file mode 100644
index 0000000..4422fd9
--- /dev/null
+++ b/leetcode/leetcode/1310-xor-queries-of-a-subarray/1310-xor-queries-of-a-subarray.java
@@ -0,0 +1,19 @@
+class Solution {
+
+    public int[] xorQueries(int[] arr, int[][] queries) {
+        int n = arr.length;
+        int[] prefixXOR = new int[n + 1];
+
+        // Build prefix XOR array
+        for (int i = 0; i < n; i++) {
+            prefixXOR[i + 1] = prefixXOR[i] ^ arr[i];
+        }
+
+        int[] result = new int[queries.length];
+        // Process each query using prefix XOR
+        for (int i = 0; i < queries.length; i++) {
+            result[i] = prefixXOR[queries[i][1] + 1] ^ prefixXOR[queries[i][0]];
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1310-xor-queries-of-a-subarray/README.md b/leetcode/leetcode/1310-xor-queries-of-a-subarray/README.md
new file mode 100644
index 0000000..9fa43d8
--- /dev/null
+++ b/leetcode/leetcode/1310-xor-queries-of-a-subarray/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/xor-queries-of-a-subarray/">1310. XOR Queries of a Subarray</a></h2><h3>Medium</h3><hr><div><p>You are given an array <code>arr</code> of positive integers. You are also given the array <code>queries</code> where <code>queries[i] = [left<sub>i, </sub>right<sub>i</sub>]</code>.</p>
+
+<p>For each query <code>i</code> compute the <strong>XOR</strong> of elements from <code>left<sub>i</sub></code> to <code>right<sub>i</sub></code> (that is, <code>arr[left<sub>i</sub>] XOR arr[left<sub>i</sub> + 1] XOR ... XOR arr[right<sub>i</sub>]</code> ).</p>
+
+<p>Return an array <code>answer</code> where <code>answer[i]</code> is the answer to the <code>i<sup>th</sup></code> query.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,3,4,8], queries = [[0,1],[1,2],[0,3],[3,3]]
+<strong>Output:</strong> [2,7,14,8] 
+<strong>Explanation:</strong> 
+The binary representation of the elements in the array are:
+1 = 0001 
+3 = 0011 
+4 = 0100 
+8 = 1000 
+The XOR values for queries are:
+[0,1] = 1 xor 3 = 2 
+[1,2] = 3 xor 4 = 7 
+[0,3] = 1 xor 3 xor 4 xor 8 = 14 
+[3,3] = 8
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [4,8,2,10], queries = [[2,3],[1,3],[0,0],[0,3]]
+<strong>Output:</strong> [8,0,4,4]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length, queries.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>queries[i].length == 2</code></li>
+	<li><code>0 &lt;= left<sub>i</sub> &lt;= right<sub>i</sub> &lt; arr.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1315-sum-of-nodes-with-even-valued-grandparent/1315-sum-of-nodes-with-even-valued-grandparent.java b/leetcode/leetcode/1315-sum-of-nodes-with-even-valued-grandparent/1315-sum-of-nodes-with-even-valued-grandparent.java
new file mode 100644
index 0000000..14d6d23
--- /dev/null
+++ b/leetcode/leetcode/1315-sum-of-nodes-with-even-valued-grandparent/1315-sum-of-nodes-with-even-valued-grandparent.java
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int childSum(TreeNode root){
+        if(root == null){
+            return 0;
+        }
+        int ans = 0;
+        if(root.left != null){
+            ans+=root.left.val;
+        }
+        if(root.right != null){
+            ans+= root.right.val;
+        }
+        return ans;
+    }
+    public int sumEvenGrandparent(TreeNode root) {
+        if(root==null){
+            return 0;
+        }
+        int ans = 0;
+        if(root.val%2==0){
+            ans += childSum(root.left);
+            ans += childSum(root.right);
+        }
+        return ans + sumEvenGrandparent(root.left) + sumEvenGrandparent(root.right);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1315-sum-of-nodes-with-even-valued-grandparent/NOTES.md b/leetcode/leetcode/1315-sum-of-nodes-with-even-valued-grandparent/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1315-sum-of-nodes-with-even-valued-grandparent/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1331-rank-transform-of-an-array/1331-rank-transform-of-an-array.java b/leetcode/leetcode/1331-rank-transform-of-an-array/1331-rank-transform-of-an-array.java
new file mode 100644
index 0000000..6a7d57a
--- /dev/null
+++ b/leetcode/leetcode/1331-rank-transform-of-an-array/1331-rank-transform-of-an-array.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int[] arrayRankTransform(int[] arr) {
+        int newArr[] = arr.clone(); 
+        Arrays.sort(arr);
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int counter = 1;
+        for(int i = 0;i<arr.length;i++){
+            if(!map.containsKey(arr[i])) map.put(arr[i],counter++);
+        }
+        for(int i = 0;i<arr.length;i++){
+            newArr[i] = map.get(newArr[i]);
+        }
+        return newArr;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1331-rank-transform-of-an-array/NOTES.md b/leetcode/leetcode/1331-rank-transform-of-an-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1331-rank-transform-of-an-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1331-rank-transform-of-an-array/README.md b/leetcode/leetcode/1331-rank-transform-of-an-array/README.md
new file mode 100644
index 0000000..dcca4e4
--- /dev/null
+++ b/leetcode/leetcode/1331-rank-transform-of-an-array/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/rank-transform-of-an-array/">1331. Rank Transform of an Array</a></h2><h3>Easy</h3><hr><div><p>Given an array of integers&nbsp;<code>arr</code>, replace each element with its rank.</p>
+
+<p>The rank represents how large the element is. The rank has the following rules:</p>
+
+<ul>
+	<li>Rank is an integer starting from 1.</li>
+	<li>The larger the element, the larger the rank. If two elements are equal, their rank must be the same.</li>
+	<li>Rank should be as small as possible.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [40,10,20,30]
+<strong>Output:</strong> [4,1,2,3]
+<strong>Explanation</strong>: 40 is the largest element. 10 is the smallest. 20 is the second smallest. 30 is the third smallest.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [100,100,100]
+<strong>Output:</strong> [1,1,1]
+<strong>Explanation</strong>: Same elements share the same rank.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [37,12,28,9,100,56,80,5,12]
+<strong>Output:</strong> [5,3,4,2,8,6,7,1,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= arr.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup>&nbsp;&lt;= arr[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1335-maximum-candies-allocated-to-k-children/1335-maximum-candies-allocated-to-k-children.java b/leetcode/leetcode/1335-maximum-candies-allocated-to-k-children/1335-maximum-candies-allocated-to-k-children.java
new file mode 100644
index 0000000..f074018
--- /dev/null
+++ b/leetcode/leetcode/1335-maximum-candies-allocated-to-k-children/1335-maximum-candies-allocated-to-k-children.java
@@ -0,0 +1,47 @@
+class Solution {
+
+    public int maximumCandies(int[] candies, long k) {
+        // Find the maximum number of candies in any pile
+        int maxCandiesInPile = 0;
+        for (int i = 0; i < candies.length; i++) {
+            maxCandiesInPile = Math.max(maxCandiesInPile, candies[i]);
+        }
+
+        // Set the initial search range for binary search
+        int left = 0;
+        int right = maxCandiesInPile;
+
+        // Binary search to find the maximum number of candies each child can get
+        while (left < right) {
+            // Calculate the middle value of the current range
+            int middle = (left + right + 1) / 2;
+
+            // Check if it's possible to allocate candies so that each child gets 'middle' candies
+            if (canAllocateCandies(candies, k, middle)) {
+                // If possible, move to the upper half to search for a larger number
+                left = middle;
+            } else {
+                // Otherwise, move to the lower half
+                right = middle - 1;
+            }
+        }
+
+        return left;
+    }
+
+    private boolean canAllocateCandies(
+        int[] candies,
+        long k,
+        int numOfCandies
+    ) {
+        // Initialize the total number of children that can be served
+        long maxNumOfChildren = 0;
+
+        // Iterate over all piles to calculate how many children each pile can serve
+        for (int pileIndex = 0; pileIndex < candies.length; pileIndex++) {
+            maxNumOfChildren += candies[pileIndex] / numOfCandies;
+        }
+
+        return maxNumOfChildren >= k;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1335-maximum-candies-allocated-to-k-children/README.md b/leetcode/leetcode/1335-maximum-candies-allocated-to-k-children/README.md
new file mode 100644
index 0000000..c37cdab
--- /dev/null
+++ b/leetcode/leetcode/1335-maximum-candies-allocated-to-k-children/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/maximum-candies-allocated-to-k-children">1335. Maximum Candies Allocated to K Children</a></h2><h3>Medium</h3><hr><p>You are given a <strong>0-indexed</strong> integer array <code>candies</code>. Each element in the array denotes a pile of candies of size <code>candies[i]</code>. You can divide each pile into any number of <strong>sub piles</strong>, but you <strong>cannot</strong> merge two piles together.</p>
+
+<p>You are also given an integer <code>k</code>. You should allocate piles of candies to <code>k</code> children such that each child gets the <strong>same</strong> number of candies. Each child can be allocated candies from <strong>only one</strong> pile of candies and some piles of candies may go unused.</p>
+
+<p>Return <em>the <strong>maximum number of candies</strong> each child can get.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> candies = [5,8,6], k = 3
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> We can divide candies[1] into 2 piles of size 5 and 3, and candies[2] into 2 piles of size 5 and 1. We now have five piles of candies of sizes 5, 5, 3, 5, and 1. We can allocate the 3 piles of size 5 to 3 children. It can be proven that each child cannot receive more than 5 candies.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> candies = [2,5], k = 11
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There are 11 children but only 7 candies in total, so it is impossible to ensure each child receives at least one candy. Thus, each child gets no candy and the answer is 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= candies.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= candies[i] &lt;= 10<sup>7</sup></code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>12</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/134-gas-station/134-gas-station.java b/leetcode/leetcode/134-gas-station/134-gas-station.java
new file mode 100644
index 0000000..1f890e4
--- /dev/null
+++ b/leetcode/leetcode/134-gas-station/134-gas-station.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int canCompleteCircuit(int[] gas, int[] cost) {
+        int start = -1;
+        int currentGas = 0;
+        int total=0;
+        for(int i = 0;i<gas.length;i++){
+            total = total + gas[i] - cost[i];
+            currentGas = currentGas + gas[i] - cost[i];
+            if(currentGas<0){
+                currentGas = 0;
+                start = -1;
+                continue;
+            }
+            if(start == -1) start = i;
+        }
+        if(total<0) return -1;
+        return start;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/134-gas-station/NOTES.md b/leetcode/leetcode/134-gas-station/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/134-gas-station/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/134-gas-station/README.md b/leetcode/leetcode/134-gas-station/README.md
new file mode 100644
index 0000000..0969b0a
--- /dev/null
+++ b/leetcode/leetcode/134-gas-station/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/gas-station/">134. Gas Station</a></h2><h3>Medium</h3><hr><div><p>There are <code>n</code> gas stations along a circular route, where the amount of gas at the <code>i<sup>th</sup></code> station is <code>gas[i]</code>.</p>
+
+<p>You have a car with an unlimited gas tank and it costs <code>cost[i]</code> of gas to travel from the <code>i<sup>th</sup></code> station to its next <code>(i + 1)<sup>th</sup></code> station. You begin the journey with an empty tank at one of the gas stations.</p>
+
+<p>Given two integer arrays <code>gas</code> and <code>cost</code>, return <em>the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return</em> <code>-1</code>. If there exists a solution, it is <strong>guaranteed</strong> to be <strong>unique</strong></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> gas = [1,2,3,4,5], cost = [3,4,5,1,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+Start at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
+Travel to station 4. Your tank = 4 - 1 + 5 = 8
+Travel to station 0. Your tank = 8 - 2 + 1 = 7
+Travel to station 1. Your tank = 7 - 3 + 2 = 6
+Travel to station 2. Your tank = 6 - 4 + 3 = 5
+Travel to station 3. The cost is 5. Your gas is just enough to travel back to station 3.
+Therefore, return 3 as the starting index.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> gas = [2,3,4], cost = [3,4,3]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong>
+You can't start at station 0 or 1, as there is not enough gas to travel to the next station.
+Let's start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
+Travel to station 0. Your tank = 4 - 3 + 2 = 3
+Travel to station 1. Your tank = 3 - 3 + 3 = 3
+You cannot travel back to station 2, as it requires 4 unit of gas but you only have 3.
+Therefore, you can't travel around the circuit once no matter where you start.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>gas.length == n</code></li>
+	<li><code>cost.length == n</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= gas[i], cost[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/136-single-number/136-single-number.java b/leetcode/leetcode/136-single-number/136-single-number.java
new file mode 100644
index 0000000..0bd61c3
--- /dev/null
+++ b/leetcode/leetcode/136-single-number/136-single-number.java
@@ -0,0 +1,9 @@
+class Solution {
+    public int singleNumber(int[] nums) {
+        int res = 0;
+        for(int num: nums){
+            res = res^num;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/136-single-number/NOTES.md b/leetcode/leetcode/136-single-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/136-single-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/136-single-number/README.md b/leetcode/leetcode/136-single-number/README.md
new file mode 100644
index 0000000..6ca2f18
--- /dev/null
+++ b/leetcode/leetcode/136-single-number/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/single-number/">136. Single Number</a></h2><h3>Easy</h3><hr><div><p>Given a <strong>non-empty</strong>&nbsp;array of integers <code>nums</code>, every element appears <em>twice</em> except for one. Find that single one.</p>
+
+<p>You must&nbsp;implement a solution with a linear runtime complexity and use&nbsp;only constant&nbsp;extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,1]
+<strong>Output:</strong> 1
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [4,1,2,1,2]
+<strong>Output:</strong> 4
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> 1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-3 * 10<sup>4</sup> &lt;= nums[i] &lt;= 3 * 10<sup>4</sup></code></li>
+	<li>Each element in the array appears twice except for one element which appears only once.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1367-linked-list-in-binary-tree/1367-linked-list-in-binary-tree.java b/leetcode/leetcode/1367-linked-list-in-binary-tree/1367-linked-list-in-binary-tree.java
new file mode 100644
index 0000000..aad5c1c
--- /dev/null
+++ b/leetcode/leetcode/1367-linked-list-in-binary-tree/1367-linked-list-in-binary-tree.java
@@ -0,0 +1,38 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isSubPath(ListNode head, TreeNode root) {
+        if(head == null) return true;
+        if(root == null) return false;
+        return dfs(head,root) || isSubPath(head,root.left) || isSubPath(head,root.right);
+        
+    }
+    public boolean dfs(ListNode head, TreeNode root){
+        if(head == null) return true;
+        if(root == null) return false;
+        return head.val == root.val && (dfs(head.next,root.left) || dfs(head.next,root.right));
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1367-linked-list-in-binary-tree/NOTES.md b/leetcode/leetcode/1367-linked-list-in-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1367-linked-list-in-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1367-linked-list-in-binary-tree/README.md b/leetcode/leetcode/1367-linked-list-in-binary-tree/README.md
new file mode 100644
index 0000000..9941b5c
--- /dev/null
+++ b/leetcode/leetcode/1367-linked-list-in-binary-tree/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/linked-list-in-binary-tree/">1367. Linked List in Binary Tree</a></h2><h3>Medium</h3><hr><div><p>Given a binary tree <code>root</code> and a&nbsp;linked list with&nbsp;<code>head</code>&nbsp;as the first node.&nbsp;</p>
+
+<p>Return True if all the elements in the linked list starting from the <code>head</code> correspond to some <em>downward path</em> connected in the binary tree&nbsp;otherwise return False.</p>
+
+<p>In this context downward path means a path that starts at some node and goes downwards.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/02/12/sample_1_1720.png" style="width: 220px; height: 280px;"></strong></p>
+
+<pre><strong>Input:</strong> head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Nodes in blue form a subpath in the binary Tree.  
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/02/12/sample_2_1720.png" style="width: 220px; height: 280px;"></strong></p>
+
+<pre><strong>Input:</strong> head = [1,4,2,6], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,4,2,6,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There is no path in the binary tree that contains all the elements of the linked list from <code>head</code>.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree will be in the range <code>[1, 2500]</code>.</li>
+	<li>The number of nodes in the list will be in the range <code>[1, 100]</code>.</li>
+	<li><code>1 &lt;= Node.val&nbsp;&lt;= 100</code>&nbsp;for each node in the linked list and binary tree.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1371-find-the-longest-substring-containing-vowels-in-even-counts/1371-find-the-longest-substring-containing-vowels-in-even-counts.java b/leetcode/leetcode/1371-find-the-longest-substring-containing-vowels-in-even-counts/1371-find-the-longest-substring-containing-vowels-in-even-counts.java
new file mode 100644
index 0000000..3e2c7c7
--- /dev/null
+++ b/leetcode/leetcode/1371-find-the-longest-substring-containing-vowels-in-even-counts/1371-find-the-longest-substring-containing-vowels-in-even-counts.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int findTheLongestSubstring(String s) {
+        HashMap<Integer, Integer> map = new HashMap<>();
+        int xor = 0;
+        int ans = 0;
+        int[] characterMap = new int[26];
+        characterMap['a' - 'a'] = 1;
+        characterMap['e' - 'a'] = 2;
+        characterMap['i' - 'a'] = 4;
+        characterMap['o' - 'a'] = 8;
+        characterMap['u' - 'a'] = 16;
+        for(int i = 0;i<s.length();i++){
+            xor = xor ^ characterMap[s.charAt(i) - 'a'];
+            if(xor == 0) ans = i+1;
+            if(map.containsKey(xor)) ans = Math.max(ans,i-map.get(xor));
+            if(!map.containsKey(xor)) map.put(xor,i);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1371-find-the-longest-substring-containing-vowels-in-even-counts/README.md b/leetcode/leetcode/1371-find-the-longest-substring-containing-vowels-in-even-counts/README.md
new file mode 100644
index 0000000..d01a55b
--- /dev/null
+++ b/leetcode/leetcode/1371-find-the-longest-substring-containing-vowels-in-even-counts/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/find-the-longest-substring-containing-vowels-in-even-counts/">1371. Find the Longest Substring Containing Vowels in Even Counts</a></h2><h3>Medium</h3><hr><div><p>Given the string <code>s</code>, return the size of the longest substring containing each vowel an even number of times. That is, 'a', 'e', 'i', 'o', and 'u' must appear an even number of times.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "eleetminicoworoep"
+<strong>Output:</strong> 13
+<strong>Explanation: </strong>The longest substring is "leetminicowor" which contains two each of the vowels: <strong>e</strong>, <strong>i</strong> and <strong>o</strong> and zero of the vowels: <strong>a</strong> and <strong>u</strong>.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "leetcodeisgreat"
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The longest substring is "leetc" which contains two e's.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "bcbcbc"
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> In this case, the given string "bcbcbc" is the longest because all vowels: <strong>a</strong>, <strong>e</strong>, <strong>i</strong>, <strong>o</strong> and <strong>u</strong> appear zero times.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 5 x 10^5</code></li>
+	<li><code>s</code>&nbsp;contains only lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/1373-maximum-sum-bst-in-binary-tree.java b/leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/1373-maximum-sum-bst-in-binary-tree.java
new file mode 100644
index 0000000..a47e2c5
--- /dev/null
+++ b/leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/1373-maximum-sum-bst-in-binary-tree.java
@@ -0,0 +1,53 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    int ans;
+    class Quad{
+        int sum;
+        int max;
+        int min;
+        boolean isBST;
+        Quad(int max,int min,int sum, boolean isBST){
+            this.max = max;
+            this.min = min;
+            this.sum = sum;
+            this.isBST = isBST;
+        }
+    }
+    public Quad maxSumHelper(TreeNode root){
+        if(root == null){ 
+            return new Quad(Integer.MIN_VALUE,Integer.MAX_VALUE,0,true);
+        }
+        Quad left = maxSumHelper(root.left);
+        Quad right = maxSumHelper(root.right);
+        boolean isBST = false;
+        int max = Math.max(root.val,Math.max(left.max,right.max));
+        int min = Math.min(root.val,Math.min(left.min,right.min));
+        int sum = Math.max(0,Math.max(left.sum,right.sum));
+        if(left.isBST && right.isBST && left.max < root.val && right.min > root.val){
+            isBST = true;
+            sum  = root.val + left.sum + right.sum;
+        }
+        ans = Math.max(ans,sum);
+        return new Quad(max,min,sum,isBST);
+        
+    }
+    public int maxSumBST(TreeNode root) {
+        ans = Integer.MIN_VALUE;
+        Quad Q = maxSumHelper(root);
+        return Math.max(ans,0);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/NOTES.md b/leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/README.md b/leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/README.md
new file mode 100644
index 0000000..15319d8
--- /dev/null
+++ b/leetcode/leetcode/1373-maximum-sum-bst-in-binary-tree/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/maximum-sum-bst-in-binary-tree/">1373. Maximum Sum BST in Binary Tree</a></h2><h3>Hard</h3><hr><div><p>Given a <strong>binary tree</strong> <code>root</code>, return <em>the maximum sum of all keys of <strong>any</strong> sub-tree which is also a Binary Search Tree (BST)</em>.</p>
+
+<p>Assume a BST is defined as follows:</p>
+
+<ul>
+	<li>The left subtree of a node contains only nodes with keys <strong>less than</strong> the node's key.</li>
+	<li>The right subtree of a node contains only nodes with keys <strong>greater than</strong> the node's key.</li>
+	<li>Both the left and right subtrees must also be binary search trees.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2020/01/30/sample_1_1709.png" style="width: 320px; height: 250px;"></p>
+
+<pre><strong>Input:</strong> root = [1,4,3,2,4,2,5,null,null,null,null,null,null,4,6]
+<strong>Output:</strong> 20
+<strong>Explanation:</strong> Maximum sum in a valid Binary search tree is obtained in root node with key equal to 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2020/01/30/sample_2_1709.png" style="width: 134px; height: 180px;"></p>
+
+<pre><strong>Input:</strong> root = [4,3,null,1,2]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Maximum sum in a valid Binary search tree is obtained in a single root node with key equal to 2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [-4,-2,-5]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> All values are negatives. Return an empty BST.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 4 * 10<sup>4</sup>]</code>.</li>
+	<li><code>-4 * 10<sup>4</sup> &lt;= Node.val &lt;= 4 * 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/13745-606-153-find-minimum-in-rotated-sorted-array/13745-606-153-find-minimum-in-rotated-sorted-array.py b/leetcode/leetcode/13745-606-153-find-minimum-in-rotated-sorted-array/13745-606-153-find-minimum-in-rotated-sorted-array.py
new file mode 100644
index 0000000..1ef4ae6
--- /dev/null
+++ b/leetcode/leetcode/13745-606-153-find-minimum-in-rotated-sorted-array/13745-606-153-find-minimum-in-rotated-sorted-array.py
@@ -0,0 +1,13 @@
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        left = 0
+        right = len(nums) - 1
+        while(left<right):
+            mid = (left+right) // 2
+            if( nums[mid]<=nums[right]):
+                right = mid
+            else:
+                left = mid+1
+        return nums[left]
+
+        
\ No newline at end of file
diff --git a/leetcode/leetcode/13745-606-153-find-minimum-in-rotated-sorted-array/README.md b/leetcode/leetcode/13745-606-153-find-minimum-in-rotated-sorted-array/README.md
new file mode 100644
index 0000000..85e928c
--- /dev/null
+++ b/leetcode/leetcode/13745-606-153-find-minimum-in-rotated-sorted-array/README.md
@@ -0,0 +1,47 @@
+<h2> 13745 606
+153. Find Minimum in Rotated Sorted Array</h2><hr><div><p>Suppose an array of length <code>n</code> sorted in ascending order is <strong>rotated</strong> between <code>1</code> and <code>n</code> times. For example, the array <code>nums = [0,1,2,4,5,6,7]</code> might become:</p>
+
+<ul>
+	<li><code>[4,5,6,7,0,1,2]</code> if it was rotated <code>4</code> times.</li>
+	<li><code>[0,1,2,4,5,6,7]</code> if it was rotated <code>7</code> times.</li>
+</ul>
+
+<p>Notice that <strong>rotating</strong> an array <code>[a[0], a[1], a[2], ..., a[n-1]]</code> 1 time results in the array <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code>.</p>
+
+<p>Given the sorted rotated array <code>nums</code> of <strong>unique</strong> elements, return <em>the minimum element of this array</em>.</p>
+
+<p>You must write an algorithm that runs in&nbsp;<code>O(log n) time</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,4,5,1,2]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The original array was [1,2,3,4,5] rotated 3 times.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [4,5,6,7,0,1,2]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [11,13,15,17]
+<strong>Output:</strong> 11
+<strong>Explanation:</strong> The original array was [11,13,15,17] and it was rotated 4 times. 
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 5000</code></li>
+	<li><code>-5000 &lt;= nums[i] &lt;= 5000</code></li>
+	<li>All the integers of <code>nums</code> are <strong>unique</strong>.</li>
+	<li><code>nums</code> is sorted and rotated between <code>1</code> and <code>n</code> times.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/138-copy-list-with-random-pointer/138-copy-list-with-random-pointer.java b/leetcode/leetcode/138-copy-list-with-random-pointer/138-copy-list-with-random-pointer.java
new file mode 100644
index 0000000..4fb03b2
--- /dev/null
+++ b/leetcode/leetcode/138-copy-list-with-random-pointer/138-copy-list-with-random-pointer.java
@@ -0,0 +1,32 @@
+/*
+// Definition for a Node.
+class Node {
+    int val;
+    Node next;
+    Node random;
+
+    public Node(int val) {
+        this.val = val;
+        this.next = null;
+        this.random = null;
+    }
+}
+*/
+
+class Solution {
+    public Node copyRandomList(Node head) {
+        HashMap<Node,Node> map = new HashMap<>();
+        Node p = head;
+        while(p!=null){
+            map.put(p,new Node(p.val));
+            p = p.next;
+        }
+        p = head;
+        while(p!=null){
+            map.get(p).next = map.get(p.next);
+            map.get(p).random = map.get(p.random);
+            p = p.next;
+        }
+        return map.get(head);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/138-copy-list-with-random-pointer/NOTES.md b/leetcode/leetcode/138-copy-list-with-random-pointer/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/138-copy-list-with-random-pointer/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/138-copy-list-with-random-pointer/README.md b/leetcode/leetcode/138-copy-list-with-random-pointer/README.md
new file mode 100644
index 0000000..b60daa2
--- /dev/null
+++ b/leetcode/leetcode/138-copy-list-with-random-pointer/README.md
@@ -0,0 +1,47 @@
+<h2><a href="https://leetcode.com/problems/copy-list-with-random-pointer/">138. Copy List with Random Pointer</a></h2><h3>Medium</h3><hr><div><p>A linked list of length <code>n</code> is given such that each node contains an additional random pointer, which could point to any node in the list, or <code>null</code>.</p>
+
+<p>Construct a <a href="https://en.wikipedia.org/wiki/Object_copying#Deep_copy" target="_blank"><strong>deep copy</strong></a> of the list. The deep copy should consist of exactly <code>n</code> <strong>brand new</strong> nodes, where each new node has its value set to the value of its corresponding original node. Both the <code>next</code> and <code>random</code> pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. <strong>None of the pointers in the new list should point to nodes in the original list</strong>.</p>
+
+<p>For example, if there are two nodes <code>X</code> and <code>Y</code> in the original list, where <code>X.random --&gt; Y</code>, then for the corresponding two nodes <code>x</code> and <code>y</code> in the copied list, <code>x.random --&gt; y</code>.</p>
+
+<p>Return <em>the head of the copied linked list</em>.</p>
+
+<p>The linked list is represented in the input/output as a list of <code>n</code> nodes. Each node is represented as a pair of <code>[val, random_index]</code> where:</p>
+
+<ul>
+	<li><code>val</code>: an integer representing <code>Node.val</code></li>
+	<li><code>random_index</code>: the index of the node (range from <code>0</code> to <code>n-1</code>) that the <code>random</code> pointer points to, or <code>null</code> if it does not point to any node.</li>
+</ul>
+
+<p>Your code will <strong>only</strong> be given the <code>head</code> of the original linked list.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/e1.png" style="width: 700px; height: 142px;">
+<pre><strong>Input:</strong> head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
+<strong>Output:</strong> [[7,null],[13,0],[11,4],[10,2],[1,0]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/e2.png" style="width: 700px; height: 114px;">
+<pre><strong>Input:</strong> head = [[1,1],[2,1]]
+<strong>Output:</strong> [[1,1],[2,1]]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/12/18/e3.png" style="width: 700px; height: 122px;"></strong></p>
+
+<pre><strong>Input:</strong> head = [[3,null],[3,0],[3,null]]
+<strong>Output:</strong> [[3,null],[3,0],[3,null]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 1000</code></li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li><code>Node.random</code> is <code>null</code> or is pointing to some node in the linked list.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1387-find-elements-in-a-contaminated-binary-tree/1387-find-elements-in-a-contaminated-binary-tree.java b/leetcode/leetcode/1387-find-elements-in-a-contaminated-binary-tree/1387-find-elements-in-a-contaminated-binary-tree.java
new file mode 100644
index 0000000..5ddc5e0
--- /dev/null
+++ b/leetcode/leetcode/1387-find-elements-in-a-contaminated-binary-tree/1387-find-elements-in-a-contaminated-binary-tree.java
@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class FindElements {
+    HashSet<Integer> set = new HashSet<>();
+    public void helper(TreeNode root, int val){
+        if(root == null) return;
+        set.add(val);
+        helper(root.left,2*val+1);
+        helper(root.right,2*val+2);
+        
+    }
+
+    public FindElements(TreeNode root) {
+        helper(root,0);
+    }
+    
+    public boolean find(int target) {
+        return set.contains(target);
+    }
+}
+
+/**
+ * Your FindElements object will be instantiated and called as such:
+ * FindElements obj = new FindElements(root);
+ * boolean param_1 = obj.find(target);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/1387-find-elements-in-a-contaminated-binary-tree/README.md b/leetcode/leetcode/1387-find-elements-in-a-contaminated-binary-tree/README.md
new file mode 100644
index 0000000..7980583
--- /dev/null
+++ b/leetcode/leetcode/1387-find-elements-in-a-contaminated-binary-tree/README.md
@@ -0,0 +1,75 @@
+<h2><a href="https://leetcode.com/problems/find-elements-in-a-contaminated-binary-tree">1387. Find Elements in a Contaminated Binary Tree</a></h2><h3>Medium</h3><hr><p>Given a binary tree with the following rules:</p>
+
+<ol>
+	<li><code>root.val == 0</code></li>
+	<li>For any <code>treeNode</code>:
+	<ol type="a">
+		<li>If <code>treeNode.val</code> has a value <code>x</code> and <code>treeNode.left != null</code>, then <code>treeNode.left.val == 2 * x + 1</code></li>
+		<li>If <code>treeNode.val</code> has a value <code>x</code> and <code>treeNode.right != null</code>, then <code>treeNode.right.val == 2 * x + 2</code></li>
+	</ol>
+	</li>
+</ol>
+
+<p>Now the binary tree is contaminated, which means all <code>treeNode.val</code> have been changed to <code>-1</code>.</p>
+
+<p>Implement the <code>FindElements</code> class:</p>
+
+<ul>
+	<li><code>FindElements(TreeNode* root)</code> Initializes the object with a contaminated binary tree and recovers it.</li>
+	<li><code>bool find(int target)</code> Returns <code>true</code> if the <code>target</code> value exists in the recovered binary tree.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/06/untitled-diagram-4-1.jpg" style="width: 320px; height: 119px;" />
+<pre>
+<strong>Input</strong>
+[&quot;FindElements&quot;,&quot;find&quot;,&quot;find&quot;]
+[[[-1,null,-1]],[1],[2]]
+<strong>Output</strong>
+[null,false,true]
+<strong>Explanation</strong>
+FindElements findElements = new FindElements([-1,null,-1]); 
+findElements.find(1); // return False 
+findElements.find(2); // return True </pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/06/untitled-diagram-4.jpg" style="width: 400px; height: 198px;" />
+<pre>
+<strong>Input</strong>
+[&quot;FindElements&quot;,&quot;find&quot;,&quot;find&quot;,&quot;find&quot;]
+[[[-1,-1,-1,-1,-1]],[1],[3],[5]]
+<strong>Output</strong>
+[null,true,true,false]
+<strong>Explanation</strong>
+FindElements findElements = new FindElements([-1,-1,-1,-1,-1]);
+findElements.find(1); // return True
+findElements.find(3); // return True
+findElements.find(5); // return False</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/07/untitled-diagram-4-1-1.jpg" style="width: 306px; height: 274px;" />
+<pre>
+<strong>Input</strong>
+[&quot;FindElements&quot;,&quot;find&quot;,&quot;find&quot;,&quot;find&quot;,&quot;find&quot;]
+[[[-1,null,-1,-1,null,-1]],[2],[3],[4],[5]]
+<strong>Output</strong>
+[null,true,false,false,true]
+<strong>Explanation</strong>
+FindElements findElements = new FindElements([-1,null,-1,-1,null,-1]);
+findElements.find(2); // return True
+findElements.find(3); // return False
+findElements.find(4); // return False
+findElements.find(5); // return True
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>TreeNode.val == -1</code></li>
+	<li>The height of the binary tree is less than or equal to <code>20</code></li>
+	<li>The total number of nodes is between <code>[1, 10<sup>4</sup>]</code></li>
+	<li>Total calls of <code>find()</code> is between <code>[1, 10<sup>4</sup>]</code></li>
+	<li><code>0 &lt;= target &lt;= 10<sup>6</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/1390-four-divisors/1390-four-divisors.java b/leetcode/leetcode/1390-four-divisors/1390-four-divisors.java
new file mode 100644
index 0000000..481bedb
--- /dev/null
+++ b/leetcode/leetcode/1390-four-divisors/1390-four-divisors.java
@@ -0,0 +1,28 @@
+class Solution {
+    public int divisor(int num){
+        int counter = 0;
+        int sum = 0;
+        int i = 1;
+        for(;i*i<num;i++){
+            if(num%i==0){
+                counter+=2;
+                sum+=i;
+                sum+=(num/i);
+            }
+            if(counter>4) return 0;
+        }
+        if(i*i == num){
+            counter++;
+            sum+=i;
+        }
+        if(counter==4) return sum;
+        return 0;
+    }
+    public int sumFourDivisors(int[] nums) {
+        int res = 0;
+        for(int num: nums){
+            res+=divisor(num);
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1390-four-divisors/NOTES.md b/leetcode/leetcode/1390-four-divisors/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1390-four-divisors/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1390-four-divisors/README.md b/leetcode/leetcode/1390-four-divisors/README.md
new file mode 100644
index 0000000..fe44e3f
--- /dev/null
+++ b/leetcode/leetcode/1390-four-divisors/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/four-divisors/">1390. Four Divisors</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, return <em>the sum of divisors of the integers in that array that have exactly four divisors</em>. If there is no such integer in the array, return <code>0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [21,4,7]
+<strong>Output:</strong> 32
+<strong>Explanation:</strong> 
+21 has 4 divisors: 1, 3, 7, 21
+4 has 3 divisors: 1, 2, 4
+7 has 2 divisors: 1, 7
+The answer is the sum of divisors of 21 only.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [21,21]
+<strong>Output:</strong> 64
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,5]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/14-longest-common-prefix/14-longest-common-prefix.java b/leetcode/leetcode/14-longest-common-prefix/14-longest-common-prefix.java
new file mode 100644
index 0000000..74d55e5
--- /dev/null
+++ b/leetcode/leetcode/14-longest-common-prefix/14-longest-common-prefix.java
@@ -0,0 +1,18 @@
+class Solution {
+    public String longestCommonPrefix(String[] strs) {
+        if(strs.length == 1) return strs[0];
+        String prefix = strs[0];
+        for(int i = 1;i<strs.length;i++){
+            int j = 0;
+            for(;j<strs[i].length() && j<prefix.length() ;j++){
+               if(prefix.charAt(j) != strs[i].charAt(j)){
+                   prefix = prefix.substring(0,j);
+                   break;
+               } 
+            }
+            prefix = prefix.substring(0,j);
+            if(prefix.length() == 0) return "";
+        }
+        return prefix;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/14-longest-common-prefix/NOTES.md b/leetcode/leetcode/14-longest-common-prefix/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/14-longest-common-prefix/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/14-longest-common-prefix/README.md b/leetcode/leetcode/14-longest-common-prefix/README.md
new file mode 100644
index 0000000..1da86c0
--- /dev/null
+++ b/leetcode/leetcode/14-longest-common-prefix/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/longest-common-prefix/">14. Longest Common Prefix</a></h2><h3>Easy</h3><hr><div><p>Write a function to find the longest common prefix string amongst an array of strings.</p>
+
+<p>If there is no common prefix, return an empty string <code>""</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> strs = ["flower","flow","flight"]
+<strong>Output:</strong> "fl"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> strs = ["dog","racecar","car"]
+<strong>Output:</strong> ""
+<strong>Explanation:</strong> There is no common prefix among the input strings.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= strs.length &lt;= 200</code></li>
+	<li><code>0 &lt;= strs[i].length &lt;= 200</code></li>
+	<li><code>strs[i]</code> consists of only lower-case English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/141-linked-list-cycle/141-linked-list-cycle.java b/leetcode/leetcode/141-linked-list-cycle/141-linked-list-cycle.java
new file mode 100644
index 0000000..82f6be8
--- /dev/null
+++ b/leetcode/leetcode/141-linked-list-cycle/141-linked-list-cycle.java
@@ -0,0 +1,22 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        ListNode fast = head;
+        while(fast!=null && fast.next!=null){
+            head = head.next;
+            fast=fast.next.next;
+            if(head == fast) return true;
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/141-linked-list-cycle/NOTES.md b/leetcode/leetcode/141-linked-list-cycle/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/141-linked-list-cycle/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k.java b/leetcode/leetcode/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k.java
new file mode 100644
index 0000000..5bcea67
--- /dev/null
+++ b/leetcode/leetcode/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k.java
@@ -0,0 +1,32 @@
+class Solution {
+    public int findMinFibonacciNumbers(int k) {
+        List<Integer> list = new ArrayList<>();
+        int prev = 1;
+        int next = 1;
+        int curr = next+prev;
+        list.add(prev);
+        list.add(next);
+        int index = 1;
+        while(curr<=k){
+            list.add(curr);
+            prev = next;
+            next = curr;
+            curr = next+prev;
+            index++;
+        }
+        if(curr == k) return 1;
+        int counter = 0;
+        while(k!=0){
+            int val = list.get(index);
+            if(val>k){
+                list.remove(index);
+                index--;
+            }
+            else{
+                k-=val;
+                counter++;
+            }
+        }
+        return counter;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/NOTES.md b/leetcode/leetcode/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1414-find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/142-linked-list-cycle-ii/142-linked-list-cycle-ii.java b/leetcode/leetcode/142-linked-list-cycle-ii/142-linked-list-cycle-ii.java
new file mode 100644
index 0000000..7d4bc6d
--- /dev/null
+++ b/leetcode/leetcode/142-linked-list-cycle-ii/142-linked-list-cycle-ii.java
@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode detectCycle(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast!=null && fast.next!=null){
+            slow = slow.next;
+            fast = fast.next.next;
+            if(slow == fast){
+                slow = head;
+                while(slow!=fast){
+                    slow = slow.next;
+                    fast = fast.next;
+                }
+                return slow;
+            }
+        }
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/142-linked-list-cycle-ii/NOTES.md b/leetcode/leetcode/142-linked-list-cycle-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/142-linked-list-cycle-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/142-linked-list-cycle-ii/README.md b/leetcode/leetcode/142-linked-list-cycle-ii/README.md
new file mode 100644
index 0000000..25cb254
--- /dev/null
+++ b/leetcode/leetcode/142-linked-list-cycle-ii/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/linked-list-cycle-ii/">142. Linked List Cycle II</a></h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a linked list, return <em>the node where the cycle begins. If there is no cycle, return </em><code>null</code>.</p>
+
+<p>There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the <code>next</code> pointer. Internally, <code>pos</code> is used to denote the index of the node that tail's <code>next</code> pointer is connected to (<strong>0-indexed</strong>). It is <code>-1</code> if there is no cycle. <strong>Note that</strong> <code>pos</code> <strong>is not passed as a parameter</strong>.</p>
+
+<p><strong>Do not modify</strong> the linked list.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png" style="height: 145px; width: 450px;">
+<pre><strong>Input:</strong> head = [3,2,0,-4], pos = 1
+<strong>Output:</strong> tail connects to node index 1
+<strong>Explanation:</strong> There is a cycle in the linked list, where tail connects to the second node.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png" style="height: 105px; width: 201px;">
+<pre><strong>Input:</strong> head = [1,2], pos = 0
+<strong>Output:</strong> tail connects to node index 0
+<strong>Explanation:</strong> There is a cycle in the linked list, where tail connects to the first node.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png" style="height: 65px; width: 65px;">
+<pre><strong>Input:</strong> head = [1], pos = -1
+<strong>Output:</strong> no cycle
+<strong>Explanation:</strong> There is no cycle in the linked list.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li><code>pos</code> is <code>-1</code> or a <strong>valid index</strong> in the linked-list.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Can you solve it using <code>O(1)</code> (i.e. constant) memory?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1421-find-numbers-with-even-number-of-digits/1421-find-numbers-with-even-number-of-digits.java b/leetcode/leetcode/1421-find-numbers-with-even-number-of-digits/1421-find-numbers-with-even-number-of-digits.java
new file mode 100644
index 0000000..10e02bf
--- /dev/null
+++ b/leetcode/leetcode/1421-find-numbers-with-even-number-of-digits/1421-find-numbers-with-even-number-of-digits.java
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean isEvenDigit(int num){
+        boolean ans = true;
+        while(num!=0){
+            num = num /10;
+            ans = !ans;
+        } 
+        return ans;
+
+    }
+    public int findNumbers(int[] nums) {
+        int count  = 0;
+        for(int num: nums){
+            if(isEvenDigit(num)) count++;
+        }
+        return count;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1421-find-numbers-with-even-number-of-digits/README.md b/leetcode/leetcode/1421-find-numbers-with-even-number-of-digits/README.md
new file mode 100644
index 0000000..4497207
--- /dev/null
+++ b/leetcode/leetcode/1421-find-numbers-with-even-number-of-digits/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/find-numbers-with-even-number-of-digits">1421. Find Numbers with Even Number of Digits</a></h2><h3>Easy</h3><hr><p>Given an array <code>nums</code> of integers, return how many of them contain an <strong>even number</strong> of digits.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [12,345,2,6,7896]
+<strong>Output:</strong> 2
+<strong>Explanation: 
+</strong>12 contains 2 digits (even number of digits).&nbsp;
+345 contains 3 digits (odd number of digits).&nbsp;
+2 contains 1 digit (odd number of digits).&nbsp;
+6 contains 1 digit (odd number of digits).&nbsp;
+7896 contains 4 digits (even number of digits).&nbsp;
+Therefore only 12 and 7896 contain an even number of digits.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [555,901,482,1771]
+<strong>Output:</strong> 1 
+<strong>Explanation: </strong>
+Only 1771 contains an even number of digits.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 500</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/1431-kids-with-the-greatest-number-of-candies.java b/leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/1431-kids-with-the-greatest-number-of-candies.java
new file mode 100644
index 0000000..7c56a96
--- /dev/null
+++ b/leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/1431-kids-with-the-greatest-number-of-candies.java
@@ -0,0 +1,17 @@
+class Solution {
+    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
+        int max = 0;
+        for(int num: candies){
+            max = Math.max(max,num);
+        }
+        List<Boolean> list = new ArrayList<>();
+        for(int num: candies){
+            if(num+extraCandies >= max){
+                list.add(true);
+            }else{
+                list.add(false);
+            }
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/NOTES.md b/leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/README.md b/leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/README.md
new file mode 100644
index 0000000..94dd6e7
--- /dev/null
+++ b/leetcode/leetcode/1431-kids-with-the-greatest-number-of-candies/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/">1431. Kids With the Greatest Number of Candies</a></h2><h3>Easy</h3><hr><div><p>There are <code>n</code> kids with candies. You are given an integer array <code>candies</code>, where each <code>candies[i]</code> represents the number of candies the <code>i<sup>th</sup></code> kid has, and an integer <code>extraCandies</code>, denoting the number of extra candies that you have.</p>
+
+<p>Return <em>a boolean array </em><code>result</code><em> of length </em><code>n</code><em>, where </em><code>result[i]</code><em> is </em><code>true</code><em> if, after giving the </em><code>i<sup>th</sup></code><em> kid all the </em><code>extraCandies</code><em>, they will have the <strong>greatest</strong> number of candies among all the kids</em><em>, or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>Note that <strong>multiple</strong> kids can have the <strong>greatest</strong> number of candies.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> candies = [2,3,5,1,3], extraCandies = 3
+<strong>Output:</strong> [true,true,true,false,true] 
+<strong>Explanation:</strong> If you give all extraCandies to:
+- Kid 1, they will have 2 + 3 = 5 candies, which is the greatest among the kids.
+- Kid 2, they will have 3 + 3 = 6 candies, which is the greatest among the kids.
+- Kid 3, they will have 5 + 3 = 8 candies, which is the greatest among the kids.
+- Kid 4, they will have 1 + 3 = 4 candies, which is not the greatest among the kids.
+- Kid 5, they will have 3 + 3 = 6 candies, which is the greatest among the kids.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> candies = [4,2,1,1,2], extraCandies = 1
+<strong>Output:</strong> [true,false,false,false,false] 
+<strong>Explanation:</strong> There is only 1 extra candy.
+Kid 1 will always have the greatest number of candies, even if a different kid is given the extra candy.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> candies = [12,1,12], extraCandies = 10
+<strong>Output:</strong> [true,false,true]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == candies.length</code></li>
+	<li><code>2 &lt;= n &lt;= 100</code></li>
+	<li><code>1 &lt;= candies[i] &lt;= 100</code></li>
+	<li><code>1 &lt;= extraCandies &lt;= 50</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1441-build-an-array-with-stack-operations/1441-build-an-array-with-stack-operations.java b/leetcode/leetcode/1441-build-an-array-with-stack-operations/1441-build-an-array-with-stack-operations.java
new file mode 100644
index 0000000..5adf365
--- /dev/null
+++ b/leetcode/leetcode/1441-build-an-array-with-stack-operations/1441-build-an-array-with-stack-operations.java
@@ -0,0 +1,17 @@
+class Solution {
+    public List<String> buildArray(int[] target, int n) {
+        List<String> list = new ArrayList<>();
+        int index = 0;
+        for(int i = 1;i<=n;i++){
+            if(index==target.length) break;
+            if(target[index] == i){
+                list.add("Push");
+                index++;
+                continue;
+            }
+            list.add("Push");
+            list.add("Pop");
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1441-build-an-array-with-stack-operations/NOTES.md b/leetcode/leetcode/1441-build-an-array-with-stack-operations/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1441-build-an-array-with-stack-operations/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/1443-minimum-time-to-collect-all-apples-in-a-tree.java b/leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/1443-minimum-time-to-collect-all-apples-in-a-tree.java
new file mode 100644
index 0000000..1574638
--- /dev/null
+++ b/leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/1443-minimum-time-to-collect-all-apples-in-a-tree.java
@@ -0,0 +1,27 @@
+class Solution {
+    public int helper(int current, int parent, HashMap<Integer,List<Integer>> map,List<Boolean> hasApple){
+        if(!map.containsKey(current)) return 0;
+        int ans = 0;
+        for(int child: map.get(current)){
+            if(child == parent) continue;
+            int childTime = helper(child,current,map,hasApple);
+            if (childTime > 0 || hasApple.get(child))
+                ans += childTime + 2;
+        }
+        return ans;
+    }
+    public int minTime(int n, int[][] edges, List<Boolean> hasApple) {
+        HashMap<Integer,List<Integer>> map = new HashMap<>();
+        for(int[] edge: edges){
+            int a = edge[0];
+            int b = edge[1];
+            List<Integer> list = map.getOrDefault(a,new ArrayList<Integer>());
+            list.add(b);
+            map.put(a,list);
+            list = map.getOrDefault(b,new ArrayList<Integer>());
+            list.add(a);
+            map.put(b,list);
+        }
+        return helper(0,-1,map,hasApple);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/NOTES.md b/leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/README.md b/leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/README.md
new file mode 100644
index 0000000..a9756d9
--- /dev/null
+++ b/leetcode/leetcode/1443-minimum-time-to-collect-all-apples-in-a-tree/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/minimum-time-to-collect-all-apples-in-a-tree/">1443. Minimum Time to Collect All Apples in a Tree</a></h2><h3>Medium</h3><hr><div><p>Given an undirected tree consisting of <code>n</code> vertices numbered from <code>0</code> to <code>n-1</code>, which has some apples in their vertices. You spend 1 second to walk over one edge of the tree. <em>Return the minimum time in seconds you have to spend to collect all apples in the tree, starting at <strong>vertex 0</strong> and coming back to this vertex.</em></p>
+
+<p>The edges of the undirected tree are given in the array <code>edges</code>, where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> means that exists an edge connecting the vertices <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>. Additionally, there is a boolean array <code>hasApple</code>, where <code>hasApple[i] = true</code> means that vertex <code>i</code> has an apple; otherwise, it does not have any apple.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/04/23/min_time_collect_apple_1.png" style="width: 300px; height: 212px;">
+<pre><strong>Input:</strong> n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,true,true,false]
+<strong>Output:</strong> 8 
+<strong>Explanation:</strong> The figure above represents the given tree where red vertices have an apple. One optimal path to collect all apples is shown by the green arrows.  
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/04/23/min_time_collect_apple_2.png" style="width: 300px; height: 212px;">
+<pre><strong>Input:</strong> n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,false,true,false]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The figure above represents the given tree where red vertices have an apple. One optimal path to collect all apples is shown by the green arrows.  
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,false,false,false,false,false]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>edges.length == n - 1</code></li>
+	<li><code>edges[i].length == 2</code></li>
+	<li><code>0 &lt;= a<sub>i</sub> &lt; b<sub>i</sub> &lt;= n - 1</code></li>
+	<li><code>from<sub>i</sub> &lt; to<sub>i</sub></code></li>
+	<li><code>hasApple.length == n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1448-count-good-nodes-in-binary-tree/1448-count-good-nodes-in-binary-tree.java b/leetcode/leetcode/1448-count-good-nodes-in-binary-tree/1448-count-good-nodes-in-binary-tree.java
new file mode 100644
index 0000000..ef4c60c
--- /dev/null
+++ b/leetcode/leetcode/1448-count-good-nodes-in-binary-tree/1448-count-good-nodes-in-binary-tree.java
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    
+    public int helper(TreeNode root,int maxVal,int rootVal){
+        if(root==null) return 0;
+        int ans = 0;
+        if(root.val>=rootVal && root.val>=maxVal) ans++;
+        if(maxVal<root.val) maxVal = root.val;
+        return ans + helper(root.left,maxVal,rootVal) + helper(root.right,maxVal,rootVal);
+    }
+    
+    public int goodNodes(TreeNode root) {
+        return helper(root,root.val,root.val);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1448-count-good-nodes-in-binary-tree/NOTES.md b/leetcode/leetcode/1448-count-good-nodes-in-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1448-count-good-nodes-in-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1448-count-good-nodes-in-binary-tree/README.md b/leetcode/leetcode/1448-count-good-nodes-in-binary-tree/README.md
new file mode 100644
index 0000000..e059058
--- /dev/null
+++ b/leetcode/leetcode/1448-count-good-nodes-in-binary-tree/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/count-good-nodes-in-binary-tree/">1448. Count Good Nodes in Binary Tree</a></h2><h3>Medium</h3><hr><div><p>Given a binary tree <code>root</code>, a node <em>X</em> in the tree is named&nbsp;<strong>good</strong> if in the path from root to <em>X</em> there are no nodes with a value <em>greater than</em> X.</p>
+
+<p>Return the number of <strong>good</strong> nodes in the binary tree.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/04/02/test_sample_1.png" style="width: 263px; height: 156px;"></strong></p>
+
+<pre><strong>Input:</strong> root = [3,1,4,3,null,1,5]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Nodes in blue are <strong>good</strong>.
+Root Node (3) is always a good node.
+Node 4 -&gt; (3,4) is the maximum value in the path starting from the root.
+Node 5 -&gt; (3,4,5) is the maximum value in the path
+Node 3 -&gt; (3,1,3) is the maximum value in the path.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/04/02/test_sample_2.png" style="width: 157px; height: 161px;"></strong></p>
+
+<pre><strong>Input:</strong> root = [3,3,null,4,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Node 2 -&gt; (3, 3, 2) is not good, because "3" is higher than it.</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> Root is considered as <strong>good</strong>.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the binary tree is in the range&nbsp;<code>[1, 10^5]</code>.</li>
+	<li>Each node's value is between <code>[-10^4, 10^4]</code>.</li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1451-rearrange-words-in-a-sentence/1451-rearrange-words-in-a-sentence.java b/leetcode/leetcode/1451-rearrange-words-in-a-sentence/1451-rearrange-words-in-a-sentence.java
new file mode 100644
index 0000000..58d5c58
--- /dev/null
+++ b/leetcode/leetcode/1451-rearrange-words-in-a-sentence/1451-rearrange-words-in-a-sentence.java
@@ -0,0 +1,14 @@
+class Solution {
+    public String arrangeWords(String text) {
+        String[] res = text.split(" ");
+        Arrays.sort(res, (a, b)->Integer.compare(a.length(), b.length()));
+        StringBuilder sb = new StringBuilder(text.length());
+        sb.append(Character.toUpperCase(res[0].charAt(0)));
+        sb.append(res[0].substring(1,res[0].length()));
+        for(int i = 1;i<res.length;i++){
+            sb.append(" ");
+            sb.append(res[i].toLowerCase());
+        }
+        return sb.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1451-rearrange-words-in-a-sentence/NOTES.md b/leetcode/leetcode/1451-rearrange-words-in-a-sentence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1451-rearrange-words-in-a-sentence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1451-rearrange-words-in-a-sentence/README.md b/leetcode/leetcode/1451-rearrange-words-in-a-sentence/README.md
new file mode 100644
index 0000000..fa9b4d5
--- /dev/null
+++ b/leetcode/leetcode/1451-rearrange-words-in-a-sentence/README.md
@@ -0,0 +1,46 @@
+<h2><a href="https://leetcode.com/problems/rearrange-words-in-a-sentence/">1451. Rearrange Words in a Sentence</a></h2><h3>Medium</h3><hr><div><p>Given a sentence&nbsp;<code>text</code> (A&nbsp;<em>sentence</em>&nbsp;is a string of space-separated words) in the following format:</p>
+
+<ul>
+	<li>First letter is in upper case.</li>
+	<li>Each word in <code>text</code> are separated by a single space.</li>
+</ul>
+
+<p>Your task is to rearrange the words in text such that&nbsp;all words are rearranged in an increasing order of their lengths. If two words have the same length, arrange them in their original order.</p>
+
+<p>Return the new text&nbsp;following the format shown above.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> text = "Leetcode is cool"
+<strong>Output:</strong> "Is cool leetcode"
+<strong>Explanation: </strong>There are 3 words, "Leetcode" of length 8, "is" of length 2 and "cool" of length 4.
+Output is ordered by length and the new first word starts with capital letter.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> text = "Keep calm and code on"
+<strong>Output:</strong> "On and keep calm code"
+<strong>Explanation: </strong>Output is ordered as follows:
+"On" 2 letters.
+"and" 3 letters.
+"keep" 4 letters in case of tie order by position in original text.
+"calm" 4 letters.
+"code" 4 letters.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> text = "To be or not to be"
+<strong>Output:</strong> "To be or to be not"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>text</code> begins with a capital letter and then contains lowercase letters and single space between words.</li>
+	<li><code>1 &lt;= text.length &lt;= 10^5</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/1456-maximum-number-of-vowels-in-a-substring-of-given-length.java b/leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/1456-maximum-number-of-vowels-in-a-substring-of-given-length.java
new file mode 100644
index 0000000..54e9f02
--- /dev/null
+++ b/leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/1456-maximum-number-of-vowels-in-a-substring-of-given-length.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int maxVowels(String s, int k) {
+        int ans = 0;
+        for(int i = 0;i<k;i++){
+            if(s.charAt(i)=='a' || s.charAt(i) == 'e'|| s.charAt(i) == 'i' || s.charAt(i) == 'o' || s.charAt(i) =='u'){
+                ans++;
+            }
+        }
+        int low = 0;
+        int temp = ans;
+        while(low+k!=s.length()){
+            if(s.charAt(low)=='a' || s.charAt(low) == 'e'|| s.charAt(low) == 'i' || s.charAt(low) == 'o' || s.charAt(low) =='u'){
+                temp--;
+            }
+            if(s.charAt(low+k)=='a' || s.charAt(low+k) == 'e'|| s.charAt(low+k) == 'i' || s.charAt(low+k) == 'o' || s.charAt(low+k) =='u'){
+                temp++;
+            }
+            low++;
+            ans = Math.max(ans,temp);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/NOTES.md b/leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/README.md b/leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/README.md
new file mode 100644
index 0000000..ab9e2fe
--- /dev/null
+++ b/leetcode/leetcode/1456-maximum-number-of-vowels-in-a-substring-of-given-length/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/maximum-number-of-vowels-in-a-substring-of-given-length/">1456. Maximum Number of Vowels in a Substring of Given Length</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code> and an integer <code>k</code>, return <em>the maximum number of vowel letters in any substring of </em><code>s</code><em> with length </em><code>k</code>.</p>
+
+<p><strong>Vowel letters</strong> in English are <code>'a'</code>, <code>'e'</code>, <code>'i'</code>, <code>'o'</code>, and <code>'u'</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "abciiidef", k = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The substring "iii" contains 3 vowel letters.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "aeiou", k = 2
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Any substring of length 2 contains 2 vowels.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "leetcode", k = 3
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> "lee", "eet" and "ode" contain 2 vowels.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+	<li><code>1 &lt;= k &lt;= s.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1460-number-of-substrings-containing-all-three-characters/1460-number-of-substrings-containing-all-three-characters.java b/leetcode/leetcode/1460-number-of-substrings-containing-all-three-characters/1460-number-of-substrings-containing-all-three-characters.java
new file mode 100644
index 0000000..e514037
--- /dev/null
+++ b/leetcode/leetcode/1460-number-of-substrings-containing-all-three-characters/1460-number-of-substrings-containing-all-three-characters.java
@@ -0,0 +1,24 @@
+class Solution {
+    public int numberOfSubstrings(String s) {
+        int[] freq = {0,0,0};
+        int start  = 0;
+        int end = 0;
+        int N = s.length();
+        int answer = 0;
+        freq[s.charAt(start)-'a']++;
+        while(start<N && end<N){
+            if(freq[0] > 0 && freq[1] > 0 && freq[2] > 0){
+                answer+=(N - end);
+                freq[s.charAt(start)-'a']--;
+                start++;
+            }else if(end<N-1){
+                end++;
+                freq[s.charAt(end)-'a']++;
+            }else{
+                freq[s.charAt(start)-'a']--;
+                start++;
+            }
+        }
+        return answer;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1460-number-of-substrings-containing-all-three-characters/README.md b/leetcode/leetcode/1460-number-of-substrings-containing-all-three-characters/README.md
new file mode 100644
index 0000000..fc7ac26
--- /dev/null
+++ b/leetcode/leetcode/1460-number-of-substrings-containing-all-three-characters/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/number-of-substrings-containing-all-three-characters">1460. Number of Substrings Containing All Three Characters</a></h2><h3>Medium</h3><hr><p>Given a string <code>s</code>&nbsp;consisting only of characters <em>a</em>, <em>b</em> and <em>c</em>.</p>
+
+<p>Return the number of substrings containing <b>at least</b>&nbsp;one occurrence of all these characters <em>a</em>, <em>b</em> and <em>c</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcabc&quot;
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> The substrings containing&nbsp;at least&nbsp;one occurrence of the characters&nbsp;<em>a</em>,&nbsp;<em>b</em>&nbsp;and&nbsp;<em>c are &quot;</em>abc<em>&quot;, &quot;</em>abca<em>&quot;, &quot;</em>abcab<em>&quot;, &quot;</em>abcabc<em>&quot;, &quot;</em>bca<em>&quot;, &quot;</em>bcab<em>&quot;, &quot;</em>bcabc<em>&quot;, &quot;</em>cab<em>&quot;, &quot;</em>cabc<em>&quot; </em>and<em> &quot;</em>abc<em>&quot; </em>(<strong>again</strong>)<em>. </em>
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;aaacb&quot;
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The substrings containing&nbsp;at least&nbsp;one occurrence of the characters&nbsp;<em>a</em>,&nbsp;<em>b</em>&nbsp;and&nbsp;<em>c are &quot;</em>aaacb<em>&quot;, &quot;</em>aacb<em>&quot; </em>and<em> &quot;</em>acb<em>&quot;.</em><em> </em>
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abc&quot;
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= s.length &lt;= 5 x 10^4</code></li>
+	<li><code>s</code>&nbsp;only consists of&nbsp;<em>a</em>, <em>b</em> or <em>c&nbsp;</em>characters.</li>
+</ul>
diff --git a/leetcode/leetcode/147-insertion-sort-list/147-insertion-sort-list.java b/leetcode/leetcode/147-insertion-sort-list/147-insertion-sort-list.java
new file mode 100644
index 0000000..68b10fd
--- /dev/null
+++ b/leetcode/leetcode/147-insertion-sort-list/147-insertion-sort-list.java
@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode insertionSortList(ListNode head) {
+        List<Integer> list = new ArrayList<>();
+        ListNode temp = head;
+        while(temp!=null){
+            list.add(temp.val);
+            temp = temp.next;
+        }
+        Collections.sort(list);
+        temp = head;
+        int i = 0;
+        while(temp!=null){
+            temp.val = list.get(i);
+            i++;
+            temp = temp.next;
+        }
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/147-insertion-sort-list/NOTES.md b/leetcode/leetcode/147-insertion-sort-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/147-insertion-sort-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/147-insertion-sort-list/README.md b/leetcode/leetcode/147-insertion-sort-list/README.md
new file mode 100644
index 0000000..b40ea2c
--- /dev/null
+++ b/leetcode/leetcode/147-insertion-sort-list/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/insertion-sort-list/">147. Insertion Sort List</a></h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a singly linked list, sort the list using <strong>insertion sort</strong>, and return <em>the sorted list's head</em>.</p>
+
+<p>The steps of the <strong>insertion sort</strong> algorithm:</p>
+
+<ol>
+	<li>Insertion sort iterates, consuming one input element each repetition and growing a sorted output list.</li>
+	<li>At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list and inserts it there.</li>
+	<li>It repeats until no input elements remain.</li>
+</ol>
+
+<p>The following is a graphical example of the insertion sort algorithm. The partially sorted list (black) initially contains only the first element in the list. One element (red) is removed from the input data and inserted in-place into the sorted list with each iteration.</p>
+<img alt="" src="https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif" style="height:180px; width:300px">
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/04/sort1linked-list.jpg" style="width: 422px; height: 222px;">
+<pre><strong>Input:</strong> head = [4,2,1,3]
+<strong>Output:</strong> [1,2,3,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/04/sort2linked-list.jpg" style="width: 542px; height: 222px;">
+<pre><strong>Input:</strong> head = [-1,5,3,4,0]
+<strong>Output:</strong> [-1,0,3,4,5]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 5000]</code>.</li>
+	<li><code>-5000 &lt;= Node.val &lt;= 5000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1476-subrectangle-queries/1476-subrectangle-queries.java b/leetcode/leetcode/1476-subrectangle-queries/1476-subrectangle-queries.java
new file mode 100644
index 0000000..0eab625
--- /dev/null
+++ b/leetcode/leetcode/1476-subrectangle-queries/1476-subrectangle-queries.java
@@ -0,0 +1,26 @@
+class SubrectangleQueries {
+    public int rec[][];
+
+    public SubrectangleQueries(int[][] rectangle) {
+        rec = rectangle;
+    }
+    
+    public void updateSubrectangle(int row1, int col1, int row2, int col2, int newValue) {
+        for(int i = row1;i<=row2;i++){
+            for(int j = col1;j<=col2;j++){
+                rec[i][j] = newValue;
+            }
+        }
+    }
+    
+    public int getValue(int row, int col) {
+        return rec[row][col];
+    }
+}
+
+/**
+ * Your SubrectangleQueries object will be instantiated and called as such:
+ * SubrectangleQueries obj = new SubrectangleQueries(rectangle);
+ * obj.updateSubrectangle(row1,col1,row2,col2,newValue);
+ * int param_2 = obj.getValue(row,col);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/1476-subrectangle-queries/NOTES.md b/leetcode/leetcode/1476-subrectangle-queries/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1476-subrectangle-queries/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1476-subrectangle-queries/README.md b/leetcode/leetcode/1476-subrectangle-queries/README.md
new file mode 100644
index 0000000..2869a77
--- /dev/null
+++ b/leetcode/leetcode/1476-subrectangle-queries/README.md
@@ -0,0 +1,80 @@
+<h2><a href="https://leetcode.com/problems/subrectangle-queries/">1476. Subrectangle Queries</a></h2><h3>Medium</h3><hr><div><p>Implement the class <code>SubrectangleQueries</code>&nbsp;which receives a <code>rows x cols</code> rectangle as a matrix of integers in the constructor and supports two methods:</p>
+
+<p>1.<code>&nbsp;updateSubrectangle(int row1, int col1, int row2, int col2, int newValue)</code></p>
+
+<ul>
+	<li>Updates all values with <code>newValue</code> in the subrectangle whose upper left coordinate is <code>(row1,col1)</code> and bottom right coordinate is <code>(row2,col2)</code>.</li>
+</ul>
+
+<p>2.<code>&nbsp;getValue(int row, int col)</code></p>
+
+<ul>
+	<li>Returns the current value of the coordinate <code>(row,col)</code> from&nbsp;the rectangle.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["SubrectangleQueries","getValue","updateSubrectangle","getValue","getValue","updateSubrectangle","getValue","getValue"]
+[[[[1,2,1],[4,3,4],[3,2,1],[1,1,1]]],[0,2],[0,0,3,2,5],[0,2],[3,1],[3,0,3,2,10],[3,1],[0,2]]
+<strong>Output</strong>
+[null,1,null,5,5,null,10,5]
+<strong>Explanation</strong>
+SubrectangleQueries subrectangleQueries = new SubrectangleQueries([[1,2,1],[4,3,4],[3,2,1],[1,1,1]]);  
+// The initial rectangle (4x3) looks like:
+// 1 2 1
+// 4 3 4
+// 3 2 1
+// 1 1 1
+subrectangleQueries.getValue(0, 2); // return 1
+subrectangleQueries.updateSubrectangle(0, 0, 3, 2, 5);
+// After this update the rectangle looks like:
+// 5 5 5
+// 5 5 5
+// 5 5 5
+// 5 5 5 
+subrectangleQueries.getValue(0, 2); // return 5
+subrectangleQueries.getValue(3, 1); // return 5
+subrectangleQueries.updateSubrectangle(3, 0, 3, 2, 10);
+// After this update the rectangle looks like:
+// 5   5   5
+// 5   5   5
+// 5   5   5
+// 10  10  10 
+subrectangleQueries.getValue(3, 1); // return 10
+subrectangleQueries.getValue(0, 2); // return 5
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input</strong>
+["SubrectangleQueries","getValue","updateSubrectangle","getValue","getValue","updateSubrectangle","getValue"]
+[[[[1,1,1],[2,2,2],[3,3,3]]],[0,0],[0,0,2,2,100],[0,0],[2,2],[1,1,2,2,20],[2,2]]
+<strong>Output</strong>
+[null,1,null,100,100,null,20]
+<strong>Explanation</strong>
+SubrectangleQueries subrectangleQueries = new SubrectangleQueries([[1,1,1],[2,2,2],[3,3,3]]);
+subrectangleQueries.getValue(0, 0); // return 1
+subrectangleQueries.updateSubrectangle(0, 0, 2, 2, 100);
+subrectangleQueries.getValue(0, 0); // return 100
+subrectangleQueries.getValue(2, 2); // return 100
+subrectangleQueries.updateSubrectangle(1, 1, 2, 2, 20);
+subrectangleQueries.getValue(2, 2); // return 20
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>There will be at most <code><font face="monospace">500</font></code>&nbsp;operations considering both methods:&nbsp;<code>updateSubrectangle</code> and <code>getValue</code>.</li>
+	<li><code>1 &lt;= rows, cols &lt;= 100</code></li>
+	<li><code>rows ==&nbsp;rectangle.length</code></li>
+	<li><code>cols == rectangle[i].length</code></li>
+	<li><code>0 &lt;= row1 &lt;= row2 &lt; rows</code></li>
+	<li><code>0 &lt;= col1 &lt;= col2 &lt; cols</code></li>
+	<li><code>1 &lt;= newValue, rectangle[i][j] &lt;= 10^9</code></li>
+	<li><code>0 &lt;= row &lt; rows</code></li>
+	<li><code>0 &lt;= col &lt; cols</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/148-sort-list/148-sort-list.java b/leetcode/leetcode/148-sort-list/148-sort-list.java
new file mode 100644
index 0000000..b2f4308
--- /dev/null
+++ b/leetcode/leetcode/148-sort-list/148-sort-list.java
@@ -0,0 +1,91 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+// class Solution {
+//     public ListNode mergeTwoLists(ListNode l1, ListNode l2){
+//         if(l1==null) return l2;
+//         if(l2==null) return l1;
+//         if(l1.val>l2.val){
+//             ListNode temp = l1;
+//             l1 = l2;
+//             l2 = temp;
+//         }
+//         ListNode res = l1;
+//         ListNode temp  = l1;
+//         l1 = l1.next;
+//         while(l2!=null){
+//             if(l1 == null){
+//                 temp.next = l2;
+//                 break;
+//             }
+//             if(l1.val>l2.val){
+//                 temp.next = l2;
+//                 l2 =l2.next;
+//                 temp = temp.next;
+//                 temp.next = l1;
+//             }else{
+//                 temp = l1;
+//                 l1 = l1.next;
+//             }
+//         }
+//         return res;   
+//     }
+    
+//     public ListNode sortList(ListNode head) {
+//         if(head==null || head.next==null) return head;
+//         ListNode prev = null;
+//         ListNode slow = head;
+//         ListNode fast = head;
+//         while(fast!=null && fast.next !=null){
+//             prev = slow;
+//             slow = slow.next;
+//             fast = fast.next.next;
+//         }
+//         prev.next = null;
+//         ListNode l1 = sortList(head);
+//         ListNode l2 = sortList(slow);
+//         return mergeTwoLists(l1,l2);
+//     }
+// }
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode sortList(ListNode head) {
+        if(head==null || head.next == null) return head;
+        int size = 0;
+        ListNode temp = head;
+        while(temp!=null){
+            temp = temp.next;
+            size++;
+        }
+        int[] arr = new int[size--];
+        temp = head;
+        while(temp!=null){
+            arr[size--] = temp.val;
+            temp =  temp.next;
+        }
+        Arrays.sort(arr);
+        temp = head;
+        while(temp!=null){
+            temp.val = arr[++size];
+            temp =temp.next;
+        }
+        return head;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/148-sort-list/NOTES.md b/leetcode/leetcode/148-sort-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/148-sort-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/148-sort-list/README.md b/leetcode/leetcode/148-sort-list/README.md
new file mode 100644
index 0000000..1446549
--- /dev/null
+++ b/leetcode/leetcode/148-sort-list/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/sort-list/">148. Sort List</a></h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a linked list, return <em>the list after sorting it in <strong>ascending order</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg" style="width: 450px; height: 194px;">
+<pre><strong>Input:</strong> head = [4,2,1,3]
+<strong>Output:</strong> [1,2,3,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg" style="width: 550px; height: 184px;">
+<pre><strong>Input:</strong> head = [-1,5,3,4,0]
+<strong>Output:</strong> [-1,0,3,4,5]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Can you sort the linked list in <code>O(n logn)</code> time and <code>O(1)</code> memory (i.e. constant space)?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1480-running-sum-of-1d-array/1480-running-sum-of-1d-array.java b/leetcode/leetcode/1480-running-sum-of-1d-array/1480-running-sum-of-1d-array.java
new file mode 100644
index 0000000..90c8622
--- /dev/null
+++ b/leetcode/leetcode/1480-running-sum-of-1d-array/1480-running-sum-of-1d-array.java
@@ -0,0 +1,8 @@
+class Solution {
+    public int[] runningSum(int[] nums) {
+        for(int i = 1;i<nums.length;i++){
+            nums[i] = nums[i-1]+nums[i];
+        }
+        return nums;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1480-running-sum-of-1d-array/NOTES.md b/leetcode/leetcode/1480-running-sum-of-1d-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1480-running-sum-of-1d-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1480-running-sum-of-1d-array/README.md b/leetcode/leetcode/1480-running-sum-of-1d-array/README.md
new file mode 100644
index 0000000..482ee91
--- /dev/null
+++ b/leetcode/leetcode/1480-running-sum-of-1d-array/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/running-sum-of-1d-array/">1480. Running Sum of 1d Array</a></h2><h3>Easy</h3><hr><div><p>Given an array <code>nums</code>. We define a running sum of an array as&nbsp;<code>runningSum[i] = sum(nums[0]…nums[i])</code>.</p>
+
+<p>Return the running sum of <code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> [1,3,6,10]
+<strong>Explanation:</strong> Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,1,1,1]
+<strong>Output:</strong> [1,2,3,4,5]
+<strong>Explanation:</strong> Running sum is obtained as follows: [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1].</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,1,2,10,1]
+<strong>Output:</strong> [3,4,6,16,17]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>-10^6&nbsp;&lt;= nums[i] &lt;=&nbsp;10^6</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/1491-average-salary-excluding-the-minimum-and-maximum-salary.java b/leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/1491-average-salary-excluding-the-minimum-and-maximum-salary.java
new file mode 100644
index 0000000..d0a6705
--- /dev/null
+++ b/leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/1491-average-salary-excluding-the-minimum-and-maximum-salary.java
@@ -0,0 +1,20 @@
+class Solution {
+    public double average(int[] salary) {
+        int min = Integer.MAX_VALUE;
+        int max  = Integer.MIN_VALUE;
+        for(int val: salary){
+            if(val>max)
+                max = val;
+            if(val<min)
+                min = val;
+        }
+        double ans = 0;
+        for(int val: salary){
+            if(val == min || val == max)
+                continue;
+            ans+=val;
+        }
+        ans = ans/(salary.length-2);
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/NOTES.md b/leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/README.md b/leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/README.md
new file mode 100644
index 0000000..2c1a0e1
--- /dev/null
+++ b/leetcode/leetcode/1491-average-salary-excluding-the-minimum-and-maximum-salary/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/average-salary-excluding-the-minimum-and-maximum-salary/">1491. Average Salary Excluding the Minimum and Maximum Salary</a></h2><h3>Easy</h3><hr><div><p>You are given an array of <strong>unique</strong> integers <code>salary</code> where <code>salary[i]</code> is the salary of the <code>i<sup>th</sup></code> employee.</p>
+
+<p>Return <em>the average salary of employees excluding the minimum and maximum salary</em>. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> salary = [4000,3000,1000,2000]
+<strong>Output:</strong> 2500.00000
+<strong>Explanation:</strong> Minimum salary and maximum salary are 1000 and 4000 respectively.
+Average salary excluding minimum and maximum salary is (2000+3000) / 2 = 2500
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> salary = [1000,2000,3000]
+<strong>Output:</strong> 2000.00000
+<strong>Explanation:</strong> Minimum salary and maximum salary are 1000 and 3000 respectively.
+Average salary excluding minimum and maximum salary is (2000) / 1 = 2000
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= salary.length &lt;= 100</code></li>
+	<li><code>1000 &lt;= salary[i] &lt;= 10<sup>6</sup></code></li>
+	<li>All the integers of <code>salary</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/1493-longest-subarray-of-1s-after-deleting-one-element.java b/leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/1493-longest-subarray-of-1s-after-deleting-one-element.java
new file mode 100644
index 0000000..eb82b53
--- /dev/null
+++ b/leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/1493-longest-subarray-of-1s-after-deleting-one-element.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int longestSubarray(int[] nums) {
+        int i = 0;
+        int j = 1;
+        int zeros = 0;
+        int lastZero = -1;
+        int max = 0;
+        if(nums[i] == 0){
+            lastZero = i;
+            zeros++;
+        }
+        while(j<nums.length){
+            if(nums[j] == 0){
+                zeros++;
+                if(lastZero == -1) lastZero = j;
+            }
+            if(zeros<2){
+                max = Math.max(max,j - i);
+            }else{
+                zeros = 1;
+                i = lastZero+1;
+                lastZero = j;
+            }
+            j++;
+        }
+        return max;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/NOTES.md b/leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/README.md b/leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/README.md
new file mode 100644
index 0000000..d288233
--- /dev/null
+++ b/leetcode/leetcode/1493-longest-subarray-of-1s-after-deleting-one-element/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/longest-subarray-of-1s-after-deleting-one-element/">1493. Longest Subarray of 1's After Deleting One Element</a></h2><h3>Medium</h3><hr><div><p>Given a binary array <code>nums</code>, you should delete one element from it.</p>
+
+<p>Return <em>the size of the longest non-empty subarray containing only </em><code>1</code><em>'s in the resulting array</em>. Return <code>0</code> if there is no such subarray.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,0,1]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> After deleting the number in position 2, [1,1,1] contains 3 numbers with value of 1's.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1,1,1,0,1,1,0,1]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> After deleting the number in position 4, [0,1,1,1,1,1,0,1] longest subarray with value of 1's is [1,1,1,1,1].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> You must delete one element.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/1497-check-if-array-pairs-are-divisible-by-k.java b/leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/1497-check-if-array-pairs-are-divisible-by-k.java
new file mode 100644
index 0000000..e39da2d
--- /dev/null
+++ b/leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/1497-check-if-array-pairs-are-divisible-by-k.java
@@ -0,0 +1,19 @@
+class Solution {
+    public boolean canArrange(int[] arr, int k) {
+        int[] freq = new int[k];
+        for(int num: arr){
+            freq[Math.abs((num%k) + k)%k]++;
+        }
+        if(freq[0]%2!=0) return false;
+        for(int i = 1;i<=k/2;i++){
+            if(i == k - i){
+                if(freq[i]%2!=0) return false;
+            }
+            if(freq[i] != freq[k - i]){
+                return false;
+            } 
+        
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/NOTES.md b/leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/README.md b/leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/README.md
new file mode 100644
index 0000000..9a39585
--- /dev/null
+++ b/leetcode/leetcode/1497-check-if-array-pairs-are-divisible-by-k/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/check-if-array-pairs-are-divisible-by-k/">1497. Check If Array Pairs Are Divisible by k</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>arr</code> of even length <code>n</code> and an integer <code>k</code>.</p>
+
+<p>We want to divide the array into exactly <code>n / 2</code> pairs such that the sum of each pair is divisible by <code>k</code>.</p>
+
+<p>Return <code>true</code><em> If you can find a way to do that or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,3,4,5,10,6,7,8,9], k = 5
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Pairs are (1,9),(2,8),(3,7),(4,6) and (5,10).
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,3,4,5,6], k = 7
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Pairs are (1,6),(2,5) and(3,4).
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,3,4,5,6], k = 10
+<strong>Output:</strong> false
+<strong>Explanation:</strong> You can try all possible pairs to see that there is no way to divide arr into 3 pairs each with sum divisible by 10.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>arr.length == n</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>n</code> is even.</li>
+	<li><code>-10<sup>9</sup> &lt;= arr[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/150-evaluate-reverse-polish-notation/150-evaluate-reverse-polish-notation.java b/leetcode/leetcode/150-evaluate-reverse-polish-notation/150-evaluate-reverse-polish-notation.java
new file mode 100644
index 0000000..4f3d71b
--- /dev/null
+++ b/leetcode/leetcode/150-evaluate-reverse-polish-notation/150-evaluate-reverse-polish-notation.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int evalRPN(String[] tokens) {
+        Stack<Integer> s = new Stack<>();
+        for(String t: tokens){
+            if(t.equals("+")){
+                s.push(s.pop() + s.pop());
+            }else if(t.equals("-")){
+                int first = s.pop();
+                s.push(s.pop() - first);                
+            }else if(t.equals("/")){
+                int first = s.pop();
+                s.push(s.pop()/first);
+            }else if(t.equals("*")){
+                s.push(s.pop() * s.pop());
+                
+            }else{
+                s.push(Integer.parseInt(t));
+            }
+        }
+        return s.pop();
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/150-evaluate-reverse-polish-notation/NOTES.md b/leetcode/leetcode/150-evaluate-reverse-polish-notation/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/150-evaluate-reverse-polish-notation/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/150-evaluate-reverse-polish-notation/README.md b/leetcode/leetcode/150-evaluate-reverse-polish-notation/README.md
new file mode 100644
index 0000000..4d48da6
--- /dev/null
+++ b/leetcode/leetcode/150-evaluate-reverse-polish-notation/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/evaluate-reverse-polish-notation/">150. Evaluate Reverse Polish Notation</a></h2><h3>Medium</h3><hr><div><p>Evaluate the value of an arithmetic expression in <a href="http://en.wikipedia.org/wiki/Reverse_Polish_notation" target="_blank">Reverse Polish Notation</a>.</p>
+
+<p>Valid operators are <code>+</code>, <code>-</code>, <code>*</code>, and <code>/</code>. Each operand may be an integer or another expression.</p>
+
+<p><strong>Note</strong> that division between two integers should truncate toward zero.</p>
+
+<p>It is guaranteed that the given RPN expression is always valid. That means the expression would always evaluate to a result, and there will not be any division by zero operation.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> tokens = ["2","1","+","3","*"]
+<strong>Output:</strong> 9
+<strong>Explanation:</strong> ((2 + 1) * 3) = 9
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> tokens = ["4","13","5","/","+"]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> (4 + (13 / 5)) = 6
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
+<strong>Output:</strong> 22
+<strong>Explanation:</strong> ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
+= ((10 * (6 / (12 * -11))) + 17) + 5
+= ((10 * (6 / -132)) + 17) + 5
+= ((10 * 0) + 17) + 5
+= (0 + 17) + 5
+= 17 + 5
+= 22
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= tokens.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>tokens[i]</code> is either an operator: <code>"+"</code>, <code>"-"</code>, <code>"*"</code>, or <code>"/"</code>, or an integer in the range <code>[-200, 200]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/1508-range-sum-of-sorted-subarray-sums.java b/leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/1508-range-sum-of-sorted-subarray-sums.java
new file mode 100644
index 0000000..944d94b
--- /dev/null
+++ b/leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/1508-range-sum-of-sorted-subarray-sums.java
@@ -0,0 +1,26 @@
+class Solution {
+    public List<Integer> subarraySum(int[] nums){
+        List<Integer> list = new ArrayList<>();
+        int sum = 0;
+        for(int j = 0;j<nums.length;j++){
+            sum = 0;
+            for(int i = j;i<nums.length;i++){
+                sum+=nums[i];
+                list.add(sum);
+            }
+        }
+        return list;
+        
+    }
+    public int rangeSum(int[] nums, int n, int left, int right) {
+        List<Integer> list = subarraySum(nums);
+        Collections.sort(list);
+        long ans = 0;
+        int mod =(int) 1e9+7;
+        for(int i = left-1;i<right;i++){
+            ans= (ans + list.get(i))%mod;
+        }
+        return (int) ans;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/NOTES.md b/leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/README.md b/leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/README.md
new file mode 100644
index 0000000..3562ccc
--- /dev/null
+++ b/leetcode/leetcode/1508-range-sum-of-sorted-subarray-sums/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/range-sum-of-sorted-subarray-sums/">1508. Range Sum of Sorted Subarray Sums</a></h2><h3>Medium</h3><hr><div><p>You are given the array <code>nums</code> consisting of <code>n</code> positive integers. You computed the sum of all non-empty continuous subarrays from the array and then sorted them in non-decreasing order, creating a new array of <code>n * (n + 1) / 2</code> numbers.</p>
+
+<p><em>Return the sum of the numbers from index </em><code>left</code><em> to index </em><code>right</code> (<strong>indexed from 1</strong>)<em>, inclusive, in the new array. </em>Since the answer can be a huge number return it modulo <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4], n = 4, left = 1, right = 5
+<strong>Output:</strong> 13 
+<strong>Explanation:</strong> All subarray sums are 1, 3, 6, 10, 2, 5, 9, 3, 7, 4. After sorting them in non-decreasing order we have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 1 to ri = 5 is 1 + 2 + 3 + 3 + 4 = 13. 
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4], n = 4, left = 3, right = 4
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The given array is the same as example 1. We have the new array [1, 2, 3, 3, 4, 5, 6, 7, 9, 10]. The sum of the numbers from index le = 3 to ri = 4 is 3 + 3 = 6.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4], n = 4, left = 1, right = 10
+<strong>Output:</strong> 50
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
+	<li><code>1 &lt;= left &lt;= right &lt;= n * (n + 1) / 2</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves.java b/leetcode/leetcode/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves.java
new file mode 100644
index 0000000..3079811
--- /dev/null
+++ b/leetcode/leetcode/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int minDifference(int[] nums) {
+        if(nums.length<=3) return 0;
+        int n = nums.length;
+        Arrays.sort(nums);
+        int minDiff = Integer.MAX_VALUE;
+        for (int left = 0, right = n - 4; left < 4; left++, right++) {
+            minDiff = Math.min(minDiff, nums[right] - nums[left]);
+        }
+        return minDiff;
+    }
+}
diff --git a/leetcode/leetcode/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves/NOTES.md b/leetcode/leetcode/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1509-replace-employee-id-with-the-unique-identifier/1509-replace-employee-id-with-the-unique-identifier.sql b/leetcode/leetcode/1509-replace-employee-id-with-the-unique-identifier/1509-replace-employee-id-with-the-unique-identifier.sql
new file mode 100644
index 0000000..645ce2a
--- /dev/null
+++ b/leetcode/leetcode/1509-replace-employee-id-with-the-unique-identifier/1509-replace-employee-id-with-the-unique-identifier.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT unique_id, name FROM Employees LEFT JOIN EmployeeUNI ON Employees.id=EmployeeUNI.id;
\ No newline at end of file
diff --git a/leetcode/leetcode/1509-replace-employee-id-with-the-unique-identifier/README.md b/leetcode/leetcode/1509-replace-employee-id-with-the-unique-identifier/README.md
new file mode 100644
index 0000000..cdf2476
--- /dev/null
+++ b/leetcode/leetcode/1509-replace-employee-id-with-the-unique-identifier/README.md
@@ -0,0 +1,75 @@
+<h2><a href="https://leetcode.com/problems/replace-employee-id-with-the-unique-identifier">1509. Replace Employee ID With The Unique Identifier</a></h2><h3>Easy</h3><hr><p>Table: <code>Employees</code></p>
+
+<pre>
++---------------+---------+
+| Column Name   | Type    |
++---------------+---------+
+| id            | int     |
+| name          | varchar |
++---------------+---------+
+id is the primary key (column with unique values) for this table.
+Each row of this table contains the id and the name of an employee in a company.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Table: <code>EmployeeUNI</code></p>
+
+<pre>
++---------------+---------+
+| Column Name   | Type    |
++---------------+---------+
+| id            | int     |
+| unique_id     | int     |
++---------------+---------+
+(id, unique_id) is the primary key (combination of columns with unique values) for this table.
+Each row of this table contains the id and the corresponding unique id of an employee in the company.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write a solution to show the <strong>unique ID </strong>of each user, If a user does not have a unique ID replace just show <code>null</code>.</p>
+
+<p>Return the result table in <strong>any</strong> order.</p>
+
+<p>The result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> 
+Employees table:
++----+----------+
+| id | name     |
++----+----------+
+| 1  | Alice    |
+| 7  | Bob      |
+| 11 | Meir     |
+| 90 | Winston  |
+| 3  | Jonathan |
++----+----------+
+EmployeeUNI table:
++----+-----------+
+| id | unique_id |
++----+-----------+
+| 3  | 1         |
+| 11 | 2         |
+| 90 | 3         |
++----+-----------+
+<strong>Output:</strong> 
++-----------+----------+
+| unique_id | name     |
++-----------+----------+
+| null      | Alice    |
+| null      | Bob      |
+| 2         | Meir     |
+| 3         | Winston  |
+| 1         | Jonathan |
++-----------+----------+
+<strong>Explanation:</strong> 
+Alice and Bob do not have a unique ID, We will show null instead.
+The unique ID of Meir is 2.
+The unique ID of Winston is 3.
+The unique ID of Jonathan is 1.
+</pre>
diff --git a/leetcode/leetcode/1518-water-bottles/1518-water-bottles.java b/leetcode/leetcode/1518-water-bottles/1518-water-bottles.java
new file mode 100644
index 0000000..d8190a0
--- /dev/null
+++ b/leetcode/leetcode/1518-water-bottles/1518-water-bottles.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int numWaterBottles(int numBottles, int numExchange) {
+        int ans = numBottles;
+        while(numBottles>= numExchange){
+            int filledBottleAfterExchange = numBottles / numExchange;
+            int leftEmptyBottles          = numBottles % numExchange;
+            ans+=filledBottleAfterExchange;
+            numBottles = leftEmptyBottles + filledBottleAfterExchange;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1518-water-bottles/NOTES.md b/leetcode/leetcode/1518-water-bottles/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1518-water-bottles/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1518-water-bottles/README.md b/leetcode/leetcode/1518-water-bottles/README.md
new file mode 100644
index 0000000..cb5e9b9
--- /dev/null
+++ b/leetcode/leetcode/1518-water-bottles/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/water-bottles/">1518. Water Bottles</a></h2><h3>Easy</h3><hr><div><p>There are <code>numBottles</code> water bottles that are initially full of water. You can exchange <code>numExchange</code> empty water bottles from the market with one full water bottle.</p>
+
+<p>The operation of drinking a full water bottle turns it into an empty bottle.</p>
+
+<p>Given the two integers <code>numBottles</code> and <code>numExchange</code>, return <em>the <strong>maximum</strong> number of water bottles you can drink</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/07/01/sample_1_1875.png" style="width: 500px; height: 245px;">
+<pre><strong>Input:</strong> numBottles = 9, numExchange = 3
+<strong>Output:</strong> 13
+<strong>Explanation:</strong> You can exchange 3 empty bottles to get 1 full water bottle.
+Number of water bottles you can drink: 9 + 3 + 1 = 13.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/07/01/sample_2_1875.png" style="width: 500px; height: 183px;">
+<pre><strong>Input:</strong> numBottles = 15, numExchange = 4
+<strong>Output:</strong> 19
+<strong>Explanation:</strong> You can exchange 4 empty bottles to get 1 full water bottle. 
+Number of water bottles you can drink: 15 + 3 + 1 = 19.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= numBottles &lt;= 100</code></li>
+	<li><code>2 &lt;= numExchange &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1519-number-of-nodes-in-the-sub-tree-with-the-same-label/1519-number-of-nodes-in-the-sub-tree-with-the-same-label.java b/leetcode/leetcode/1519-number-of-nodes-in-the-sub-tree-with-the-same-label/1519-number-of-nodes-in-the-sub-tree-with-the-same-label.java
new file mode 100644
index 0000000..51411d9
--- /dev/null
+++ b/leetcode/leetcode/1519-number-of-nodes-in-the-sub-tree-with-the-same-label/1519-number-of-nodes-in-the-sub-tree-with-the-same-label.java
@@ -0,0 +1,37 @@
+class Solution {
+    public int[] dfs(int node, int parent, Map<Integer, List<Integer>> adj,char[] labels, int[] ans) {
+        // Store count of all alphabets in the subtree of the node.
+        int[] nodeCounts = new int[26];
+        nodeCounts[labels[node] - 'a'] = 1;
+
+        if (!adj.containsKey(node))
+            return nodeCounts;
+        for (int child : adj.get(node)) {
+            if (child == parent) {
+                continue;
+            }
+            int[] childCounts = dfs(child, node, adj, labels, ans);
+            // Add frequencies of the child node in the parent node's frequency array.
+            for (int i = 0; i < 26; i++) {
+                nodeCounts[i] += childCounts[i];
+            }
+        }
+
+        ans[node] = nodeCounts[labels[node] - 'a'];
+        return nodeCounts;
+    }
+
+    public int[] countSubTrees(int n, int[][] edges, String labels) {
+        Map<Integer, List<Integer>> adj = new HashMap<>();
+        for (int[] edge : edges) {
+            int a = edge[0], b = edge[1];
+            adj.computeIfAbsent(a, value -> new ArrayList<Integer>()).add(b);
+            adj.computeIfAbsent(b, value -> new ArrayList<Integer>()).add(a);
+        }
+
+        int[] ans = new int[n];
+        char[] label = labels.toCharArray();
+        dfs(0, -1, adj, label, ans);
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1519-number-of-nodes-in-the-sub-tree-with-the-same-label/NOTES.md b/leetcode/leetcode/1519-number-of-nodes-in-the-sub-tree-with-the-same-label/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1519-number-of-nodes-in-the-sub-tree-with-the-same-label/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/155-min-stack/155-min-stack.java b/leetcode/leetcode/155-min-stack/155-min-stack.java
new file mode 100644
index 0000000..6c1a9b4
--- /dev/null
+++ b/leetcode/leetcode/155-min-stack/155-min-stack.java
@@ -0,0 +1,47 @@
+class MinStack {
+    class Node{
+        int min;
+        int val;
+        Node next;
+        Node(){}
+        Node(int val, int min, Node next){
+            this.val = val;
+            this.min = min;
+            this.next = next;
+        }
+    }
+    Node head;
+    public MinStack() {
+        head = null;
+    }
+    
+    public void push(int val) {
+        if(head == null){
+            head = new Node(val,val,null);
+        }else{
+            Node temp = new Node(val,Math.min(val,head.min),head);
+            head = temp;    
+        }
+    }
+    
+    public void pop() {
+        head = head.next;
+    }
+    
+    public int top() {
+        return head.val;
+    }
+    
+    public int getMin() {
+        return head.min;
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack obj = new MinStack();
+ * obj.push(val);
+ * obj.pop();
+ * int param_3 = obj.top();
+ * int param_4 = obj.getMin();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/155-min-stack/NOTES.md b/leetcode/leetcode/155-min-stack/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/155-min-stack/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/155-min-stack/README.md b/leetcode/leetcode/155-min-stack/README.md
new file mode 100644
index 0000000..a6f1991
--- /dev/null
+++ b/leetcode/leetcode/155-min-stack/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/min-stack/">155. Min Stack</a></h2><h3>Easy</h3><hr><div><p>Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.</p>
+
+<p>Implement the <code>MinStack</code> class:</p>
+
+<ul>
+	<li><code>MinStack()</code> initializes the stack object.</li>
+	<li><code>void push(int val)</code> pushes the element <code>val</code> onto the stack.</li>
+	<li><code>void pop()</code> removes the element on the top of the stack.</li>
+	<li><code>int top()</code> gets the top element of the stack.</li>
+	<li><code>int getMin()</code> retrieves the minimum element in the stack.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["MinStack","push","push","push","getMin","pop","top","getMin"]
+[[],[-2],[0],[-3],[],[],[],[]]
+
+<strong>Output</strong>
+[null,null,null,null,-3,null,0,-2]
+
+<strong>Explanation</strong>
+MinStack minStack = new MinStack();
+minStack.push(-2);
+minStack.push(0);
+minStack.push(-3);
+minStack.getMin(); // return -3
+minStack.pop();
+minStack.top();    // return 0
+minStack.getMin(); // return -2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= val &lt;= 2<sup>31</sup> - 1</code></li>
+	<li>Methods <code>pop</code>, <code>top</code> and <code>getMin</code> operations will always be called on <strong>non-empty</strong> stacks.</li>
+	<li>At most <code>3 * 10<sup>4</sup></code> calls will be made to <code>push</code>, <code>pop</code>, <code>top</code>, and <code>getMin</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1550-three-consecutive-odds/1550-three-consecutive-odds.java b/leetcode/leetcode/1550-three-consecutive-odds/1550-three-consecutive-odds.java
new file mode 100644
index 0000000..38c68fa
--- /dev/null
+++ b/leetcode/leetcode/1550-three-consecutive-odds/1550-three-consecutive-odds.java
@@ -0,0 +1,17 @@
+class Solution {
+    public boolean threeConsecutiveOdds(int[] arr) {
+        for(int i = 0;i<arr.length-2;i++){
+            if(arr[i]%2!=0){
+                if(arr[i+1]%2!=0){
+                    if(arr[i+2]%2!=0){
+                        return true;
+                    }else i+=2;
+                }else{
+                    i++;
+                }
+            }
+        }
+        return false;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1550-three-consecutive-odds/NOTES.md b/leetcode/leetcode/1550-three-consecutive-odds/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1550-three-consecutive-odds/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1550-three-consecutive-odds/README.md b/leetcode/leetcode/1550-three-consecutive-odds/README.md
new file mode 100644
index 0000000..898856b
--- /dev/null
+++ b/leetcode/leetcode/1550-three-consecutive-odds/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/three-consecutive-odds/">1550. Three Consecutive Odds</a></h2><h3>Easy</h3><hr><div>Given an integer array <code>arr</code>, return <code>true</code>&nbsp;if there are three consecutive odd numbers in the array. Otherwise, return&nbsp;<code>false</code>.
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [2,6,4,1]
+<strong>Output:</strong> false
+<b>Explanation:</b> There are no three consecutive odds.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,34,3,4,5,7,23,12]
+<strong>Output:</strong> true
+<b>Explanation:</b> [5,7,23] are three consecutive odds.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1582-special-positions-in-a-binary-matrix/1582-special-positions-in-a-binary-matrix.java b/leetcode/leetcode/1582-special-positions-in-a-binary-matrix/1582-special-positions-in-a-binary-matrix.java
new file mode 100644
index 0000000..85e28d4
--- /dev/null
+++ b/leetcode/leetcode/1582-special-positions-in-a-binary-matrix/1582-special-positions-in-a-binary-matrix.java
@@ -0,0 +1,25 @@
+class Solution {
+    public int numSpecial(int[][] mat) {
+        int[] row = new int[mat.length];
+        int[] col = new int[mat[0].length];
+        for(int i = 0;i<mat.length;i++){
+            for(int j = 0;j<mat[0].length;j++){
+                if(mat[i][j] == 1){
+                    row[i]++;
+                    col[j]++;
+                }
+            }
+        }
+        int ans = 0;
+        for(int i =0;i<mat.length;i++){
+            for(int j = 0;j<mat[0].length;j++){
+                if(mat[i][j]==1){
+                    if(row[i] == 1 && col[j] == 1){
+                        ans++;
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1582-special-positions-in-a-binary-matrix/NOTES.md b/leetcode/leetcode/1582-special-positions-in-a-binary-matrix/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1582-special-positions-in-a-binary-matrix/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1582-special-positions-in-a-binary-matrix/README.md b/leetcode/leetcode/1582-special-positions-in-a-binary-matrix/README.md
new file mode 100644
index 0000000..c973d91
--- /dev/null
+++ b/leetcode/leetcode/1582-special-positions-in-a-binary-matrix/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/special-positions-in-a-binary-matrix/">1582. Special Positions in a Binary Matrix</a></h2><h3>Easy</h3><hr><div><p>Given an <code>m x n</code> binary matrix <code>mat</code>, return <em>the number of special positions in </em><code>mat</code><em>.</em></p>
+
+<p>A position <code>(i, j)</code> is called <strong>special</strong> if <code>mat[i][j] == 1</code> and all other elements in row <code>i</code> and column <code>j</code> are <code>0</code> (rows and columns are <strong>0-indexed</strong>).</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/23/special1.jpg" style="width: 244px; height: 245px;">
+<pre><strong>Input:</strong> mat = [[1,0,0],[0,0,1],[1,0,0]]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> (1, 2) is a special position because mat[1][2] == 1 and all other elements in row 1 and column 2 are 0.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/24/special-grid.jpg" style="width: 244px; height: 245px;">
+<pre><strong>Input:</strong> mat = [[1,0,0],[0,1,0],[0,0,1]]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> (0, 0), (1, 1) and (2, 2) are special positions.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == mat.length</code></li>
+	<li><code>n == mat[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 100</code></li>
+	<li><code>mat[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1598-crawler-log-folder/1598-crawler-log-folder.java b/leetcode/leetcode/1598-crawler-log-folder/1598-crawler-log-folder.java
new file mode 100644
index 0000000..606d6d9
--- /dev/null
+++ b/leetcode/leetcode/1598-crawler-log-folder/1598-crawler-log-folder.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int minOperations(String[] logs) {
+        int ans = 0;
+        for(int i=0;i<logs.length;i++){
+            if(logs[i].equals("./")){
+                continue;
+            }else if(logs[i].equals("../")){
+                ans--;
+                ans = Math.max(0,ans);
+            }else{
+                ans++;
+            }
+           
+        }
+         return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1598-crawler-log-folder/NOTES.md b/leetcode/leetcode/1598-crawler-log-folder/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1598-crawler-log-folder/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1598-crawler-log-folder/README.md b/leetcode/leetcode/1598-crawler-log-folder/README.md
new file mode 100644
index 0000000..09137a6
--- /dev/null
+++ b/leetcode/leetcode/1598-crawler-log-folder/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/crawler-log-folder/">1598. Crawler Log Folder</a></h2><h3>Easy</h3><hr><div><p>The Leetcode file system keeps a log each time some user performs a <em>change folder</em> operation.</p>
+
+<p>The operations are described below:</p>
+
+<ul>
+	<li><code>"../"</code> : Move to the parent folder of the current folder. (If you are already in the main folder, <strong>remain in the same folder</strong>).</li>
+	<li><code>"./"</code> : Remain in the same folder.</li>
+	<li><code>"x/"</code> : Move to the child folder named <code>x</code> (This folder is <strong>guaranteed to always exist</strong>).</li>
+</ul>
+
+<p>You are given a list of strings <code>logs</code> where <code>logs[i]</code> is the operation performed by the user at the <code>i<sup>th</sup></code> step.</p>
+
+<p>The file system starts in the main folder, then the operations in <code>logs</code> are performed.</p>
+
+<p>Return <em>the minimum number of operations needed to go back to the main folder after the change folder operations.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2020/09/09/sample_11_1957.png" style="width: 775px; height: 151px;"></p>
+
+<pre><strong>Input:</strong> logs = ["d1/","d2/","../","d21/","./"]
+<strong>Output:</strong> 2
+<strong>Explanation: </strong>Use this change folder operation "../" 2 times and go back to the main folder.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2020/09/09/sample_22_1957.png" style="width: 600px; height: 270px;"></p>
+
+<pre><strong>Input:</strong> logs = ["d1/","d2/","./","d3/","../","d31/"]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> logs = ["d1/","../","../","../"]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= logs.length &lt;= 10<sup>3</sup></code></li>
+	<li><code>2 &lt;= logs[i].length &lt;= 10</code></li>
+	<li><code>logs[i]</code> contains lowercase English letters, digits, <code>'.'</code>, and <code>'/'</code>.</li>
+	<li><code>logs[i]</code> follows the format described in the statement.</li>
+	<li>Folder names consist of lowercase English letters and digits.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/160-intersection-of-two-linked-lists/160-intersection-of-two-linked-lists.java b/leetcode/leetcode/160-intersection-of-two-linked-lists/160-intersection-of-two-linked-lists.java
new file mode 100644
index 0000000..d5f05c3
--- /dev/null
+++ b/leetcode/leetcode/160-intersection-of-two-linked-lists/160-intersection-of-two-linked-lists.java
@@ -0,0 +1,42 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public int size(ListNode head){
+        ListNode temp = head;
+        int counter = 0;
+        while(temp!=null){
+            temp = temp.next;
+            counter++;
+        }
+        return counter;
+    }
+    public ListNode nthNode(ListNode head, int n){
+        ListNode temp = head;
+        while(n--!=0) temp = temp.next;
+        return temp;
+    }
+    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+        int size1 =size(headA);
+        int size2 =size(headB);
+        int common = Math.abs(size1-size2);
+        if(size1>size2) headA = nthNode(headA,common);
+        else if(size2>size1) headB = nthNode(headB,common);
+        if(headA == headB) return headA;
+        while(headA!=null && headB!=null){
+            headA = headA.next;
+            headB = headB.next;
+            if(headA == headB) return headA;
+        }
+        
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/160-intersection-of-two-linked-lists/NOTES.md b/leetcode/leetcode/160-intersection-of-two-linked-lists/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/160-intersection-of-two-linked-lists/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1609-even-odd-tree/1609-even-odd-tree.java b/leetcode/leetcode/1609-even-odd-tree/1609-even-odd-tree.java
new file mode 100644
index 0000000..77b5231
--- /dev/null
+++ b/leetcode/leetcode/1609-even-odd-tree/1609-even-odd-tree.java
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isEvenOddTree(TreeNode root) {
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+        int level = 0;
+        while(!q.isEmpty()){
+            int prev = 0;
+            if(level%2 == 0){
+                for(int i = q.size();i!=0;i--){
+                    TreeNode front = q.remove();
+                    if(front.val%2!=0 && front.val>prev){
+                        prev = front.val;
+                    }else return false;
+                    if(front.left!=null) q.add(front.left);
+                    if(front.right!=null) q.add(front.right);
+                }        
+            }else{
+                 prev = Integer.MAX_VALUE;
+                 for(int i = q.size();i!=0;i--){
+                    TreeNode front = q.remove();
+                    if(front.val%2==0 && front.val<prev){
+                        prev = front.val;
+                    }else return false;
+                     
+                    if(front.left!=null) q.add(front.left);
+                    if(front.right!=null) q.add(front.right);
+                }   
+            }
+            level++;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1609-even-odd-tree/NOTES.md b/leetcode/leetcode/1609-even-odd-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1609-even-odd-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1609-even-odd-tree/README.md b/leetcode/leetcode/1609-even-odd-tree/README.md
new file mode 100644
index 0000000..0cf3fbb
--- /dev/null
+++ b/leetcode/leetcode/1609-even-odd-tree/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/even-odd-tree/">1609. Even Odd Tree</a></h2><h3>Medium</h3><hr><div><p>A binary tree is named <strong>Even-Odd</strong> if it meets the following conditions:</p>
+
+<ul>
+	<li>The root of the binary tree is at level index <code>0</code>, its children are at level index <code>1</code>, their children are at level index <code>2</code>, etc.</li>
+	<li>For every <strong>even-indexed</strong> level, all nodes at the level have <strong>odd</strong> integer values in <strong>strictly increasing</strong> order (from left to right).</li>
+	<li>For every <b>odd-indexed</b> level, all nodes at the level have <b>even</b> integer values in <strong>strictly decreasing</strong> order (from left to right).</li>
+</ul>
+
+<p>Given the <code>root</code> of a binary tree, <em>return </em><code>true</code><em> if the binary tree is <strong>Even-Odd</strong>, otherwise return </em><code>false</code><em>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/sample_1_1966.png" style="width: 362px; height: 229px;">
+<pre><strong>Input:</strong> root = [1,10,4,3,null,7,9,12,8,6,null,null,2]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The node values on each level are:
+Level 0: [1]
+Level 1: [10,4]
+Level 2: [3,7,9]
+Level 3: [12,8,6,2]
+Since levels 0 and 2 are all odd and increasing and levels 1 and 3 are all even and decreasing, the tree is Even-Odd.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/sample_2_1966.png" style="width: 363px; height: 167px;">
+<pre><strong>Input:</strong> root = [5,4,2,3,3,7]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The node values on each level are:
+Level 0: [5]
+Level 1: [4,2]
+Level 2: [3,3,7]
+Node values in level 2 must be in strictly increasing order, so the tree is not Even-Odd.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/22/sample_1_333_1966.png" style="width: 363px; height: 167px;">
+<pre><strong>Input:</strong> root = [5,9,1,3,5,7]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Node values in the level 1 should be even integers.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/162-find-peak-element/162-find-peak-element.java b/leetcode/leetcode/162-find-peak-element/162-find-peak-element.java
new file mode 100644
index 0000000..f017a71
--- /dev/null
+++ b/leetcode/leetcode/162-find-peak-element/162-find-peak-element.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int findPeakElement(int[] nums) {
+        if(nums.length == 1) return 0;
+        int low = 0;
+        int high = nums.length -1;
+        while(low<high){
+            int mid = (low+high)/2;
+            if(nums[mid]>nums[mid+1]){
+                high = mid;
+            }else
+                low = mid+1;
+            }
+        return low;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/162-find-peak-element/NOTES.md b/leetcode/leetcode/162-find-peak-element/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/162-find-peak-element/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/162-find-peak-element/README.md b/leetcode/leetcode/162-find-peak-element/README.md
new file mode 100644
index 0000000..96d085a
--- /dev/null
+++ b/leetcode/leetcode/162-find-peak-element/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/find-peak-element/">162. Find Peak Element</a></h2><h3>Medium</h3><hr><div><p>A peak element is an element that is strictly greater than its neighbors.</p>
+
+<p>Given an integer array <code>nums</code>, find a peak element, and return its index. If&nbsp;the array contains multiple peaks, return the index to <strong>any of the peaks</strong>.</p>
+
+<p>You may imagine that <code>nums[-1] = nums[n] = -∞</code>.</p>
+
+<p>You must write an algorithm that runs in&nbsp;<code>O(log n)</code> time.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 3 is a peak element and your function should return the index number 2.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,1,3,5,6,4]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> Your function can return either index number 1 where the peak element is 2, or index number 5 where the peak element is 6.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>nums[i] != nums[i + 1]</code> for all valid <code>i</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1631-number-of-sub-arrays-with-odd-sum/1631-number-of-sub-arrays-with-odd-sum.java b/leetcode/leetcode/1631-number-of-sub-arrays-with-odd-sum/1631-number-of-sub-arrays-with-odd-sum.java
new file mode 100644
index 0000000..b4d29e2
--- /dev/null
+++ b/leetcode/leetcode/1631-number-of-sub-arrays-with-odd-sum/1631-number-of-sub-arrays-with-odd-sum.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int numOfSubarrays(int[] arr) {
+        int count = 0;
+        int evenCount = 1;
+        int oddCount  = 0;
+        long prefixSum = 0;
+        for(int i = 0;i<arr.length;i++){
+            prefixSum+=arr[i];
+            if(prefixSum % 2 == 0){
+                count+=(oddCount);
+                
+                evenCount++;
+            }else{
+                count+=(evenCount);
+                oddCount++;
+            }
+            count = count % 1000000007;
+        }
+        return count;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1631-number-of-sub-arrays-with-odd-sum/README.md b/leetcode/leetcode/1631-number-of-sub-arrays-with-odd-sum/README.md
new file mode 100644
index 0000000..2e2bb66
--- /dev/null
+++ b/leetcode/leetcode/1631-number-of-sub-arrays-with-odd-sum/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/number-of-sub-arrays-with-odd-sum">1631. Number of Sub-arrays With Odd Sum</a></h2><h3>Medium</h3><hr><p>Given an array of integers <code>arr</code>, return <em>the number of subarrays with an <strong>odd</strong> sum</em>.</p>
+
+<p>Since the answer can be very large, return it modulo <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> arr = [1,3,5]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> All subarrays are [[1],[1,3],[1,3,5],[3],[3,5],[5]]
+All sub-arrays sum are [1,4,9,3,8,5].
+Odd sums are [1,9,3,5] so the answer is 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> arr = [2,4,6]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> All subarrays are [[2],[2,4],[2,4,6],[4],[4,6],[6]]
+All sub-arrays sum are [2,6,12,4,10,6].
+All sub-arrays have even sum and the answer is 0.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> arr = [1,2,3,4,5,6,7]
+<strong>Output:</strong> 16
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/1642-water-bottles/1642-water-bottles.java b/leetcode/leetcode/1642-water-bottles/1642-water-bottles.java
new file mode 100644
index 0000000..d8190a0
--- /dev/null
+++ b/leetcode/leetcode/1642-water-bottles/1642-water-bottles.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int numWaterBottles(int numBottles, int numExchange) {
+        int ans = numBottles;
+        while(numBottles>= numExchange){
+            int filledBottleAfterExchange = numBottles / numExchange;
+            int leftEmptyBottles          = numBottles % numExchange;
+            ans+=filledBottleAfterExchange;
+            numBottles = leftEmptyBottles + filledBottleAfterExchange;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1642-water-bottles/README.md b/leetcode/leetcode/1642-water-bottles/README.md
new file mode 100644
index 0000000..68f50f8
--- /dev/null
+++ b/leetcode/leetcode/1642-water-bottles/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/water-bottles">1642. Water Bottles</a></h2><h3>Easy</h3><hr><p>There are <code>numBottles</code> water bottles that are initially full of water. You can exchange <code>numExchange</code> empty water bottles from the market with one full water bottle.</p>
+
+<p>The operation of drinking a full water bottle turns it into an empty bottle.</p>
+
+<p>Given the two integers <code>numBottles</code> and <code>numExchange</code>, return <em>the <strong>maximum</strong> number of water bottles you can drink</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/07/01/sample_1_1875.png" style="width: 500px; height: 245px;" />
+<pre>
+<strong>Input:</strong> numBottles = 9, numExchange = 3
+<strong>Output:</strong> 13
+<strong>Explanation:</strong> You can exchange 3 empty bottles to get 1 full water bottle.
+Number of water bottles you can drink: 9 + 3 + 1 = 13.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/07/01/sample_2_1875.png" style="width: 500px; height: 183px;" />
+<pre>
+<strong>Input:</strong> numBottles = 15, numExchange = 4
+<strong>Output:</strong> 19
+<strong>Explanation:</strong> You can exchange 4 empty bottles to get 1 full water bottle. 
+Number of water bottles you can drink: 15 + 3 + 1 = 19.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= numBottles &lt;= 100</code></li>
+	<li><code>2 &lt;= numExchange &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/1652-minimum-suffix-flips/1652-minimum-suffix-flips.py b/leetcode/leetcode/1652-minimum-suffix-flips/1652-minimum-suffix-flips.py
new file mode 100644
index 0000000..5b3f348
--- /dev/null
+++ b/leetcode/leetcode/1652-minimum-suffix-flips/1652-minimum-suffix-flips.py
@@ -0,0 +1,22 @@
+class Solution:
+    # def flip(self,s, index):
+    #     for i in range(index,len(s)):
+    #         if(s[i] == 0):
+    #             s[i] = 1
+    #         else:
+    #             s[i] = 0
+    #     return s
+    def minFlips(self, target: str) -> int:
+        ans = 0
+        n = len(target)
+        # s = [0]*n
+        bit = 0
+        for i in range(n):
+            if(int(target[i]) != bit):
+                ans+=1
+                # bit = (bit +1)%2
+                if(bit == 0):
+                    bit = 1
+                else:
+                    bit = 0
+        return ans
diff --git a/leetcode/leetcode/1652-minimum-suffix-flips/README.md b/leetcode/leetcode/1652-minimum-suffix-flips/README.md
new file mode 100644
index 0000000..ff4871e
--- /dev/null
+++ b/leetcode/leetcode/1652-minimum-suffix-flips/README.md
@@ -0,0 +1,47 @@
+<h2><a href="https://leetcode.com/problems/minimum-suffix-flips">1652. Minimum Suffix Flips</a></h2><h3>Medium</h3><hr><p>You are given a <strong>0-indexed</strong> binary string <code>target</code> of length <code>n</code>. You have another binary string <code>s</code> of length <code>n</code> that is initially set to all zeros. You want to make <code>s</code> equal to <code>target</code>.</p>
+
+<p>In one operation, you can pick an index <code>i</code> where <code>0 &lt;= i &lt; n</code> and flip all bits in the <strong>inclusive</strong> range <code>[i, n - 1]</code>. Flip means changing <code>&#39;0&#39;</code> to <code>&#39;1&#39;</code> and <code>&#39;1&#39;</code> to <code>&#39;0&#39;</code>.</p>
+
+<p>Return <em>the minimum number of operations needed to make </em><code>s</code><em> equal to </em><code>target</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> target = &quot;10111&quot;
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Initially, s = &quot;00000&quot;.
+Choose index i = 2: &quot;00<u>000</u>&quot; -&gt; &quot;00<u>111</u>&quot;
+Choose index i = 0: &quot;<u>00111</u>&quot; -&gt; &quot;<u>11000</u>&quot;
+Choose index i = 1: &quot;1<u>1000</u>&quot; -&gt; &quot;1<u>0111</u>&quot;
+We need at least 3 flip operations to form target.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> target = &quot;101&quot;
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Initially, s = &quot;000&quot;.
+Choose index i = 0: &quot;<u>000</u>&quot; -&gt; &quot;<u>111</u>&quot;
+Choose index i = 1: &quot;1<u>11</u>&quot; -&gt; &quot;1<u>00</u>&quot;
+Choose index i = 2: &quot;10<u>0</u>&quot; -&gt; &quot;10<u>1</u>&quot;
+We need at least 3 flip operations to form target.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> target = &quot;00000&quot;
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> We do not need any operations since the initial s already equals target.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == target.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>target[i]</code> is either <code>&#39;0&#39;</code> or <code>&#39;1&#39;</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/1662-check-if-two-string-arrays-are-equivalent.java b/leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/1662-check-if-two-string-arrays-are-equivalent.java
new file mode 100644
index 0000000..e108c7e
--- /dev/null
+++ b/leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/1662-check-if-two-string-arrays-are-equivalent.java
@@ -0,0 +1,23 @@
+class Solution {
+    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
+        int index1      = 0;
+        int subIndex1   = 0;
+        int index2      = 0;
+        int subIndex2   = 0;
+        while(index1!= word1.length && index2!=word2.length){
+            if(word1[index1].charAt(subIndex1++) != word2[index2].charAt(subIndex2++)){
+                return false;
+            }
+            if(subIndex1 == word1[index1].length()){
+                subIndex1 = 0;
+                index1++;
+            }
+            if(subIndex2 == word2[index2].length()){
+                subIndex2 = 0;
+                index2++;
+            }
+        }
+        return index1==word1.length && index2==word2.length;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/NOTES.md b/leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/README.md b/leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/README.md
new file mode 100644
index 0000000..da59236
--- /dev/null
+++ b/leetcode/leetcode/1662-check-if-two-string-arrays-are-equivalent/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/">1662. Check If Two String Arrays are Equivalent</a></h2><h3>Easy</h3><hr><div><p>Given two string arrays <code>word1</code> and <code>word2</code>, return<em> </em><code>true</code><em> if the two arrays <strong>represent</strong> the same string, and </em><code>false</code><em> otherwise.</em></p>
+
+<p>A string is <strong>represented</strong> by an array if the array elements concatenated <strong>in order</strong> forms the string.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> word1 = ["ab", "c"], word2 = ["a", "bc"]
+<strong>Output:</strong> true
+<strong>Explanation:</strong>
+word1 represents string "ab" + "c" -&gt; "abc"
+word2 represents string "a" + "bc" -&gt; "abc"
+The strings are the same, so return true.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> word1 = ["a", "cb"], word2 = ["ab", "c"]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> word1  = ["abc", "d", "defg"], word2 = ["abcddefg"]
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= word1.length, word2.length &lt;= 10<sup>3</sup></code></li>
+	<li><code>1 &lt;= word1[i].length, word2[i].length &lt;= 10<sup>3</sup></code></li>
+	<li><code>1 &lt;= sum(word1[i].length), sum(word2[i].length) &lt;= 10<sup>3</sup></code></li>
+	<li><code>word1[i]</code> and <code>word2[i]</code> consist of lowercase letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/167-two-sum-ii-input-array-is-sorted.java b/leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/167-two-sum-ii-input-array-is-sorted.java
new file mode 100644
index 0000000..fb3899b
--- /dev/null
+++ b/leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/167-two-sum-ii-input-array-is-sorted.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int[] twoSum(int[] arr,int target) {
+        int[] result = {-1,-1};
+        int low = 0;
+        int high = arr.length-1;
+        while(low<high){
+            if(arr[low]+arr[high]==target){
+                result[0] = low+1;
+                result[1] = high+1;
+                break;
+            }else if(arr[low]+arr[high]>target){
+                high--;
+            }else{
+                low++;
+            }
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/NOTES.md b/leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/README.md b/leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/README.md
new file mode 100644
index 0000000..535a7ac
--- /dev/null
+++ b/leetcode/leetcode/167-two-sum-ii-input-array-is-sorted/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/">167. Two Sum II - Input Array Is Sorted</a></h2><h3>Medium</h3><hr><div><p>Given a <strong>1-indexed</strong> array of integers <code>numbers</code> that is already <strong><em>sorted in non-decreasing order</em></strong>, find two numbers such that they add up to a specific <code>target</code> number. Let these two numbers be <code>numbers[index<sub>1</sub>]</code> and <code>numbers[index<sub>2</sub>]</code> where <code>1 &lt;= index<sub>1</sub> &lt; index<sub>2</sub> &lt;= numbers.length</code>.</p>
+
+<p>Return<em> the indices of the two numbers, </em><code>index<sub>1</sub></code><em> and </em><code>index<sub>2</sub></code><em>, <strong>added by one</strong> as an integer array </em><code>[index<sub>1</sub>, index<sub>2</sub>]</code><em> of length 2.</em></p>
+
+<p>The tests are generated such that there is <strong>exactly one solution</strong>. You <strong>may not</strong> use the same element twice.</p>
+
+<p>Your solution must use only constant extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> numbers = [<u>2</u>,<u>7</u>,11,15], target = 9
+<strong>Output:</strong> [1,2]
+<strong>Explanation:</strong> The sum of 2 and 7 is 9. Therefore, index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> numbers = [<u>2</u>,3,<u>4</u>], target = 6
+<strong>Output:</strong> [1,3]
+<strong>Explanation:</strong> The sum of 2 and 4 is 6. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 3. We return [1, 3].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> numbers = [<u>-1</u>,<u>0</u>], target = -1
+<strong>Output:</strong> [1,2]
+<strong>Explanation:</strong> The sum of -1 and 0 is -1. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= numbers.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= numbers[i] &lt;= 1000</code></li>
+	<li><code>numbers</code> is sorted in <strong>non-decreasing order</strong>.</li>
+	<li><code>-1000 &lt;= target &lt;= 1000</code></li>
+	<li>The tests are generated such that there is <strong>exactly one solution</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1672-richest-customer-wealth/1672-richest-customer-wealth.java b/leetcode/leetcode/1672-richest-customer-wealth/1672-richest-customer-wealth.java
new file mode 100644
index 0000000..ecea742
--- /dev/null
+++ b/leetcode/leetcode/1672-richest-customer-wealth/1672-richest-customer-wealth.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int maximumWealth(int[][] accounts) {
+        int max = 0;
+        for(int i =0;i<accounts.length;i++){
+            int sum = 0;
+            for(int j = 0;j<accounts[0].length;j++) sum+=accounts[i][j];
+            max = Math.max(sum,max);
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1672-richest-customer-wealth/NOTES.md b/leetcode/leetcode/1672-richest-customer-wealth/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1672-richest-customer-wealth/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1672-richest-customer-wealth/README.md b/leetcode/leetcode/1672-richest-customer-wealth/README.md
new file mode 100644
index 0000000..e75b70d
--- /dev/null
+++ b/leetcode/leetcode/1672-richest-customer-wealth/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/richest-customer-wealth/">1672. Richest Customer Wealth</a></h2><h3>Easy</h3><hr><div><p>You are given an <code>m x n</code> integer grid <code>accounts</code> where <code>accounts[i][j]</code> is the amount of money the <code>i​​​​​<sup>​​​​​​th</sup>​​​​</code> customer has in the <code>j​​​​​<sup>​​​​​​th</sup></code>​​​​ bank. Return<em> the <strong>wealth</strong> that the richest customer has.</em></p>
+
+<p>A customer's <strong>wealth</strong> is the amount of money they have in all their bank accounts. The richest customer is the customer that has the maximum <strong>wealth</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> accounts = [[1,2,3],[3,2,1]]
+<strong>Output:</strong> 6
+<strong>Explanation</strong><strong>:</strong>
+<code>1st customer has wealth = 1 + 2 + 3 = 6
+</code><code>2nd customer has wealth = 3 + 2 + 1 = 6
+</code>Both customers are considered the richest with a wealth of 6 each, so return 6.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> accounts = [[1,5],[7,3],[3,5]]
+<strong>Output:</strong> 10
+<strong>Explanation</strong>: 
+1st customer has wealth = 6
+2nd customer has wealth = 10 
+3rd customer has wealth = 8
+The 2nd customer is the richest with a wealth of 10.</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> accounts = [[2,8,7],[7,1,3],[1,9,5]]
+<strong>Output:</strong> 17
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m ==&nbsp;accounts.length</code></li>
+	<li><code>n ==&nbsp;accounts[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 50</code></li>
+	<li><code>1 &lt;= accounts[i][j] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1679-max-number-of-k-sum-pairs/1679-max-number-of-k-sum-pairs.java b/leetcode/leetcode/1679-max-number-of-k-sum-pairs/1679-max-number-of-k-sum-pairs.java
new file mode 100644
index 0000000..dec23ea
--- /dev/null
+++ b/leetcode/leetcode/1679-max-number-of-k-sum-pairs/1679-max-number-of-k-sum-pairs.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int maxOperations(int[] nums, int k) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: nums) map.put(num, map.getOrDefault(num,0)+1);
+        int res = 0;
+        for(int i = 0;i<nums.length - 1;i++){
+            int val1 = map.getOrDefault(nums[i],0);
+            int val2 = map.getOrDefault(k-nums[i],0);
+            if(val1>0 && val2>0){
+                if(nums[i] == k - nums[i]){
+                    res+=(Math.min(val1,val2)/2);
+                }else res+=Math.min(val1,val2);
+                map.remove(nums[i]);
+                map.remove(k - nums[i]);
+               
+            }
+            
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1679-max-number-of-k-sum-pairs/NOTES.md b/leetcode/leetcode/1679-max-number-of-k-sum-pairs/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1679-max-number-of-k-sum-pairs/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1679-max-number-of-k-sum-pairs/README.md b/leetcode/leetcode/1679-max-number-of-k-sum-pairs/README.md
new file mode 100644
index 0000000..2de99b4
--- /dev/null
+++ b/leetcode/leetcode/1679-max-number-of-k-sum-pairs/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/max-number-of-k-sum-pairs/">1679. Max Number of K-Sum Pairs</a></h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>nums</code> and an integer <code>k</code>.</p>
+
+<p>In one operation, you can pick two numbers from the array whose sum equals <code>k</code> and remove them from the array.</p>
+
+<p>Return <em>the maximum number of operations you can perform on the array</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4], k = 5
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Starting with nums = [1,2,3,4]:
+- Remove numbers 1 and 4, then nums = [2,3]
+- Remove numbers 2 and 3, then nums = []
+There are no more pairs that sum up to 5, hence a total of 2 operations.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,1,3,4,3], k = 6
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> Starting with nums = [3,1,3,4,3]:
+- Remove the first two 3's, then nums = [1,4,3]
+There are no more pairs that sum up to 6, hence a total of 1 operation.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1684-count-the-number-of-consistent-strings/1684-count-the-number-of-consistent-strings.java b/leetcode/leetcode/1684-count-the-number-of-consistent-strings/1684-count-the-number-of-consistent-strings.java
new file mode 100644
index 0000000..ea7fbe9
--- /dev/null
+++ b/leetcode/leetcode/1684-count-the-number-of-consistent-strings/1684-count-the-number-of-consistent-strings.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int countConsistentStrings(String allowed, String[] words) {
+        int[] map = new int[26];
+        for(int i = 0; i < allowed.length();i++){
+            map[(int) (allowed.charAt(i) - 'a')]++;
+        }
+        int ans = 0;
+        for(int i =0;i<words.length;i++){
+            boolean found = true;
+            for(int j =0;j<words[i].length();j++){
+                if(map[(int) (words[i].charAt(j) - 'a')]==0){
+                    found = false;
+                    break;
+                }
+            }
+            if(found) ans++;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1684-count-the-number-of-consistent-strings/NOTES.md b/leetcode/leetcode/1684-count-the-number-of-consistent-strings/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1684-count-the-number-of-consistent-strings/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1684-count-the-number-of-consistent-strings/README.md b/leetcode/leetcode/1684-count-the-number-of-consistent-strings/README.md
new file mode 100644
index 0000000..e65890f
--- /dev/null
+++ b/leetcode/leetcode/1684-count-the-number-of-consistent-strings/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/count-the-number-of-consistent-strings/">1684. Count the Number of Consistent Strings</a></h2><h3>Easy</h3><hr><div><p>You are given a string <code>allowed</code> consisting of <strong>distinct</strong> characters and an array of strings <code>words</code>. A string is <strong>consistent </strong>if all characters in the string appear in the string <code>allowed</code>.</p>
+
+<p>Return<em> the number of <strong>consistent</strong> strings in the array </em><code>words</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> allowed = "ab", words = ["ad","bd","aaab","baa","badab"]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Strings "aaab" and "baa" are consistent since they only contain characters 'a' and 'b'.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> allowed = "abc", words = ["a","b","c","ab","ac","bc","abc"]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> All strings are consistent.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> allowed = "cad", words = ["cc","acd","b","ba","bac","bad","ac","d"]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Strings "cc", "acd", "ac", and "d" are consistent.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= words.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= allowed.length &lt;=<sup> </sup>26</code></li>
+	<li><code>1 &lt;= words[i].length &lt;= 10</code></li>
+	<li>The characters in <code>allowed</code> are <strong>distinct</strong>.</li>
+	<li><code>words[i]</code> and <code>allowed</code> contain only lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/1689-partitioning-into-minimum-number-of-deci-binary-numbers.java b/leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/1689-partitioning-into-minimum-number-of-deci-binary-numbers.java
new file mode 100644
index 0000000..a3192bf
--- /dev/null
+++ b/leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/1689-partitioning-into-minimum-number-of-deci-binary-numbers.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int minPartitions(String n) {
+        int max = 0;
+        for(int i = 0;i<n.length();i++){
+            int num = n.charAt(i)-'0';
+            max = Math.max(num,max);
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/NOTES.md b/leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/README.md b/leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/README.md
new file mode 100644
index 0000000..c10950e
--- /dev/null
+++ b/leetcode/leetcode/1689-partitioning-into-minimum-number-of-deci-binary-numbers/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers/">1689. Partitioning Into Minimum Number Of Deci-Binary Numbers</a></h2><h3>Medium</h3><hr><div><p>A decimal number is called <strong>deci-binary</strong> if each of its digits is either <code>0</code> or <code>1</code> without any leading zeros. For example, <code>101</code> and <code>1100</code> are <strong>deci-binary</strong>, while <code>112</code> and <code>3001</code> are not.</p>
+
+<p>Given a string <code>n</code> that represents a positive decimal integer, return <em>the <strong>minimum</strong> number of positive <strong>deci-binary</strong> numbers needed so that they sum up to </em><code>n</code><em>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = "32"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 10 + 11 + 11 = 32
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = "82734"
+<strong>Output:</strong> 8
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = "27346209830709182346"
+<strong>Output:</strong> 9
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>n</code> consists of only digits.</li>
+	<li><code>n</code> does not contain any leading zeros and represents a positive integer.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/169-majority-element/169-majority-element.java b/leetcode/leetcode/169-majority-element/169-majority-element.java
new file mode 100644
index 0000000..feb2a73
--- /dev/null
+++ b/leetcode/leetcode/169-majority-element/169-majority-element.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int majorityElement(int[] nums) {
+        int element = 0;
+        int counter = 0;
+        for(int num: nums){
+            if(counter == 0) element = num;
+            if(element == num) counter++;
+            else counter--;
+        }
+        return element;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/169-majority-element/NOTES.md b/leetcode/leetcode/169-majority-element/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/169-majority-element/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/169-majority-element/README.md b/leetcode/leetcode/169-majority-element/README.md
new file mode 100644
index 0000000..d1393d2
--- /dev/null
+++ b/leetcode/leetcode/169-majority-element/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/majority-element/">169. Majority Element</a></h2><h3>Easy</h3><hr><div><p>Given an array <code>nums</code> of size <code>n</code>, return <em>the majority element</em>.</p>
+
+<p>The majority element is the element that appears more than <code>⌊n / 2⌋</code> times. You may assume that the majority element always exists in the array.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,3]
+<strong>Output:</strong> 3
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,1,1,1,2,2]
+<strong>Output:</strong> 2
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow-up:</strong> Could you solve the problem in linear time and in <code>O(1)</code> space?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/17-letter-combinations-of-a-phone-number/17-letter-combinations-of-a-phone-number.java b/leetcode/leetcode/17-letter-combinations-of-a-phone-number/17-letter-combinations-of-a-phone-number.java
new file mode 100644
index 0000000..cddcbd7
--- /dev/null
+++ b/leetcode/leetcode/17-letter-combinations-of-a-phone-number/17-letter-combinations-of-a-phone-number.java
@@ -0,0 +1,34 @@
+class Solution {
+    public List<String> letterHelper(String digit,HashMap<Character,String> map){
+        if(digit.equals("")) return new ArrayList<String> (0);
+        if(digit.length() == 1){
+            List<String> list = new ArrayList<>(3);
+            String s = map.get(digit.charAt(0));
+            for(int i = 0;i<s.length();i++){
+                list.add(String.valueOf(s.charAt(i)));
+            }
+            return list;
+        }
+        List<String> list = letterHelper(digit.substring(1,digit.length()),map);
+        List<String> result = new ArrayList<>();
+        String s = map.get(digit.charAt(0));
+        for(int i = 0;i<s.length();i++){
+            for(int j = 0;j<list.size();j++){
+                result.add(String.valueOf(s.charAt(i)).concat(list.get(j)) );
+            }
+        }
+        return result;
+    }
+    public List<String> letterCombinations(String digits) {
+        HashMap<Character,String> map = new HashMap<>(8);
+        map.put('2',"abc");
+        map.put('3',"def");
+        map.put('4',"ghi");
+        map.put('5',"jkl");
+        map.put('6',"mno");
+        map.put('7',"pqrs");
+        map.put('8',"tuv");
+        map.put('9',"wxyz");
+        return letterHelper(digits,map);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/17-letter-combinations-of-a-phone-number/NOTES.md b/leetcode/leetcode/17-letter-combinations-of-a-phone-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/17-letter-combinations-of-a-phone-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/17-letter-combinations-of-a-phone-number/README.md b/leetcode/leetcode/17-letter-combinations-of-a-phone-number/README.md
new file mode 100644
index 0000000..d045972
--- /dev/null
+++ b/leetcode/leetcode/17-letter-combinations-of-a-phone-number/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/letter-combinations-of-a-phone-number/">17. Letter Combinations of a Phone Number</a></h2><h3>Medium</h3><hr><div><p>Given a string containing digits from <code>2-9</code> inclusive, return all possible letter combinations that the number could represent. Return the answer in <strong>any order</strong>.</p>
+
+<p>A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.</p>
+
+<p><img src="https://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Telephone-keypad2.svg/200px-Telephone-keypad2.svg.png" style="width: 200px; height: 162px;"></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> digits = "23"
+<strong>Output:</strong> ["ad","ae","af","bd","be","bf","cd","ce","cf"]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> digits = ""
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> digits = "2"
+<strong>Output:</strong> ["a","b","c"]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= digits.length &lt;= 4</code></li>
+	<li><code>digits[i]</code> is a digit in the range <code>['2', '9']</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1701-average-waiting-time/1701-average-waiting-time.java b/leetcode/leetcode/1701-average-waiting-time/1701-average-waiting-time.java
new file mode 100644
index 0000000..e5339a9
--- /dev/null
+++ b/leetcode/leetcode/1701-average-waiting-time/1701-average-waiting-time.java
@@ -0,0 +1,15 @@
+class Solution {
+    public double averageWaitingTime(int[][] customers) {
+        int currentTime = 1;
+        long totalWaitingTime = 0;
+        currentTime = customers[0][0];
+        for(int i = 0;i<customers.length;i++){
+            if(customers[i][0]>currentTime){
+                currentTime = customers[i][0];
+            }
+            totalWaitingTime+=(currentTime+customers[i][1] - customers[i][0]) ;
+            currentTime+=customers[i][1];
+        }
+        return ((1.0)*(totalWaitingTime))/customers.length;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1701-average-waiting-time/NOTES.md b/leetcode/leetcode/1701-average-waiting-time/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1701-average-waiting-time/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1701-average-waiting-time/README.md b/leetcode/leetcode/1701-average-waiting-time/README.md
new file mode 100644
index 0000000..1bc0b36
--- /dev/null
+++ b/leetcode/leetcode/1701-average-waiting-time/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/average-waiting-time/">1701. Average Waiting Time</a></h2><h3>Medium</h3><hr><div><p>There is a restaurant with a single chef. You are given an array <code>customers</code>, where <code>customers[i] = [arrival<sub>i</sub>, time<sub>i</sub>]:</code></p>
+
+<ul>
+	<li><code>arrival<sub>i</sub></code> is the arrival time of the <code>i<sup>th</sup></code> customer. The arrival times are sorted in <strong>non-decreasing</strong> order.</li>
+	<li><code>time<sub>i</sub></code> is the time needed to prepare the order of the <code>i<sup>th</sup></code> customer.</li>
+</ul>
+
+<p>When a customer arrives, he gives the chef his order, and the chef starts preparing it once he is idle. The customer waits till the chef finishes preparing his order. The chef does not prepare food for more than one customer at a time. The chef prepares food for customers <strong>in the order they were given in the input</strong>.</p>
+
+<p>Return <em>the <strong>average</strong> waiting time of all customers</em>. Solutions within <code>10<sup>-5</sup></code> from the actual answer are considered accepted.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> customers = [[1,2],[2,5],[4,3]]
+<strong>Output:</strong> 5.00000
+<strong>Explanation:
+</strong>1) The first customer arrives at time 1, the chef takes his order and starts preparing it immediately at time 1, and finishes at time 3, so the waiting time of the first customer is 3 - 1 = 2.
+2) The second customer arrives at time 2, the chef takes his order and starts preparing it at time 3, and finishes at time 8, so the waiting time of the second customer is 8 - 2 = 6.
+3) The third customer arrives at time 4, the chef takes his order and starts preparing it at time 8, and finishes at time 11, so the waiting time of the third customer is 11 - 4 = 7.
+So the average waiting time = (2 + 6 + 7) / 3 = 5.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> customers = [[5,2],[5,4],[10,3],[20,1]]
+<strong>Output:</strong> 3.25000
+<strong>Explanation:
+</strong>1) The first customer arrives at time 5, the chef takes his order and starts preparing it immediately at time 5, and finishes at time 7, so the waiting time of the first customer is 7 - 5 = 2.
+2) The second customer arrives at time 5, the chef takes his order and starts preparing it at time 7, and finishes at time 11, so the waiting time of the second customer is 11 - 5 = 6.
+3) The third customer arrives at time 10, the chef takes his order and starts preparing it at time 11, and finishes at time 14, so the waiting time of the third customer is 14 - 10 = 4.
+4) The fourth customer arrives at time 20, the chef takes his order and starts preparing it immediately at time 20, and finishes at time 21, so the waiting time of the fourth customer is 21 - 20 = 1.
+So the average waiting time = (2 + 6 + 4 + 1) / 4 = 3.25.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= arrival<sub>i</sub>, time<sub>i</sub> &lt;= 10<sup>4</sup></code></li>
+	<li><code>arrival<sub>i&nbsp;</sub>&lt;= arrival<sub>i+1</sub></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1710-maximum-units-on-a-truck/1710-maximum-units-on-a-truck.java b/leetcode/leetcode/1710-maximum-units-on-a-truck/1710-maximum-units-on-a-truck.java
new file mode 100644
index 0000000..d0dae3e
--- /dev/null
+++ b/leetcode/leetcode/1710-maximum-units-on-a-truck/1710-maximum-units-on-a-truck.java
@@ -0,0 +1,16 @@
+class Solution {
+ public int maximumUnits(int[][] boxTypes, int truckSize) {
+        Arrays.sort(boxTypes, (a, b) -> Integer.compare(b[1], a[1]));
+        int boxes = 0;
+        for (int[] box : boxTypes) {
+            if (truckSize >= box[0]) {
+                boxes += box[0] * box[1];
+                truckSize -= box[0];
+            }else {
+                boxes += truckSize * box[1];
+                return boxes;
+            }
+        }
+        return boxes;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1710-maximum-units-on-a-truck/NOTES.md b/leetcode/leetcode/1710-maximum-units-on-a-truck/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1710-maximum-units-on-a-truck/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1710-maximum-units-on-a-truck/README.md b/leetcode/leetcode/1710-maximum-units-on-a-truck/README.md
new file mode 100644
index 0000000..6b631ac
--- /dev/null
+++ b/leetcode/leetcode/1710-maximum-units-on-a-truck/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/maximum-units-on-a-truck/">1710. Maximum Units on a Truck</a></h2><h3>Easy</h3><hr><div><p>You are assigned to put some amount of boxes onto <strong>one truck</strong>. You are given a 2D array <code>boxTypes</code>, where <code>boxTypes[i] = [numberOfBoxes<sub>i</sub>, numberOfUnitsPerBox<sub>i</sub>]</code>:</p>
+
+<ul>
+	<li><code>numberOfBoxes<sub>i</sub></code> is the number of boxes of type <code>i</code>.</li>
+	<li><code>numberOfUnitsPerBox<sub>i</sub></code><sub> </sub>is the number of units in each box of the type <code>i</code>.</li>
+</ul>
+
+<p>You are also given an integer <code>truckSize</code>, which is the <strong>maximum</strong> number of <strong>boxes</strong> that can be put on the truck. You can choose any boxes to put on the truck as long as the number&nbsp;of boxes does not exceed <code>truckSize</code>.</p>
+
+<p>Return <em>the <strong>maximum</strong> total number of <strong>units</strong> that can be put on the truck.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> There are:
+- 1 box of the first type that contains 3 units.
+- 2 boxes of the second type that contain 2 units each.
+- 3 boxes of the third type that contain 1 unit each.
+You can take all the boxes of the first and second types, and one box of the third type.
+The total number of units will be = (1 * 3) + (2 * 2) + (1 * 1) = 8.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
+<strong>Output:</strong> 91
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= boxTypes.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= numberOfBoxes<sub>i</sub>, numberOfUnitsPerBox<sub>i</sub> &lt;= 1000</code></li>
+	<li><code>1 &lt;= truckSize &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1717-maximum-score-from-removing-substrings/1717-maximum-score-from-removing-substrings.java b/leetcode/leetcode/1717-maximum-score-from-removing-substrings/1717-maximum-score-from-removing-substrings.java
new file mode 100644
index 0000000..9baba91
--- /dev/null
+++ b/leetcode/leetcode/1717-maximum-score-from-removing-substrings/1717-maximum-score-from-removing-substrings.java
@@ -0,0 +1,30 @@
+class Solution {
+    public int maximumGain(String s, int x, int y) {
+        char firstChar = 'a';
+        char secondChar = 'b';
+        if(y>x){
+            firstChar  = 'b';
+            secondChar = 'a';
+        }
+        StringBuilder sb =  remove(s,firstChar,secondChar);
+        int ans = (s.length() - sb.length())*Math.max(x,y)/2;
+        StringBuilder sb2 = remove(sb.toString(),secondChar,firstChar);
+        ans+= (sb.length() - sb2.length())*Math.min(x,y)/2;
+        return ans;
+        
+    }
+    public StringBuilder remove(String s, char firstChar, char secondChar){
+        StringBuilder result = new StringBuilder();
+        for(int i = 0;i<s.length();i++){
+            if(s.charAt(i) == secondChar){
+                if(result.length()>0 && result.charAt(result.length()-1) == firstChar){
+                    result.deleteCharAt(result.length() - 1);
+                    continue;
+                }
+            }
+            result.append(s.charAt(i));
+        }
+        return result;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1717-maximum-score-from-removing-substrings/README.md b/leetcode/leetcode/1717-maximum-score-from-removing-substrings/README.md
new file mode 100644
index 0000000..5cb76a0
--- /dev/null
+++ b/leetcode/leetcode/1717-maximum-score-from-removing-substrings/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/maximum-score-from-removing-substrings/">1717. Maximum Score From Removing Substrings</a></h2><h3>Medium</h3><hr><div><p>You are given a string <code>s</code> and two integers <code>x</code> and <code>y</code>. You can perform two types of operations any number of times.</p>
+
+<ul>
+	<li>Remove substring <code>"ab"</code> and gain <code>x</code> points.
+
+	<ul>
+		<li>For example, when removing <code>"ab"</code> from <code>"c<u>ab</u>xbae"</code> it becomes <code>"cxbae"</code>.</li>
+	</ul>
+	</li>
+	<li>Remove substring <code>"ba"</code> and gain <code>y</code> points.
+	<ul>
+		<li>For example, when removing <code>"ba"</code> from <code>"cabx<u>ba</u>e"</code> it becomes <code>"cabxe"</code>.</li>
+	</ul>
+	</li>
+</ul>
+
+<p>Return <em>the maximum points you can gain after applying the above operations on</em> <code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "cdbcbbaaabab", x = 4, y = 5
+<strong>Output:</strong> 19
+<strong>Explanation:</strong>
+- Remove the "ba" underlined in "cdbcbbaaa<u>ba</u>b". Now, s = "cdbcbbaaab" and 5 points are added to the score.
+- Remove the "ab" underlined in "cdbcbbaa<u>ab</u>". Now, s = "cdbcbbaa" and 4 points are added to the score.
+- Remove the "ba" underlined in "cdbcb<u>ba</u>a". Now, s = "cdbcba" and 5 points are added to the score.
+- Remove the "ba" underlined in "cdbc<u>ba</u>". Now, s = "cdbc" and 5 points are added to the score.
+Total score = 5 + 4 + 5 + 5 = 19.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "aabbaaxybbaabb", x = 5, y = 4
+<strong>Output:</strong> 20
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= x, y &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/172-factorial-trailing-zeroes/172-factorial-trailing-zeroes.java b/leetcode/leetcode/172-factorial-trailing-zeroes/172-factorial-trailing-zeroes.java
new file mode 100644
index 0000000..e8676b8
--- /dev/null
+++ b/leetcode/leetcode/172-factorial-trailing-zeroes/172-factorial-trailing-zeroes.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int trailingZeroes(int n) {
+        while(n%5!=0){
+            n--;
+        }
+        int count = 0;
+        while(n!=0){
+            n = n/5;
+            count+=n;
+        }
+        return count;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/172-factorial-trailing-zeroes/NOTES.md b/leetcode/leetcode/172-factorial-trailing-zeroes/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/172-factorial-trailing-zeroes/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/172-factorial-trailing-zeroes/README.md b/leetcode/leetcode/172-factorial-trailing-zeroes/README.md
new file mode 100644
index 0000000..12fdb19
--- /dev/null
+++ b/leetcode/leetcode/172-factorial-trailing-zeroes/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/factorial-trailing-zeroes/">172. Factorial Trailing Zeroes</a></h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, return <em>the number of trailing zeroes in </em><code>n!</code>.</p>
+
+<p>Note that <code>n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> 3! = 6, no trailing zero.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> 5! = 120, one trailing zero.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 0
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you write a solution that works in logarithmic time complexity?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/1721-swapping-nodes-in-a-linked-list.java b/leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/1721-swapping-nodes-in-a-linked-list.java
new file mode 100644
index 0000000..3bb4d21
--- /dev/null
+++ b/leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/1721-swapping-nodes-in-a-linked-list.java
@@ -0,0 +1,41 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode swapNodes(ListNode head, int k) {
+        ListNode temp = head;
+        int len = 0;
+        int main1 = 0;
+        while(temp!=null){
+            if(len==k-1){
+                main1 = temp.val;
+            }
+            temp = temp.next;
+            len++;
+        }
+        int counter = 0;
+        temp = head;
+        while(counter!=len-k){
+            temp = temp.next;
+            counter++;
+        }
+        int val2 = temp.val;
+        temp.val = main1;
+        counter=0;
+        temp = head;
+        while(counter<k-1){
+            temp = temp.next;
+            counter++;
+        }
+        temp.val = val2;
+        return head;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/NOTES.md b/leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/README.md b/leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/README.md
new file mode 100644
index 0000000..e84ddbb
--- /dev/null
+++ b/leetcode/leetcode/1721-swapping-nodes-in-a-linked-list/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/swapping-nodes-in-a-linked-list/">1721. Swapping Nodes in a Linked List</a></h2><h3>Medium</h3><hr><div><p>You are given the <code>head</code> of a linked list, and an integer <code>k</code>.</p>
+
+<p>Return <em>the head of the linked list after <strong>swapping</strong> the values of the </em><code>k<sup>th</sup></code> <em>node from the beginning and the </em><code>k<sup>th</sup></code> <em>node from the end (the list is <strong>1-indexed</strong>).</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/21/linked1.jpg" style="width: 400px; height: 112px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5], k = 2
+<strong>Output:</strong> [1,4,3,2,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [7,9,6,6,7,8,3,0,9,5], k = 5
+<strong>Output:</strong> [7,9,6,6,8,7,3,0,9,5]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is <code>n</code>.</li>
+	<li><code>1 &lt;= k &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1724-customer-who-visited-but-did-not-make-any-transactions/1724-customer-who-visited-but-did-not-make-any-transactions.sql b/leetcode/leetcode/1724-customer-who-visited-but-did-not-make-any-transactions/1724-customer-who-visited-but-did-not-make-any-transactions.sql
new file mode 100644
index 0000000..8fad138
--- /dev/null
+++ b/leetcode/leetcode/1724-customer-who-visited-but-did-not-make-any-transactions/1724-customer-who-visited-but-did-not-make-any-transactions.sql
@@ -0,0 +1,3 @@
+# Write your MySQL query statement below
+SELECT customer_id, count(visit_id) AS count_no_trans FROM Visits WHERE visit_id NOT IN 
+(Select visit_id FROM Transactions) GROUP BY customer_id; 
\ No newline at end of file
diff --git a/leetcode/leetcode/1724-customer-who-visited-but-did-not-make-any-transactions/README.md b/leetcode/leetcode/1724-customer-who-visited-but-did-not-make-any-transactions/README.md
new file mode 100644
index 0000000..40d6826
--- /dev/null
+++ b/leetcode/leetcode/1724-customer-who-visited-but-did-not-make-any-transactions/README.md
@@ -0,0 +1,80 @@
+<h2><a href="https://leetcode.com/problems/customer-who-visited-but-did-not-make-any-transactions/description/?envType=study-plan-v2&envId=top-sql-50">1724. Customer Who Visited but Did Not Make Any Transactions</a></h2><h3>Easy</h3><hr><p>Table: <code>Visits</code></p>
+
+<pre>
++-------------+---------+
+| Column Name | Type    |
++-------------+---------+
+| visit_id    | int     |
+| customer_id | int     |
++-------------+---------+
+visit_id is the column with unique values for this table.
+This table contains information about the customers who visited the mall.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Table: <code>Transactions</code></p>
+
+<pre>
++----------------+---------+
+| Column Name    | Type    |
++----------------+---------+
+| transaction_id | int     |
+| visit_id       | int     |
+| amount         | int     |
++----------------+---------+
+transaction_id is column with unique values for this table.
+This table contains information about the transactions made during the visit_id.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write a&nbsp;solution to find the IDs of the users who visited without making any transactions and the number of times they made these types of visits.</p>
+
+<p>Return the result table sorted in <strong>any order</strong>.</p>
+
+<p>The&nbsp;result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> 
+Visits
++----------+-------------+
+| visit_id | customer_id |
++----------+-------------+
+| 1        | 23          |
+| 2        | 9           |
+| 4        | 30          |
+| 5        | 54          |
+| 6        | 96          |
+| 7        | 54          |
+| 8        | 54          |
++----------+-------------+
+Transactions
++----------------+----------+--------+
+| transaction_id | visit_id | amount |
++----------------+----------+--------+
+| 2              | 5        | 310    |
+| 3              | 5        | 300    |
+| 9              | 5        | 200    |
+| 12             | 1        | 910    |
+| 13             | 2        | 970    |
++----------------+----------+--------+
+<strong>Output:</strong> 
++-------------+----------------+
+| customer_id | count_no_trans |
++-------------+----------------+
+| 54          | 2              |
+| 30          | 1              |
+| 96          | 1              |
++-------------+----------------+
+<strong>Explanation:</strong> 
+Customer with id = 23 visited the mall once and made one transaction during the visit with id = 12.
+Customer with id = 9 visited the mall once and made one transaction during the visit with id = 13.
+Customer with id = 30 visited the mall once and did not make any transactions.
+Customer with id = 54 visited the mall three times. During 2 visits they did not make any transactions, and during one visit they made 3 transactions.
+Customer with id = 96 visited the mall once and did not make any transactions.
+As we can see, users with IDs 30 and 96 visited the mall one time without making any transactions. Also, user 54 visited the mall twice and did not make any transactions.
+</pre>
diff --git a/leetcode/leetcode/173-binary-search-tree-iterator/173-binary-search-tree-iterator.java b/leetcode/leetcode/173-binary-search-tree-iterator/173-binary-search-tree-iterator.java
new file mode 100644
index 0000000..64a719b
--- /dev/null
+++ b/leetcode/leetcode/173-binary-search-tree-iterator/173-binary-search-tree-iterator.java
@@ -0,0 +1,50 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class BSTIterator {
+    
+    Stack<TreeNode> s;
+    public BSTIterator(TreeNode root) {
+        s = new Stack<>();
+        TreeNode curr = root;
+        while(curr!=null){
+            s.push(curr);
+            curr = curr.left;
+        }
+    }
+    
+    public int next() {
+        TreeNode curr = s.pop();
+        int val = curr.val;
+        curr = curr.right;
+        while(curr!=null){
+            s.push(curr);
+            curr =curr.left;
+        }
+        return val;
+        
+    }
+    
+    public boolean hasNext() {
+        return s.size()!=0;
+    }
+}
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * BSTIterator obj = new BSTIterator(root);
+ * int param_1 = obj.next();
+ * boolean param_2 = obj.hasNext();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/173-binary-search-tree-iterator/NOTES.md b/leetcode/leetcode/173-binary-search-tree-iterator/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/173-binary-search-tree-iterator/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1732-find-the-highest-altitude/1732-find-the-highest-altitude.java b/leetcode/leetcode/1732-find-the-highest-altitude/1732-find-the-highest-altitude.java
new file mode 100644
index 0000000..61696fe
--- /dev/null
+++ b/leetcode/leetcode/1732-find-the-highest-altitude/1732-find-the-highest-altitude.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int largestAltitude(int[] gain) {
+        int low = 0;
+        int ans = 0;
+        for(int i = 0;i<gain.length;i++){
+            low = low + gain[i];
+            ans = Math.max(ans,low);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1732-find-the-highest-altitude/NOTES.md b/leetcode/leetcode/1732-find-the-highest-altitude/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1732-find-the-highest-altitude/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1732-find-the-highest-altitude/README.md b/leetcode/leetcode/1732-find-the-highest-altitude/README.md
new file mode 100644
index 0000000..663a3de
--- /dev/null
+++ b/leetcode/leetcode/1732-find-the-highest-altitude/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/find-the-highest-altitude/">1732. Find the Highest Altitude</a></h2><h3>Easy</h3><hr><div><p>There is a biker going on a road trip. The road trip consists of <code>n + 1</code> points at different altitudes. The biker starts his trip on point <code>0</code> with altitude equal <code>0</code>.</p>
+
+<p>You are given an integer array <code>gain</code> of length <code>n</code> where <code>gain[i]</code> is the <strong>net gain in altitude</strong> between points <code>i</code>​​​​​​ and <code>i + 1</code> for all (<code>0 &lt;= i &lt; n)</code>. Return <em>the <strong>highest altitude</strong> of a point.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> gain = [-5,1,5,0,-7]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The altitudes are [0,-5,-4,1,1,-6]. The highest is 1.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> gain = [-4,-3,-2,-1,4,3,2]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == gain.length</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>-100 &lt;= gain[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1768-merge-strings-alternately/1768-merge-strings-alternately.java b/leetcode/leetcode/1768-merge-strings-alternately/1768-merge-strings-alternately.java
new file mode 100644
index 0000000..6ec04e4
--- /dev/null
+++ b/leetcode/leetcode/1768-merge-strings-alternately/1768-merge-strings-alternately.java
@@ -0,0 +1,21 @@
+class Solution {
+    public String mergeAlternately(String word1, String word2) {
+        int pointer1 = 0;
+        int pointer2 = 0;
+        StringBuilder sb = new StringBuilder(word1.length()+word2.length());
+        while(pointer1!=word1.length() || pointer2!=word2.length() ){
+            if(pointer1==word1.length()){
+                sb.append(word2.charAt(pointer2++));
+                continue;
+            }
+            if(pointer2==word2.length()){
+                sb.append(word1.charAt(pointer1++));
+                continue;
+            }
+            sb.append(word1.charAt(pointer1++));
+            sb.append(word2.charAt(pointer2++));
+        }
+        return sb.toString();
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1768-merge-strings-alternately/NOTES.md b/leetcode/leetcode/1768-merge-strings-alternately/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1768-merge-strings-alternately/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1768-merge-strings-alternately/README.md b/leetcode/leetcode/1768-merge-strings-alternately/README.md
new file mode 100644
index 0000000..2d0d189
--- /dev/null
+++ b/leetcode/leetcode/1768-merge-strings-alternately/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/merge-strings-alternately/">1768. Merge Strings Alternately</a></h2><h3>Easy</h3><hr><div><p>You are given two strings <code>word1</code> and <code>word2</code>. Merge the strings by adding letters in alternating order, starting with <code>word1</code>. If a string is longer than the other, append the additional letters onto the end of the merged string.</p>
+
+<p>Return <em>the merged string.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> word1 = "abc", word2 = "pqr"
+<strong>Output:</strong> "apbqcr"
+<strong>Explanation:</strong>&nbsp;The merged string will be merged as so:
+word1:  a   b   c
+word2:    p   q   r
+merged: a p b q c r
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> word1 = "ab", word2 = "pqrs"
+<strong>Output:</strong> "apbqrs"
+<strong>Explanation:</strong>&nbsp;Notice that as word2 is longer, "rs" is appended to the end.
+word1:  a   b 
+word2:    p   q   r   s
+merged: a p b q   r   s
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> word1 = "abcd", word2 = "pq"
+<strong>Output:</strong> "apbqcd"
+<strong>Explanation:</strong>&nbsp;Notice that as word1 is longer, "cd" is appended to the end.
+word1:  a   b   c   d
+word2:    p   q 
+merged: a p b q c   d
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= word1.length, word2.length &lt;= 100</code></li>
+	<li><code>word1</code> and <code>word2</code> consist of lowercase English letters.</li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1791-find-center-of-star-graph/1791-find-center-of-star-graph.java b/leetcode/leetcode/1791-find-center-of-star-graph/1791-find-center-of-star-graph.java
new file mode 100644
index 0000000..cfa098c
--- /dev/null
+++ b/leetcode/leetcode/1791-find-center-of-star-graph/1791-find-center-of-star-graph.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int findCenter(int[][] edges) {
+        int[] firstEdge = edges[0];
+        int[] secondEdge = edges[1];
+
+        return (firstEdge[0] == secondEdge[0] || firstEdge[0] == secondEdge[1])
+            ? firstEdge[0]
+            : firstEdge[1];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1791-find-center-of-star-graph/README.md b/leetcode/leetcode/1791-find-center-of-star-graph/README.md
new file mode 100644
index 0000000..fc958c5
--- /dev/null
+++ b/leetcode/leetcode/1791-find-center-of-star-graph/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/find-center-of-star-graph/">1791. Find Center of Star Graph</a></h2><h3>Easy</h3><hr><div><p>There is an undirected <strong>star</strong> graph consisting of <code>n</code> nodes labeled from <code>1</code> to <code>n</code>. A star graph is a graph where there is one <strong>center</strong> node and <strong>exactly</strong> <code>n - 1</code> edges that connect the center node with every other node.</p>
+
+<p>You are given a 2D integer array <code>edges</code> where each <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> indicates that there is an edge between the nodes <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code>. Return the center of the given star graph.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/24/star_graph.png" style="width: 331px; height: 321px;">
+<pre><strong>Input:</strong> edges = [[1,2],[2,3],[4,2]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> As shown in the figure above, node 2 is connected to every other node, so 2 is the center.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> edges = [[1,2],[5,1],[1,3],[1,4]]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>edges.length == n - 1</code></li>
+	<li><code>edges[i].length == 2</code></li>
+	<li><code>1 &lt;= u<sub>i,</sub> v<sub>i</sub> &lt;= n</code></li>
+	<li><code>u<sub>i</sub> != v<sub>i</sub></code></li>
+	<li>The given <code>edges</code> represent a valid star graph.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1817-finding-the-users-active-minutes/1817-finding-the-users-active-minutes.java b/leetcode/leetcode/1817-finding-the-users-active-minutes/1817-finding-the-users-active-minutes.java
new file mode 100644
index 0000000..f5b4282
--- /dev/null
+++ b/leetcode/leetcode/1817-finding-the-users-active-minutes/1817-finding-the-users-active-minutes.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int[] findingUsersActiveMinutes(int[][] logs, int k) {
+        int[] res = new int[k];
+        HashMap<Integer,HashSet<Integer>> map = new HashMap<>();
+        for(int i = 0;i<logs.length;i++){
+            if(map.containsKey(logs[i][0])){
+                HashSet<Integer> set = map.get(logs[i][0]);
+                set.add(logs[i][1]);
+                map.put(logs[i][0],set);
+            }else{
+                HashSet<Integer> set = new HashSet<>();
+                set.add(logs[i][1]);
+                map.put(logs[i][0],set);
+            }
+        }
+        for(int key : map.keySet()) res[map.get(key).size()-1]++;
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1817-finding-the-users-active-minutes/NOTES.md b/leetcode/leetcode/1817-finding-the-users-active-minutes/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1817-finding-the-users-active-minutes/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1817-finding-the-users-active-minutes/README.md b/leetcode/leetcode/1817-finding-the-users-active-minutes/README.md
new file mode 100644
index 0000000..4219ad6
--- /dev/null
+++ b/leetcode/leetcode/1817-finding-the-users-active-minutes/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/finding-the-users-active-minutes/">1817. Finding the Users Active Minutes</a></h2><h3>Medium</h3><hr><div><p>You are given the logs for users' actions on LeetCode, and an integer <code>k</code>. The logs are represented by a 2D integer array <code>logs</code> where each <code>logs[i] = [ID<sub>i</sub>, time<sub>i</sub>]</code> indicates that the user with <code>ID<sub>i</sub></code> performed an action at the minute <code>time<sub>i</sub></code>.</p>
+
+<p><strong>Multiple users</strong> can perform actions simultaneously, and a single user can perform <strong>multiple actions</strong> in the same minute.</p>
+
+<p>The <strong>user active minutes (UAM)</strong> for a given user is defined as the <strong>number of unique minutes</strong> in which the user performed an action on LeetCode. A minute can only be counted once, even if multiple actions occur during it.</p>
+
+<p>You are to calculate a <strong>1-indexed</strong> array <code>answer</code> of size <code>k</code> such that, for each <code>j</code> (<code>1 &lt;= j &lt;= k</code>), <code>answer[j]</code> is the <strong>number of users</strong> whose <strong>UAM</strong> equals <code>j</code>.</p>
+
+<p>Return <i>the array </i><code>answer</code><i> as described above</i>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> logs = [[0,5],[1,2],[0,2],[0,5],[1,3]], k = 5
+<strong>Output:</strong> [0,2,0,0,0]
+<strong>Explanation:</strong>
+The user with ID=0 performed actions at minutes 5, 2, and 5 again. Hence, they have a UAM of 2 (minute 5 is only counted once).
+The user with ID=1 performed actions at minutes 2 and 3. Hence, they have a UAM of 2.
+Since both users have a UAM of 2, answer[2] is 2, and the remaining answer[j] values are 0.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> logs = [[1,1],[2,2],[2,3]], k = 4
+<strong>Output:</strong> [1,1,0,0]
+<strong>Explanation:</strong>
+The user with ID=1 performed a single action at minute 1. Hence, they have a UAM of 1.
+The user with ID=2 performed actions at minutes 2 and 3. Hence, they have a UAM of 2.
+There is one user with a UAM of 1 and one with a UAM of 2.
+Hence, answer[1] = 1, answer[2] = 1, and the remaining values are 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= logs.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= ID<sub>i</sub> &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= time<sub>i</sub> &lt;= 10<sup>5</sup></code></li>
+	<li><code>k</code> is in the range <code>[The maximum <strong>UAM</strong> for a user, 10<sup>5</sup>]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/182-duplicate-emails/182-duplicate-emails.sql b/leetcode/leetcode/182-duplicate-emails/182-duplicate-emails.sql
new file mode 100644
index 0000000..5882623
--- /dev/null
+++ b/leetcode/leetcode/182-duplicate-emails/182-duplicate-emails.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT email from Person GROUP BY email HAVING count(email)>1;
\ No newline at end of file
diff --git a/leetcode/leetcode/182-duplicate-emails/NOTES.md b/leetcode/leetcode/182-duplicate-emails/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/182-duplicate-emails/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/182-duplicate-emails/README.md b/leetcode/leetcode/182-duplicate-emails/README.md
new file mode 100644
index 0000000..43e8473
--- /dev/null
+++ b/leetcode/leetcode/182-duplicate-emails/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/duplicate-emails/">182. Duplicate Emails</a></h2><h3>Easy</h3><hr><div class="sql-schema-wrapper__3VBi"><a class="sql-schema-link__3cEg">SQL Schema<svg viewBox="0 0 24 24" width="1em" height="1em" class="icon__1Md2"><path fill-rule="evenodd" d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></svg></a></div><div><p>Table: <code>Person</code></p>
+
+<pre>+-------------+---------+
+| Column Name | Type    |
++-------------+---------+
+| id          | int     |
+| email       | varchar |
++-------------+---------+
+id is the primary key column for this table.
+Each row of this table contains an email. The emails will not contain uppercase letters.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write an SQL query to report all the duplicate emails.</p>
+
+<p>Return the result table in <strong>any order</strong>.</p>
+
+<p>The query result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> 
+Person table:
++----+---------+
+| id | email   |
++----+---------+
+| 1  | a@b.com |
+| 2  | c@d.com |
+| 3  | a@b.com |
++----+---------+
+<strong>Output:</strong> 
++---------+
+| Email   |
++---------+
+| a@b.com |
++---------+
+<strong>Explanation:</strong> a@b.com is repeated two times.
+</pre>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1822-sign-of-the-product-of-an-array/1822-sign-of-the-product-of-an-array.java b/leetcode/leetcode/1822-sign-of-the-product-of-an-array/1822-sign-of-the-product-of-an-array.java
new file mode 100644
index 0000000..cb212f5
--- /dev/null
+++ b/leetcode/leetcode/1822-sign-of-the-product-of-an-array/1822-sign-of-the-product-of-an-array.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int arraySign(int[] nums) {
+        boolean negative = false;
+        for(int val: nums){
+            if(val==0) return 0;
+            else if(val<0) negative = !negative;
+        }
+        if(negative == false) return 1;
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1822-sign-of-the-product-of-an-array/NOTES.md b/leetcode/leetcode/1822-sign-of-the-product-of-an-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1822-sign-of-the-product-of-an-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1822-sign-of-the-product-of-an-array/README.md b/leetcode/leetcode/1822-sign-of-the-product-of-an-array/README.md
new file mode 100644
index 0000000..f7b477f
--- /dev/null
+++ b/leetcode/leetcode/1822-sign-of-the-product-of-an-array/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/sign-of-the-product-of-an-array/">1822. Sign of the Product of an Array</a></h2><h3>Easy</h3><hr><div><p>There is a function <code>signFunc(x)</code> that returns:</p>
+
+<ul>
+	<li><code>1</code> if <code>x</code> is positive.</li>
+	<li><code>-1</code> if <code>x</code> is negative.</li>
+	<li><code>0</code> if <code>x</code> is equal to <code>0</code>.</li>
+</ul>
+
+<p>You are given an integer array <code>nums</code>. Let <code>product</code> be the product of all values in the array <code>nums</code>.</p>
+
+<p>Return <code>signFunc(product)</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,-2,-3,-4,3,2,1]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The product of all values in the array is 144, and signFunc(144) = 1
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,5,0,2,-3]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The product of all values in the array is 0, and signFunc(0) = 0
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,1,-1,1,-1]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> The product of all values in the array is -1, and signFunc(-1) = -1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>-100 &lt;= nums[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1823-find-the-winner-of-the-circular-game/1823-find-the-winner-of-the-circular-game.java b/leetcode/leetcode/1823-find-the-winner-of-the-circular-game/1823-find-the-winner-of-the-circular-game.java
new file mode 100644
index 0000000..9447cdb
--- /dev/null
+++ b/leetcode/leetcode/1823-find-the-winner-of-the-circular-game/1823-find-the-winner-of-the-circular-game.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int findTheWinner(int n, int k) {
+        Queue<Integer> q = new LinkedList<>();
+        for(int i = 1;i<=n;i++) q.add(i);
+        int counter = 0;
+        while(q.size()!=1){
+            while(counter!=k-1){
+                q.add(q.remove());
+                counter++;
+            }
+            q.remove();
+            counter = 0;
+        }
+        return q.peek();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1823-find-the-winner-of-the-circular-game/NOTES.md b/leetcode/leetcode/1823-find-the-winner-of-the-circular-game/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1823-find-the-winner-of-the-circular-game/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1823-find-the-winner-of-the-circular-game/README.md b/leetcode/leetcode/1823-find-the-winner-of-the-circular-game/README.md
new file mode 100644
index 0000000..e62bea9
--- /dev/null
+++ b/leetcode/leetcode/1823-find-the-winner-of-the-circular-game/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/find-the-winner-of-the-circular-game/">1823. Find the Winner of the Circular Game</a></h2><h3>Medium</h3><hr><div><p>There are <code>n</code> friends that are playing a game. The friends are sitting in a circle and are numbered from <code>1</code> to <code>n</code> in <strong>clockwise order</strong>. More formally, moving clockwise from the <code>i<sup>th</sup></code> friend brings you to the <code>(i+1)<sup>th</sup></code> friend for <code>1 &lt;= i &lt; n</code>, and moving clockwise from the <code>n<sup>th</sup></code> friend brings you to the <code>1<sup>st</sup></code> friend.</p>
+
+<p>The rules of the game are as follows:</p>
+
+<ol>
+	<li><strong>Start</strong> at the <code>1<sup>st</sup></code> friend.</li>
+	<li>Count the next <code>k</code> friends in the clockwise direction <strong>including</strong> the friend you started at. The counting wraps around the circle and may count some friends more than once.</li>
+	<li>The last friend you counted leaves the circle and loses the game.</li>
+	<li>If there is still more than one friend in the circle, go back to step <code>2</code> <strong>starting</strong> from the friend <strong>immediately clockwise</strong> of the friend who just lost and repeat.</li>
+	<li>Else, the last friend in the circle wins the game.</li>
+</ol>
+
+<p>Given the number of friends, <code>n</code>, and an integer <code>k</code>, return <em>the winner of the game</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/25/ic234-q2-ex11.png" style="width: 500px; height: 345px;">
+<pre><strong>Input:</strong> n = 5, k = 2
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Here are the steps of the game:
+1) Start at friend 1.
+2) Count 2 friends clockwise, which are friends 1 and 2.
+3) Friend 2 leaves the circle. Next start is friend 3.
+4) Count 2 friends clockwise, which are friends 3 and 4.
+5) Friend 4 leaves the circle. Next start is friend 5.
+6) Count 2 friends clockwise, which are friends 5 and 1.
+7) Friend 1 leaves the circle. Next start is friend 3.
+8) Count 2 friends clockwise, which are friends 3 and 5.
+9) Friend 5 leaves the circle. Only friend 3 is left, so they are the winner.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 6, k = 5
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The friends leave in this order: 5, 4, 6, 2, 3. The winner is friend 1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= n &lt;= 500</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<p>Could you solve this problem in linear time with constant space?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1827-invalid-tweets/1827-invalid-tweets.sql b/leetcode/leetcode/1827-invalid-tweets/1827-invalid-tweets.sql
new file mode 100644
index 0000000..c30fede
--- /dev/null
+++ b/leetcode/leetcode/1827-invalid-tweets/1827-invalid-tweets.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT tweet_id FROM Tweets where LENGTH(content) > 15;
\ No newline at end of file
diff --git a/leetcode/leetcode/1827-invalid-tweets/README.md b/leetcode/leetcode/1827-invalid-tweets/README.md
new file mode 100644
index 0000000..900c40e
--- /dev/null
+++ b/leetcode/leetcode/1827-invalid-tweets/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/invalid-tweets">1827. Invalid Tweets</a></h2><h3>Easy</h3><hr><p>Table: <code>Tweets</code></p>
+
+<pre>
++----------------+---------+
+| Column Name    | Type    |
++----------------+---------+
+| tweet_id       | int     |
+| content        | varchar |
++----------------+---------+
+tweet_id is the primary key (column with unique values) for this table.
+content consists of characters on an American Keyboard, and no other special characters.
+This table contains all the tweets in a social media app.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write a solution to find the IDs of the invalid tweets. The tweet is invalid if the number of characters used in the content of the tweet is <strong>strictly greater</strong> than <code>15</code>.</p>
+
+<p>Return the result table in <strong>any order</strong>.</p>
+
+<p>The result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> 
+Tweets table:
++----------+-----------------------------------+
+| tweet_id | content                           |
++----------+-----------------------------------+
+| 1        | Let us Code                       |
+| 2        | More than fifteen chars are here! |
++----------+-----------------------------------+
+<strong>Output:</strong> 
++----------+
+| tweet_id |
++----------+
+| 2        |
++----------+
+<strong>Explanation:</strong> 
+Tweet 1 has length = 11. It is a valid tweet.
+Tweet 2 has length = 33. It is an invalid tweet.
+</pre>
diff --git a/leetcode/leetcode/1833-maximum-ice-cream-bars/1833-maximum-ice-cream-bars.java b/leetcode/leetcode/1833-maximum-ice-cream-bars/1833-maximum-ice-cream-bars.java
new file mode 100644
index 0000000..0c68c64
--- /dev/null
+++ b/leetcode/leetcode/1833-maximum-ice-cream-bars/1833-maximum-ice-cream-bars.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int maxIceCream(int[] costs, int coins) {
+        Arrays.sort(costs);
+        int max = 0;
+        int index = 0;    
+        while(costs[index]<=coins){
+            max++;
+            coins-=costs[index];
+            index++;
+            if(index==costs.length) break;
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1833-maximum-ice-cream-bars/NOTES.md b/leetcode/leetcode/1833-maximum-ice-cream-bars/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1833-maximum-ice-cream-bars/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1833-maximum-ice-cream-bars/README.md b/leetcode/leetcode/1833-maximum-ice-cream-bars/README.md
new file mode 100644
index 0000000..cc72d87
--- /dev/null
+++ b/leetcode/leetcode/1833-maximum-ice-cream-bars/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/maximum-ice-cream-bars/">1833. Maximum Ice Cream Bars</a></h2><h3>Medium</h3><hr><div><p>It is a sweltering summer day, and a boy wants to buy some ice cream bars.</p>
+
+<p>At the store, there are <code>n</code> ice cream bars. You are given an array <code>costs</code> of length <code>n</code>, where <code>costs[i]</code> is the price of the <code>i<sup>th</sup></code> ice cream bar in coins. The boy initially has <code>coins</code> coins to spend, and he wants to buy as many ice cream bars as possible.&nbsp;</p>
+
+<p>Return <em>the <strong>maximum</strong> number of ice cream bars the boy can buy with </em><code>coins</code><em> coins.</em></p>
+
+<p><strong>Note:</strong> The boy can buy the ice cream bars in any order.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> costs = [1,3,2,4,1], coins = 7
+<strong>Output:</strong> 4
+<strong>Explanation: </strong>The boy can buy ice cream bars at indices 0,1,2,4 for a total price of 1 + 3 + 2 + 1 = 7.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> costs = [10,6,8,7,7,8], coins = 5
+<strong>Output:</strong> 0
+<strong>Explanation: </strong>The boy cannot afford any of the ice cream bars.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> costs = [1,6,3,1,2,5], coins = 20
+<strong>Output:</strong> 6
+<strong>Explanation: </strong>The boy can buy all the ice cream bars for a total price of 1 + 6 + 3 + 1 + 2 + 5 = 18.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>costs.length == n</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= costs[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= coins &lt;= 10<sup>8</sup></code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1845-seat-reservation-manager/1845-seat-reservation-manager.java b/leetcode/leetcode/1845-seat-reservation-manager/1845-seat-reservation-manager.java
new file mode 100644
index 0000000..4b46156
--- /dev/null
+++ b/leetcode/leetcode/1845-seat-reservation-manager/1845-seat-reservation-manager.java
@@ -0,0 +1,27 @@
+class SeatManager {
+    PriorityQueue<Integer> pq;
+    public SeatManager(int n) {
+        pq = new PriorityQueue<>(n);
+        for(int i = 1;i<=n;i++){
+            pq.add(i);
+        }
+    }
+    
+    public int reserve() {
+        int min = pq.peek();
+        pq.remove(min);
+        return min;
+    }
+    
+    public void unreserve(int seatNumber) {    
+        pq.add(seatNumber);
+
+    }
+}
+
+/**
+ * Your SeatManager object will be instantiated and called as such:
+ * SeatManager obj = new SeatManager(n);
+ * int param_1 = obj.reserve();
+ * obj.unreserve(seatNumber);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/1845-seat-reservation-manager/NOTES.md b/leetcode/leetcode/1845-seat-reservation-manager/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1845-seat-reservation-manager/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1845-seat-reservation-manager/README.md b/leetcode/leetcode/1845-seat-reservation-manager/README.md
new file mode 100644
index 0000000..889dd70
--- /dev/null
+++ b/leetcode/leetcode/1845-seat-reservation-manager/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/seat-reservation-manager/">1845. Seat Reservation Manager</a></h2><h3>Medium</h3><hr><div><p>Design a system that manages the reservation state of <code>n</code> seats that are numbered from <code>1</code> to <code>n</code>.</p>
+
+<p>Implement the <code>SeatManager</code> class:</p>
+
+<ul>
+	<li><code>SeatManager(int n)</code> Initializes a <code>SeatManager</code> object that will manage <code>n</code> seats numbered from <code>1</code> to <code>n</code>. All seats are initially available.</li>
+	<li><code>int reserve()</code> Fetches the <strong>smallest-numbered</strong> unreserved seat, reserves it, and returns its number.</li>
+	<li><code>void unreserve(int seatNumber)</code> Unreserves the seat with the given <code>seatNumber</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["SeatManager", "reserve", "reserve", "unreserve", "reserve", "reserve", "reserve", "reserve", "unreserve"]
+[[5], [], [], [2], [], [], [], [], [5]]
+<strong>Output</strong>
+[null, 1, 2, null, 2, 3, 4, 5, null]
+
+<strong>Explanation</strong>
+SeatManager seatManager = new SeatManager(5); // Initializes a SeatManager with 5 seats.
+seatManager.reserve();    // All seats are available, so return the lowest numbered seat, which is 1.
+seatManager.reserve();    // The available seats are [2,3,4,5], so return the lowest of them, which is 2.
+seatManager.unreserve(2); // Unreserve seat 2, so now the available seats are [2,3,4,5].
+seatManager.reserve();    // The available seats are [2,3,4,5], so return the lowest of them, which is 2.
+seatManager.reserve();    // The available seats are [3,4,5], so return the lowest of them, which is 3.
+seatManager.reserve();    // The available seats are [4,5], so return the lowest of them, which is 4.
+seatManager.reserve();    // The only available seat is seat 5, so return 5.
+seatManager.unreserve(5); // Unreserve seat 5, so now the available seats are [5].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= seatNumber &lt;= n</code></li>
+	<li>For each call to <code>reserve</code>, it is guaranteed that there will be at least one unreserved seat.</li>
+	<li>For each call to <code>unreserve</code>, it is guaranteed that <code>seatNumber</code> will be reserved.</li>
+	<li>At most <code>10<sup>5</sup></code> calls <strong>in total</strong> will be made to <code>reserve</code> and <code>unreserve</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1846-maximum-element-after-decreasing-and-rearranging/1846-maximum-element-after-decreasing-and-rearranging.java b/leetcode/leetcode/1846-maximum-element-after-decreasing-and-rearranging/1846-maximum-element-after-decreasing-and-rearranging.java
new file mode 100644
index 0000000..dd9b191
--- /dev/null
+++ b/leetcode/leetcode/1846-maximum-element-after-decreasing-and-rearranging/1846-maximum-element-after-decreasing-and-rearranging.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int maximumElementAfterDecrementingAndRearranging(int[] arr) {
+        if(arr.length==1) return 1;
+        Arrays.sort(arr);
+        arr[0] = 1;
+        for(int i = 1;i<arr.length-1;i++){
+            if(Math.abs(arr[i]-arr[i-1])<=1 && Math.abs(arr[i]-arr[i+1])<=1){
+                i=i+2;
+            }else if(Math.abs(arr[i]-arr[i-1])<=1){
+                continue;
+            }else{
+                arr[i] = arr[i-1]+1;
+            }
+        }
+        if(Math.abs(arr[arr.length-1]-arr[arr.length-2])>1){
+            arr[arr.length-1] = arr[arr.length-2]+1;
+        }
+        return arr[arr.length-1];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1846-maximum-element-after-decreasing-and-rearranging/README.md b/leetcode/leetcode/1846-maximum-element-after-decreasing-and-rearranging/README.md
new file mode 100644
index 0000000..cc83a97
--- /dev/null
+++ b/leetcode/leetcode/1846-maximum-element-after-decreasing-and-rearranging/README.md
@@ -0,0 +1,54 @@
+<h2><a href="https://leetcode.com/problems/maximum-element-after-decreasing-and-rearranging/">1846. Maximum Element After Decreasing and Rearranging</a></h2><h3>Medium</h3><hr><div><p>You are given an array of positive integers <code>arr</code>. Perform some operations (possibly none) on <code>arr</code> so that it satisfies these conditions:</p>
+
+<ul>
+	<li>The value of the <strong>first</strong> element in <code>arr</code> must be <code>1</code>.</li>
+	<li>The absolute difference between any 2 adjacent elements must be <strong>less than or equal to </strong><code>1</code>. In other words, <code>abs(arr[i] - arr[i - 1]) &lt;= 1</code> for each <code>i</code> where <code>1 &lt;= i &lt; arr.length</code> (<strong>0-indexed</strong>). <code>abs(x)</code> is the absolute value of <code>x</code>.</li>
+</ul>
+
+<p>There are 2 types of operations that you can perform any number of times:</p>
+
+<ul>
+	<li><strong>Decrease</strong> the value of any element of <code>arr</code> to a <strong>smaller positive integer</strong>.</li>
+	<li><strong>Rearrange</strong> the elements of <code>arr</code> to be in any order.</li>
+</ul>
+
+<p>Return <em>the <strong>maximum</strong> possible value of an element in </em><code>arr</code><em> after performing the operations to satisfy the conditions</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [2,2,1,2,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 
+We can satisfy the conditions by rearranging <code>arr</code> so it becomes <code>[1,2,2,2,1]</code>.
+The largest element in <code>arr</code> is 2.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [100,1,1000]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 
+One possible way to satisfy the conditions is by doing the following:
+1. Rearrange <code>arr</code> so it becomes <code>[1,100,1000]</code>.
+2. Decrease the value of the second element to 2.
+3. Decrease the value of the third element to 3.
+Now <code>arr = [1,2,3], which </code>satisfies the conditions.
+The largest element in <code>arr is 3.</code>
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,3,4,5]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The array already satisfies the conditions, and the largest element is 5.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1849-maximum-absolute-sum-of-any-subarray/1849-maximum-absolute-sum-of-any-subarray.java b/leetcode/leetcode/1849-maximum-absolute-sum-of-any-subarray/1849-maximum-absolute-sum-of-any-subarray.java
new file mode 100644
index 0000000..90215b3
--- /dev/null
+++ b/leetcode/leetcode/1849-maximum-absolute-sum-of-any-subarray/1849-maximum-absolute-sum-of-any-subarray.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxAbsoluteSum(int[] nums) {
+        int maxSum = Integer.MIN_VALUE;
+        int minSum = Integer.MAX_VALUE;
+        int currMax = 0;
+        int currMin = 0;
+        for(int num: nums){
+            currMax +=num;
+            currMin +=num;
+            maxSum = Math.max(maxSum,currMax);
+            minSum = Math.min(minSum,currMin);
+            if(currMax<0) currMax = 0;
+            if(currMin>0) currMin = 0;
+        }
+        return Math.max(maxSum,Math.abs(minSum));
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1849-maximum-absolute-sum-of-any-subarray/README.md b/leetcode/leetcode/1849-maximum-absolute-sum-of-any-subarray/README.md
new file mode 100644
index 0000000..17a252e
--- /dev/null
+++ b/leetcode/leetcode/1849-maximum-absolute-sum-of-any-subarray/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/maximum-absolute-sum-of-any-subarray">1849. Maximum Absolute Sum of Any Subarray</a></h2><h3>Medium</h3><hr><p>You are given an integer array <code>nums</code>. The <strong>absolute sum</strong> of a subarray <code>[nums<sub>l</sub>, nums<sub>l+1</sub>, ..., nums<sub>r-1</sub>, nums<sub>r</sub>]</code> is <code>abs(nums<sub>l</sub> + nums<sub>l+1</sub> + ... + nums<sub>r-1</sub> + nums<sub>r</sub>)</code>.</p>
+
+<p>Return <em>the <strong>maximum</strong> absolute sum of any <strong>(possibly empty)</strong> subarray of </em><code>nums</code>.</p>
+
+<p>Note that <code>abs(x)</code> is defined as follows:</p>
+
+<ul>
+	<li>If <code>x</code> is a negative integer, then <code>abs(x) = -x</code>.</li>
+	<li>If <code>x</code> is a non-negative integer, then <code>abs(x) = x</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,-3,2,3,-4]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The subarray [2,3] has absolute sum = abs(2+3) = abs(5) = 5.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,-5,1,-4,3,-2]
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> The subarray [-5,1,-4] has absolute sum = abs(-5+1-4) = abs(-8) = 8.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/1889-check-if-number-is-a-sum-of-powers-of-three/1889-check-if-number-is-a-sum-of-powers-of-three.java b/leetcode/leetcode/1889-check-if-number-is-a-sum-of-powers-of-three/1889-check-if-number-is-a-sum-of-powers-of-three.java
new file mode 100644
index 0000000..a510bff
--- /dev/null
+++ b/leetcode/leetcode/1889-check-if-number-is-a-sum-of-powers-of-three/1889-check-if-number-is-a-sum-of-powers-of-three.java
@@ -0,0 +1,32 @@
+class Solution {
+
+    // Approach 1: Pre-computation all possible sum of power of three
+    
+    HashSet<Integer> set = new HashSet<>(); 
+    // function to generate sum of all subset of an array.
+    public void generateAllSubsetSum(ArrayList<Integer> list, int index, int sum){
+        if(index == list.size()){
+            set.add(sum);
+            return;
+        }
+
+        generateAllSubsetSum(list,index+1,sum);
+        generateAllSubsetSum(list,index+1,sum+list.get(index));
+
+    }
+    public boolean checkPowersOfThree(int n) {
+        // array to save all powers of three.
+        ArrayList<Integer> powerOfThree = new ArrayList<>();
+        
+        int currentNum = 1;
+        
+        while(currentNum<=10000000){
+            powerOfThree.add(currentNum);
+            currentNum*=3;
+        }
+        // generate all subset sum of powers of three.
+        generateAllSubsetSum(powerOfThree,0,0);
+        return set.contains(n);
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1889-check-if-number-is-a-sum-of-powers-of-three/README.md b/leetcode/leetcode/1889-check-if-number-is-a-sum-of-powers-of-three/README.md
new file mode 100644
index 0000000..565fa7a
--- /dev/null
+++ b/leetcode/leetcode/1889-check-if-number-is-a-sum-of-powers-of-three/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/check-if-number-is-a-sum-of-powers-of-three">1889. Check if Number is a Sum of Powers of Three</a></h2><h3>Medium</h3><hr><p>Given an integer <code>n</code>, return <code>true</code> <em>if it is possible to represent </em><code>n</code><em> as the sum of distinct powers of three.</em> Otherwise, return <code>false</code>.</p>
+
+<p>An integer <code>y</code> is a power of three if there exists an integer <code>x</code> such that <code>y == 3<sup>x</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 12
+<strong>Output:</strong> true
+<strong>Explanation:</strong> 12 = 3<sup>1</sup> + 3<sup>2</sup>
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 91
+<strong>Output:</strong> true
+<strong>Explanation:</strong> 91 = 3<sup>0</sup> + 3<sup>2</sup> + 3<sup>4</sup>
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 21
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>7</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/19-remove-nth-node-from-end-of-list/19-remove-nth-node-from-end-of-list.java b/leetcode/leetcode/19-remove-nth-node-from-end-of-list/19-remove-nth-node-from-end-of-list.java
new file mode 100644
index 0000000..073b472
--- /dev/null
+++ b/leetcode/leetcode/19-remove-nth-node-from-end-of-list/19-remove-nth-node-from-end-of-list.java
@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        int len = 0;
+        ListNode temp = head;
+        while(temp!=null){
+            temp = temp.next;
+            len++;
+        }
+        if(len == n) return head.next;
+        len = len - n;
+        temp = head;
+        while(len!=1){
+            temp = temp.next;
+            len--;
+        }
+        temp.next = temp.next.next;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/19-remove-nth-node-from-end-of-list/NOTES.md b/leetcode/leetcode/19-remove-nth-node-from-end-of-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/19-remove-nth-node-from-end-of-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1908-recyclable-and-low-fat-products/1908-recyclable-and-low-fat-products.sql b/leetcode/leetcode/1908-recyclable-and-low-fat-products/1908-recyclable-and-low-fat-products.sql
new file mode 100644
index 0000000..9761120
--- /dev/null
+++ b/leetcode/leetcode/1908-recyclable-and-low-fat-products/1908-recyclable-and-low-fat-products.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT product_id from Products where low_fats = 'Y' AND recyclable='Y';
\ No newline at end of file
diff --git a/leetcode/leetcode/1908-recyclable-and-low-fat-products/README.md b/leetcode/leetcode/1908-recyclable-and-low-fat-products/README.md
new file mode 100644
index 0000000..f47c9f2
--- /dev/null
+++ b/leetcode/leetcode/1908-recyclable-and-low-fat-products/README.md
@@ -0,0 +1,46 @@
+<h2><a href="https://leetcode.com/problems/recyclable-and-low-fat-products">1908. Recyclable and Low Fat Products</a></h2><h3>Easy</h3><hr><p>Table: <code>Products</code></p>
+
+<pre>
++-------------+---------+
+| Column Name | Type    |
++-------------+---------+
+| product_id  | int     |
+| low_fats    | enum    |
+| recyclable  | enum    |
++-------------+---------+
+product_id is the primary key (column with unique values) for this table.
+low_fats is an ENUM (category) of type (&#39;Y&#39;, &#39;N&#39;) where &#39;Y&#39; means this product is low fat and &#39;N&#39; means it is not.
+recyclable is an ENUM (category) of types (&#39;Y&#39;, &#39;N&#39;) where &#39;Y&#39; means this product is recyclable and &#39;N&#39; means it is not.</pre>
+
+<p>&nbsp;</p>
+
+<p>Write a solution to find the ids of products that are both low fat and recyclable.</p>
+
+<p>Return the result table in <strong>any order</strong>.</p>
+
+<p>The result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> 
+Products table:
++-------------+----------+------------+
+| product_id  | low_fats | recyclable |
++-------------+----------+------------+
+| 0           | Y        | N          |
+| 1           | Y        | Y          |
+| 2           | N        | Y          |
+| 3           | Y        | Y          |
+| 4           | N        | N          |
++-------------+----------+------------+
+<strong>Output:</strong> 
++-------------+
+| product_id  |
++-------------+
+| 1           |
+| 3           |
++-------------+
+<strong>Explanation:</strong> Only products 1 and 3 are both low fat and recyclable.
+</pre>
diff --git a/leetcode/leetcode/1920-build-array-from-permutation/1920-build-array-from-permutation.py b/leetcode/leetcode/1920-build-array-from-permutation/1920-build-array-from-permutation.py
new file mode 100644
index 0000000..9c2ca2d
--- /dev/null
+++ b/leetcode/leetcode/1920-build-array-from-permutation/1920-build-array-from-permutation.py
@@ -0,0 +1,6 @@
+class Solution:
+    def buildArray(self, nums: List[int]) -> List[int]:
+        res = []
+        for i in nums:
+            res.append(nums[i]);
+        return res;
\ No newline at end of file
diff --git a/leetcode/leetcode/1920-build-array-from-permutation/README.md b/leetcode/leetcode/1920-build-array-from-permutation/README.md
new file mode 100644
index 0000000..50d20dc
--- /dev/null
+++ b/leetcode/leetcode/1920-build-array-from-permutation/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/build-array-from-permutation/">1920. Build Array from Permutation</a></h2><h3>Easy</h3><hr><div><p>Given a <strong>zero-based permutation</strong> <code>nums</code> (<strong>0-indexed</strong>), build an array <code>ans</code> of the <strong>same length</strong> where <code>ans[i] = nums[nums[i]]</code> for each <code>0 &lt;= i &lt; nums.length</code> and return it.</p>
+
+<p>A <strong>zero-based permutation</strong> <code>nums</code> is an array of <strong>distinct</strong> integers from <code>0</code> to <code>nums.length - 1</code> (<strong>inclusive</strong>).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,2,1,5,3,4]
+<strong>Output:</strong> [0,1,2,4,5,3]<strong>
+Explanation:</strong> The array ans is built as follows: 
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
+    = [0,1,2,4,5,3]</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [5,0,1,2,3,4]
+<strong>Output:</strong> [4,5,0,1,2,3]
+<strong>Explanation:</strong> The array ans is built as follows:
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
+    = [4,5,0,1,2,3]</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums[i] &lt; nums.length</code></li>
+	<li>The elements in <code>nums</code> are <strong>distinct</strong>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong> Can you solve it without using an extra space (i.e., <code>O(1)</code> memory)?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1945-sum-of-digits-of-string-after-convert/1945-sum-of-digits-of-string-after-convert.java b/leetcode/leetcode/1945-sum-of-digits-of-string-after-convert/1945-sum-of-digits-of-string-after-convert.java
new file mode 100644
index 0000000..9bfdd3a
--- /dev/null
+++ b/leetcode/leetcode/1945-sum-of-digits-of-string-after-convert/1945-sum-of-digits-of-string-after-convert.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int transform(int num, int k){
+        if(k==0) return num;
+        int sum = 0;
+        while(num!=0){
+            sum += num%10;
+            num = num/10;
+        }
+        return transform(sum,k-1);
+    }
+    public int getLucky(String s, int k) {
+        int sum = 0;
+        int temp;
+        for(int i = 0;i<s.length();i++){
+            temp =(int) s.charAt(i)  - 96;
+            sum  = sum + temp%10 + temp/10;
+        }
+   
+        return k == 1 ? sum : transform(sum,k-1);
+    
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1945-sum-of-digits-of-string-after-convert/README.md b/leetcode/leetcode/1945-sum-of-digits-of-string-after-convert/README.md
new file mode 100644
index 0000000..bcd40d1
--- /dev/null
+++ b/leetcode/leetcode/1945-sum-of-digits-of-string-after-convert/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/sum-of-digits-of-string-after-convert/">1945. Sum of Digits of String After Convert</a></h2><h3>Easy</h3><hr><div><p>You are given a string <code>s</code> consisting of lowercase English letters, and an integer <code>k</code>.</p>
+
+<p>First, <strong>convert</strong> <code>s</code> into an integer by replacing each letter with its position in the alphabet (i.e., replace <code>'a'</code> with <code>1</code>, <code>'b'</code> with <code>2</code>, ..., <code>'z'</code> with <code>26</code>). Then, <strong>transform</strong> the integer by replacing it with the <strong>sum of its digits</strong>. Repeat the <strong>transform</strong> operation <code>k</code><strong> times</strong> in total.</p>
+
+<p>For example, if <code>s = "zbax"</code> and <code>k = 2</code>, then the resulting integer would be <code>8</code> by the following operations:</p>
+
+<ul>
+	<li><strong>Convert</strong>: <code>"zbax" ➝ "(26)(2)(1)(24)" ➝ "262124" ➝ 262124</code></li>
+	<li><strong>Transform #1</strong>: <code>262124 ➝ 2 + 6 + 2 + 1 + 2 + 4&nbsp;➝ 17</code></li>
+	<li><strong>Transform #2</strong>: <code>17 ➝ 1 + 7 ➝ 8</code></li>
+</ul>
+
+<p>Return <em>the resulting integer after performing the operations described above</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "iiii", k = 1
+<strong>Output:</strong> 36
+<strong>Explanation:</strong> The operations are as follows:
+- Convert: "iiii" ➝ "(9)(9)(9)(9)" ➝ "9999" ➝ 9999
+- Transform #1: 9999 ➝ 9 + 9 + 9 + 9 ➝ 36
+Thus the resulting integer is 36.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "leetcode", k = 2
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The operations are as follows:
+- Convert: "leetcode" ➝ "(12)(5)(5)(20)(3)(15)(4)(5)" ➝ "12552031545" ➝ 12552031545
+- Transform #1: 12552031545 ➝ 1 + 2 + 5 + 5 + 2 + 0 + 3 + 1 + 5 + 4 + 5 ➝ 33
+- Transform #2: 33 ➝ 3 + 3 ➝ 6
+Thus the resulting integer is 6.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "zbax", k = 2
+<strong>Output:</strong> 8
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 100</code></li>
+	<li><code>1 &lt;= k &lt;= 10</code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1979-find-greatest-common-divisor-of-array/1979-find-greatest-common-divisor-of-array.java b/leetcode/leetcode/1979-find-greatest-common-divisor-of-array/1979-find-greatest-common-divisor-of-array.java
new file mode 100644
index 0000000..436f09d
--- /dev/null
+++ b/leetcode/leetcode/1979-find-greatest-common-divisor-of-array/1979-find-greatest-common-divisor-of-array.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int gcd(int a, int b){
+        if(a == 0) return b;
+        return gcd(b%a,a);
+    }
+    public int findGCD(int[] nums) {
+        int min = Integer.MAX_VALUE;
+        int max = Integer.MIN_VALUE;
+        for(int num: nums){
+            min = Math.min(num,min);
+            max = Math.max(num, max);
+        }
+        return gcd(max,min);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1979-find-greatest-common-divisor-of-array/NOTES.md b/leetcode/leetcode/1979-find-greatest-common-divisor-of-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1979-find-greatest-common-divisor-of-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1979-find-greatest-common-divisor-of-array/README.md b/leetcode/leetcode/1979-find-greatest-common-divisor-of-array/README.md
new file mode 100644
index 0000000..598fe8a
--- /dev/null
+++ b/leetcode/leetcode/1979-find-greatest-common-divisor-of-array/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/find-greatest-common-divisor-of-array/">1979. Find Greatest Common Divisor of Array</a></h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code>, return<strong> </strong><em>the <strong>greatest common divisor</strong> of the smallest number and largest number in </em><code>nums</code>.</p>
+
+<p>The <strong>greatest common divisor</strong> of two numbers is the largest positive integer that evenly divides both numbers.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,5,6,9,10]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+The smallest number in nums is 2.
+The largest number in nums is 10.
+The greatest common divisor of 2 and 10 is 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [7,5,6,8,3]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong>
+The smallest number in nums is 3.
+The largest number in nums is 8.
+The greatest common divisor of 3 and 8 is 1.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,3]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+The smallest number in nums is 3.
+The largest number in nums is 3.
+The greatest common divisor of 3 and 3 is 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/198-house-robber/198-house-robber.java b/leetcode/leetcode/198-house-robber/198-house-robber.java
new file mode 100644
index 0000000..798eca6
--- /dev/null
+++ b/leetcode/leetcode/198-house-robber/198-house-robber.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int rob(int[] nums, int index, int[] dp){
+        if(index >= nums.length) return 0;
+        if(dp[index]!=-1) return dp[index];
+        dp[index] = Math.max(nums[index] + rob(nums,index+2,dp),rob(nums,index+1,dp));
+        return dp[index];
+    }
+    public int rob(int[] nums) {
+        int[] dp = new int[nums.length];
+        for(int i = 0;i<nums.length;i++) dp[i] = -1;
+        return rob(nums,0,dp);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/198-house-robber/NOTES.md b/leetcode/leetcode/198-house-robber/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/198-house-robber/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/198-house-robber/README.md b/leetcode/leetcode/198-house-robber/README.md
new file mode 100644
index 0000000..f6fe673
--- /dev/null
+++ b/leetcode/leetcode/198-house-robber/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/house-robber/">198. House Robber</a></h2><h3>Medium</h3><hr><div><p>You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and <b>it will automatically contact the police if two adjacent houses were broken into on the same night</b>.</p>
+
+<p>Given an integer array <code>nums</code> representing the amount of money of each house, return <em>the maximum amount of money you can rob tonight <b>without alerting the police</b></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,1]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Rob house 1 (money = 1) and then rob house 3 (money = 3).
+Total amount you can rob = 1 + 3 = 4.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,7,9,3,1]
+<strong>Output:</strong> 12
+<strong>Explanation:</strong> Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
+Total amount you can rob = 2 + 9 + 1 = 12.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 400</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1983-maximum-population-year/1983-maximum-population-year.java b/leetcode/leetcode/1983-maximum-population-year/1983-maximum-population-year.java
new file mode 100644
index 0000000..d0096d3
--- /dev/null
+++ b/leetcode/leetcode/1983-maximum-population-year/1983-maximum-population-year.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int maximumPopulation(int[][] logs) {
+        int[] arr = new int[101];
+        for(int[] entry: logs){
+            arr[entry[0]-1950]++;
+            arr[entry[1]-1950]--;
+        }
+        int max = 0;
+        int year = 0;
+        int temp = 0;
+        for(int i = 0;i<101;i++){
+            temp+=arr[i];
+            if(temp>max){
+                max = temp;
+                year = i;
+            }
+        }
+        return year+1950;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1983-maximum-population-year/README.md b/leetcode/leetcode/1983-maximum-population-year/README.md
new file mode 100644
index 0000000..9d8dfcf
--- /dev/null
+++ b/leetcode/leetcode/1983-maximum-population-year/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/maximum-population-year">1983. Maximum Population Year</a></h2><h3>Easy</h3><hr><p>You are given a 2D integer array <code>logs</code> where each <code>logs[i] = [birth<sub>i</sub>, death<sub>i</sub>]</code> indicates the birth and death years of the <code>i<sup>th</sup></code> person.</p>
+
+<p>The <strong>population</strong> of some year <code>x</code> is the number of people alive during that year. The <code>i<sup>th</sup></code> person is counted in year <code>x</code>&#39;s population if <code>x</code> is in the <strong>inclusive</strong> range <code>[birth<sub>i</sub>, death<sub>i</sub> - 1]</code>. Note that the person is <strong>not</strong> counted in the year that they die.</p>
+
+<p>Return <em>the <strong>earliest</strong> year with the <strong>maximum population</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> logs = [[1993,1999],[2000,2010]]
+<strong>Output:</strong> 1993
+<strong>Explanation:</strong> The maximum population is 1, and 1993 is the earliest year with this population.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> logs = [[1950,1961],[1960,1971],[1970,1981]]
+<strong>Output:</strong> 1960
+<strong>Explanation:</strong> 
+The maximum population is 2, and it had happened in years 1960 and 1970.
+The earlier year between them is 1960.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= logs.length &lt;= 100</code></li>
+	<li><code>1950 &lt;= birth<sub>i</sub> &lt; death<sub>i</sub> &lt;= 2050</code></li>
+</ul>
diff --git a/leetcode/leetcode/199-binary-tree-right-side-view/199-binary-tree-right-side-view.java b/leetcode/leetcode/199-binary-tree-right-side-view/199-binary-tree-right-side-view.java
new file mode 100644
index 0000000..2775e56
--- /dev/null
+++ b/leetcode/leetcode/199-binary-tree-right-side-view/199-binary-tree-right-side-view.java
@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> rightSideView(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        if(root==null) return list;
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+        while(!q.isEmpty()){
+            for(int i = q.size();i>0;i--){
+                TreeNode front = q.remove();
+                if(i == 1) list.add(front.val);
+                if(front.left!=null) q.add(front.left);
+                if(front.right!=null) q.add(front.right);
+            }
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/199-binary-tree-right-side-view/NOTES.md b/leetcode/leetcode/199-binary-tree-right-side-view/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/199-binary-tree-right-side-view/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/199-binary-tree-right-side-view/README.md b/leetcode/leetcode/199-binary-tree-right-side-view/README.md
new file mode 100644
index 0000000..e7d4431
--- /dev/null
+++ b/leetcode/leetcode/199-binary-tree-right-side-view/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-right-side-view/">199. Binary Tree Right Side View</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, imagine yourself standing on the <strong>right side</strong> of it, return <em>the values of the nodes you can see ordered from top to bottom</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/14/tree.jpg" style="width: 401px; height: 301px;">
+<pre><strong>Input:</strong> root = [1,2,3,null,5,null,4]
+<strong>Output:</strong> [1,3,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,null,3]
+<strong>Output:</strong> [1,3]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/1991-find-the-middle-index-in-array/1991-find-the-middle-index-in-array.java b/leetcode/leetcode/1991-find-the-middle-index-in-array/1991-find-the-middle-index-in-array.java
new file mode 100644
index 0000000..8475543
--- /dev/null
+++ b/leetcode/leetcode/1991-find-the-middle-index-in-array/1991-find-the-middle-index-in-array.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int findMiddleIndex(int[] nums) {
+        long sum = 0;
+        int left[] = new int[nums.length+1];
+        int right[] = new int[nums.length+1];
+        for(int i = 0;i<nums.length;i++){
+            left[i+1] = left[i]+nums[i];
+            right[nums.length-i-1] = right[nums.length-i]+nums[nums.length-i-1];
+        }
+
+        int index = -1;
+        for(int i = 0;i<nums.length;i++){
+            if(left[i] == right[i+1]){
+                return i;
+            }
+        }
+        return index;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/1991-find-the-middle-index-in-array/NOTES.md b/leetcode/leetcode/1991-find-the-middle-index-in-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/1991-find-the-middle-index-in-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/1991-find-the-middle-index-in-array/README.md b/leetcode/leetcode/1991-find-the-middle-index-in-array/README.md
new file mode 100644
index 0000000..0a0a07d
--- /dev/null
+++ b/leetcode/leetcode/1991-find-the-middle-index-in-array/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/find-the-middle-index-in-array/">1991. Find the Middle Index in Array</a></h2><h3>Easy</h3><hr><div><p>Given a <strong>0-indexed</strong> integer array <code>nums</code>, find the <strong>leftmost</strong> <code>middleIndex</code> (i.e., the smallest amongst all the possible ones).</p>
+
+<p>A <code>middleIndex</code> is an index where <code>nums[0] + nums[1] + ... + nums[middleIndex-1] == nums[middleIndex+1] + nums[middleIndex+2] + ... + nums[nums.length-1]</code>.</p>
+
+<p>If <code>middleIndex == 0</code>, the left side sum is considered to be <code>0</code>. Similarly, if <code>middleIndex == nums.length - 1</code>, the right side sum is considered to be <code>0</code>.</p>
+
+<p>Return <em>the <strong>leftmost</strong> </em><code>middleIndex</code><em> that satisfies the condition, or </em><code>-1</code><em> if there is no such index</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,3,-1,<u>8</u>,4]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The sum of the numbers before index 3 is: 2 + 3 + -1 = 4
+The sum of the numbers after index 3 is: 4 = 4
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,-1,<u>4</u>]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The sum of the numbers before index 2 is: 1 + -1 = 0
+The sum of the numbers after index 2 is: 0
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,5]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> There is no valid middleIndex.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>-1000 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as&nbsp;724:&nbsp;<a href="https://leetcode.com/problems/find-pivot-index/" target="_blank">https://leetcode.com/problems/find-pivot-index/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2-add-two-numbers/2-add-two-numbers.java b/leetcode/leetcode/2-add-two-numbers/2-add-two-numbers.java
new file mode 100644
index 0000000..7a57e58
--- /dev/null
+++ b/leetcode/leetcode/2-add-two-numbers/2-add-two-numbers.java
@@ -0,0 +1,42 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        int carry = 0;
+        ListNode head = new ListNode();
+        ListNode temp = head;
+        while(l1!=null || l2!=null){
+            int val1 = 0;
+            int val2 = 0;
+            if(l1!=null){
+                val1 = l1.val;
+                l1 = l1.next;
+                
+            } 
+            if(l2!=null) {
+                val2 = l2.val;
+                l2 = l2.next;
+                
+            }
+            int data = val1 + val2 +carry;
+            if(data>9){
+                carry = data/10;
+                data = data%10;
+            }else{
+                carry = 0;
+            }
+            temp.next = new ListNode(data);
+            temp = temp.next;
+        }
+        if(carry!=0) temp.next = new ListNode(carry);
+        return head.next;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2-add-two-numbers/NOTES.md b/leetcode/leetcode/2-add-two-numbers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2-add-two-numbers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/20-valid-parentheses/20-valid-parentheses.java b/leetcode/leetcode/20-valid-parentheses/20-valid-parentheses.java
new file mode 100644
index 0000000..ade3022
--- /dev/null
+++ b/leetcode/leetcode/20-valid-parentheses/20-valid-parentheses.java
@@ -0,0 +1,20 @@
+class Solution {
+    public boolean isValid(String s) {
+        Stack<Character> s1 = new Stack<>();
+        for(char c : s.toCharArray()){
+            if(c == '('){
+                s1.push(')');
+            }else if(c == '{'){
+                s1.push('}');
+            }else if( c=='['){
+                s1.push(']');
+            }
+            else if(!(s1.isEmpty()) && s1.peek()==c){
+                s1.pop();
+            }else{
+                return false;
+            }
+        }
+        return s1.isEmpty();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/20-valid-parentheses/NOTES.md b/leetcode/leetcode/20-valid-parentheses/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/20-valid-parentheses/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/20-valid-parentheses/README.md b/leetcode/leetcode/20-valid-parentheses/README.md
new file mode 100644
index 0000000..2fa17b8
--- /dev/null
+++ b/leetcode/leetcode/20-valid-parentheses/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/valid-parentheses/">20. Valid Parentheses</a></h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code> containing just the characters <code>'('</code>, <code>')'</code>, <code>'{'</code>, <code>'}'</code>, <code>'['</code> and <code>']'</code>, determine if the input string is valid.</p>
+
+<p>An input string is valid if:</p>
+
+<ol>
+	<li>Open brackets must be closed by the same type of brackets.</li>
+	<li>Open brackets must be closed in the correct order.</li>
+</ol>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "()"
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "()[]{}"
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "(]"
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of parentheses only <code>'()[]{}'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2000-reverse-prefix-of-word/2000-reverse-prefix-of-word.java b/leetcode/leetcode/2000-reverse-prefix-of-word/2000-reverse-prefix-of-word.java
new file mode 100644
index 0000000..145af8d
--- /dev/null
+++ b/leetcode/leetcode/2000-reverse-prefix-of-word/2000-reverse-prefix-of-word.java
@@ -0,0 +1,16 @@
+class Solution {
+    public String reversePrefix(String word, char ch) {
+        StringBuilder sb = new StringBuilder(word.length());
+        int found = 0;
+        for(int i =0;i<word.length();i++){
+            sb.append(word.charAt(i));
+            if(found == 0 && word.charAt(i) == ch){
+                sb.reverse();
+                found = 1;
+            }
+        }
+        return sb.toString();
+        
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2000-reverse-prefix-of-word/NOTES.md b/leetcode/leetcode/2000-reverse-prefix-of-word/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2000-reverse-prefix-of-word/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2000-reverse-prefix-of-word/README.md b/leetcode/leetcode/2000-reverse-prefix-of-word/README.md
new file mode 100644
index 0000000..e5627c8
--- /dev/null
+++ b/leetcode/leetcode/2000-reverse-prefix-of-word/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/reverse-prefix-of-word/">2000. Reverse Prefix of Word</a></h2><h3>Easy</h3><hr><div><p>Given a <strong>0-indexed</strong> string <code>word</code> and a character <code>ch</code>, <strong>reverse</strong> the segment of <code>word</code> that starts at index <code>0</code> and ends at the index of the <strong>first occurrence</strong> of <code>ch</code> (<strong>inclusive</strong>). If the character <code>ch</code> does not exist in <code>word</code>, do nothing.</p>
+
+<ul>
+	<li>For example, if <code>word = "abcdefd"</code> and <code>ch = "d"</code>, then you should <strong>reverse</strong> the segment that starts at <code>0</code> and ends at <code>3</code> (<strong>inclusive</strong>). The resulting string will be <code>"<u>dcba</u>efd"</code>.</li>
+</ul>
+
+<p>Return <em>the resulting string</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> word = "<u>abcd</u>efd", ch = "d"
+<strong>Output:</strong> "<u>dcba</u>efd"
+<strong>Explanation:</strong>&nbsp;The first occurrence of "d" is at index 3. 
+Reverse the part of word from 0 to 3 (inclusive), the resulting string is "dcbaefd".
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> word = "<u>xyxz</u>xe", ch = "z"
+<strong>Output:</strong> "<u>zxyx</u>xe"
+<strong>Explanation:</strong>&nbsp;The first and only occurrence of "z" is at index 3.
+Reverse the part of word from 0 to 3 (inclusive), the resulting string is "zxyxxe".
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> word = "abcd", ch = "z"
+<strong>Output:</strong> "abcd"
+<strong>Explanation:</strong>&nbsp;"z" does not exist in word.
+You should not do any reverse operation, the resulting string is "abcd".
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= word.length &lt;= 250</code></li>
+	<li><code>word</code> consists of lowercase English letters.</li>
+	<li><code>ch</code> is a lowercase English letter.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/202-happy-number/202-happy-number.java b/leetcode/leetcode/202-happy-number/202-happy-number.java
new file mode 100644
index 0000000..68ddbb8
--- /dev/null
+++ b/leetcode/leetcode/202-happy-number/202-happy-number.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int sumOfDigitSquare(int n){
+        int ans = 0;
+        while(n!=0){
+            int digit = n%10;
+            ans+=(digit*digit);
+            n = n/10;
+        }
+        return ans;
+    }
+    public boolean isHappy(int n) {
+        HashSet<Integer> set = new HashSet<>();
+        while(n!=1){
+            int nextNum = sumOfDigitSquare(n);
+            if(set.contains(nextNum)) return false;
+            set.add(nextNum);
+            n = nextNum;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/202-happy-number/NOTES.md b/leetcode/leetcode/202-happy-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/202-happy-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2021-remove-all-occurrences-of-a-substring/2021-remove-all-occurrences-of-a-substring.java b/leetcode/leetcode/2021-remove-all-occurrences-of-a-substring/2021-remove-all-occurrences-of-a-substring.java
new file mode 100644
index 0000000..7b5dfc5
--- /dev/null
+++ b/leetcode/leetcode/2021-remove-all-occurrences-of-a-substring/2021-remove-all-occurrences-of-a-substring.java
@@ -0,0 +1,88 @@
+class Solution {
+
+    public String removeOccurrences(String s, String part) {
+        // Precompute KMP longest prefix-suffix array for the pattern
+        int[] kmpLPS = computeLongestPrefixSuffix(part);
+
+        // Using stack to track characters and support pattern matching
+        Stack<Character> charStack = new Stack<>();
+
+        // Array to store pattern matching indices during traversal
+        int[] patternIndexes = new int[s.length() + 1];
+
+        for (
+            int strIndex = 0, patternIndex = 0;
+            strIndex < s.length();
+            strIndex++
+        ) {
+            char currentChar = s.charAt(strIndex);
+            charStack.push(currentChar);
+
+            if (currentChar == part.charAt(patternIndex)) {
+                // Track the next pattern index when characters match
+                patternIndexes[charStack.size()] = ++patternIndex;
+
+                if (patternIndex == part.length()) {
+                    // Remove entire matched pattern from stack
+                    int remainingLength = part.length();
+                    while (remainingLength != 0) {
+                        charStack.pop();
+                        remainingLength--;
+                    }
+
+                    // Restore pattern index for next potential match
+                    patternIndex = charStack.isEmpty()
+                        ? 0
+                        : patternIndexes[charStack.size()];
+                }
+            } else {
+                if (patternIndex != 0) {
+                    // Backtrack pattern matching using KMP LPS
+                    strIndex--;
+                    patternIndex = kmpLPS[patternIndex - 1];
+                    charStack.pop();
+                } else {
+                    // Reset pattern index tracking when no match is possible
+                    patternIndexes[charStack.size()] = 0;
+                }
+            }
+        }
+
+        // Convert remaining stack characters to result string
+        StringBuilder result = new StringBuilder();
+        while (!charStack.isEmpty()) {
+            result.append(charStack.pop());
+        }
+
+        return result.reverse().toString();
+    }
+
+    private int[] computeLongestPrefixSuffix(String pattern) {
+        // Array to store the longest proper prefix which is also a suffix
+        int[] lps = new int[pattern.length()];
+
+        // Initialize tracking variables for prefix and current position
+        for (int current = 1, prefixLength = 0; current < pattern.length();) {
+            // If characters match, extend the prefix length
+            if (pattern.charAt(current) == pattern.charAt(prefixLength)) {
+                // Store the length of matching prefix
+                lps[current] = ++prefixLength;
+                current++;
+            }
+            // If characters don't match and we're not at the start of the pattern
+            else if (prefixLength != 0) {
+                // Backtrack to the previous longest prefix-suffix
+                prefixLength = lps[prefixLength - 1];
+            }
+            // If no match and no prefix to backtrack
+            else {
+                // No prefix-suffix match found
+                lps[current] = 0;
+                current++;
+            }
+        }
+
+        // Return the computed longest prefix-suffix array
+        return lps;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2021-remove-all-occurrences-of-a-substring/README.md b/leetcode/leetcode/2021-remove-all-occurrences-of-a-substring/README.md
new file mode 100644
index 0000000..05d9e85
--- /dev/null
+++ b/leetcode/leetcode/2021-remove-all-occurrences-of-a-substring/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/remove-all-occurrences-of-a-substring">2021. Remove All Occurrences of a Substring</a></h2><h3>Medium</h3><hr><p>Given two strings <code>s</code> and <code>part</code>, perform the following operation on <code>s</code> until <strong>all</strong> occurrences of the substring <code>part</code> are removed:</p>
+
+<ul>
+	<li>Find the <strong>leftmost</strong> occurrence of the substring <code>part</code> and <strong>remove</strong> it from <code>s</code>.</li>
+</ul>
+
+<p>Return <code>s</code><em> after removing all occurrences of </em><code>part</code>.</p>
+
+<p>A <strong>substring</strong> is a contiguous sequence of characters in a string.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;daabcbaabcbc&quot;, part = &quot;abc&quot;
+<strong>Output:</strong> &quot;dab&quot;
+<strong>Explanation</strong>: The following operations are done:
+- s = &quot;da<strong><u>abc</u></strong>baabcbc&quot;, remove &quot;abc&quot; starting at index 2, so s = &quot;dabaabcbc&quot;.
+- s = &quot;daba<strong><u>abc</u></strong>bc&quot;, remove &quot;abc&quot; starting at index 4, so s = &quot;dababc&quot;.
+- s = &quot;dab<strong><u>abc</u></strong>&quot;, remove &quot;abc&quot; starting at index 3, so s = &quot;dab&quot;.
+Now s has no occurrences of &quot;abc&quot;.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;axxxxyyyyb&quot;, part = &quot;xy&quot;
+<strong>Output:</strong> &quot;ab&quot;
+<strong>Explanation</strong>: The following operations are done:
+- s = &quot;axxx<strong><u>xy</u></strong>yyyb&quot;, remove &quot;xy&quot; starting at index 4 so s = &quot;axxxyyyb&quot;.
+- s = &quot;axx<strong><u>xy</u></strong>yyb&quot;, remove &quot;xy&quot; starting at index 3 so s = &quot;axxyyb&quot;.
+- s = &quot;ax<strong><u>xy</u></strong>yb&quot;, remove &quot;xy&quot; starting at index 2 so s = &quot;axyb&quot;.
+- s = &quot;a<strong><u>xy</u></strong>b&quot;, remove &quot;xy&quot; starting at index 1 so s = &quot;ab&quot;.
+Now s has no occurrences of &quot;xy&quot;.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= part.length &lt;= 1000</code></li>
+	<li><code>s</code>​​​​​​ and <code>part</code> consists of lowercase English letters.</li>
+</ul>
diff --git a/leetcode/leetcode/2048-build-array-from-permutation/2048-build-array-from-permutation.java b/leetcode/leetcode/2048-build-array-from-permutation/2048-build-array-from-permutation.java
new file mode 100644
index 0000000..419b088
--- /dev/null
+++ b/leetcode/leetcode/2048-build-array-from-permutation/2048-build-array-from-permutation.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int[] buildArray(int[] nums) {
+        int[] result = new int[nums.length];
+        int counter =0;
+        while(counter<nums.length){
+            result[counter] = nums[nums[counter]];
+            counter++;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2048-build-array-from-permutation/README.md b/leetcode/leetcode/2048-build-array-from-permutation/README.md
new file mode 100644
index 0000000..b70722c
--- /dev/null
+++ b/leetcode/leetcode/2048-build-array-from-permutation/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/build-array-from-permutation">2048. Build Array from Permutation</a></h2><h3>Easy</h3><hr><p>Given a <strong>zero-based permutation</strong> <code>nums</code> (<strong>0-indexed</strong>), build an array <code>ans</code> of the <strong>same length</strong> where <code>ans[i] = nums[nums[i]]</code> for each <code>0 &lt;= i &lt; nums.length</code> and return it.</p>
+
+<p>A <strong>zero-based permutation</strong> <code>nums</code> is an array of <strong>distinct</strong> integers from <code>0</code> to <code>nums.length - 1</code> (<strong>inclusive</strong>).</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,2,1,5,3,4]
+<strong>Output:</strong> [0,1,2,4,5,3]<strong>
+Explanation:</strong> The array ans is built as follows: 
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
+    = [0,1,2,4,5,3]</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [5,0,1,2,3,4]
+<strong>Output:</strong> [4,5,0,1,2,3]
+<strong>Explanation:</strong> The array ans is built as follows:
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
+    = [4,5,0,1,2,3]</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums[i] &lt; nums.length</code></li>
+	<li>The elements in <code>nums</code> are <strong>distinct</strong>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong> Can you solve it without using an extra space (i.e., <code>O(1)</code> memory)?</p>
diff --git a/leetcode/leetcode/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points.java b/leetcode/leetcode/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points.java
new file mode 100644
index 0000000..d026494
--- /dev/null
+++ b/leetcode/leetcode/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points.java
@@ -0,0 +1,48 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public int[] nodesBetweenCriticalPoints(ListNode head) {
+        int[] ans = {-1,-1};
+        int min = Integer.MAX_VALUE;
+        int max = 0;
+        int firstCriticalValIndex = -1;
+        int prevToLastIndex = -1;
+        int lastCriticalValIndex = -1;
+        int prevVal = head.val;
+        head = head.next;
+        int currentVal = head.val;
+        int nextVal = -1;
+        int currentIndex = 1;
+        while(head.next!=null){
+            nextVal = head.next.val;
+            if((currentVal>prevVal && currentVal>nextVal) || (currentVal<prevVal&& currentVal<nextVal)){
+                if(firstCriticalValIndex==-1){
+                    firstCriticalValIndex = currentIndex;
+                }
+                prevToLastIndex = lastCriticalValIndex;
+                lastCriticalValIndex = Math.max(lastCriticalValIndex,currentIndex);
+                if(prevToLastIndex!=lastCriticalValIndex && prevToLastIndex!=-1 ){
+                    min = Math.min(min,lastCriticalValIndex-prevToLastIndex);
+                }
+            
+            }
+            prevVal =currentVal;
+            currentVal = nextVal;
+            head= head.next;
+            currentIndex++;
+        }
+        if(firstCriticalValIndex!=lastCriticalValIndex && lastCriticalValIndex!=-1){
+            ans[0] = min;
+            ans[1] = lastCriticalValIndex-firstCriticalValIndex;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points/README.md b/leetcode/leetcode/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points/README.md
new file mode 100644
index 0000000..530c9a2
--- /dev/null
+++ b/leetcode/leetcode/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points/README.md
@@ -0,0 +1,50 @@
+<h2><a href="https://leetcode.com/problems/find-the-minimum-and-maximum-number-of-nodes-between-critical-points/">2058. Find the Minimum and Maximum Number of Nodes Between Critical Points</a></h2><h3>Medium</h3><hr><div><p>A <strong>critical point</strong> in a linked list is defined as <strong>either</strong> a <strong>local maxima</strong> or a <strong>local minima</strong>.</p>
+
+<p>A node is a <strong>local maxima</strong> if the current node has a value <strong>strictly greater</strong> than the previous node and the next node.</p>
+
+<p>A node is a <strong>local minima</strong> if the current node has a value <strong>strictly smaller</strong> than the previous node and the next node.</p>
+
+<p>Note that a node can only be a local maxima/minima if there exists <strong>both</strong> a previous node and a next node.</p>
+
+<p>Given a linked list <code>head</code>, return <em>an array of length 2 containing </em><code>[minDistance, maxDistance]</code><em> where </em><code>minDistance</code><em> is the <strong>minimum distance</strong> between <strong>any&nbsp;two distinct</strong> critical points and </em><code>maxDistance</code><em> is the <strong>maximum distance</strong> between <strong>any&nbsp;two distinct</strong> critical points. If there are <strong>fewer</strong> than two critical points, return </em><code>[-1, -1]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/10/13/a1.png" style="width: 148px; height: 55px;">
+<pre><strong>Input:</strong> head = [3,1]
+<strong>Output:</strong> [-1,-1]
+<strong>Explanation:</strong> There are no critical points in [3,1].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/10/13/a2.png" style="width: 624px; height: 46px;">
+<pre><strong>Input:</strong> head = [5,3,1,2,5,1,2]
+<strong>Output:</strong> [1,3]
+<strong>Explanation:</strong> There are three critical points:
+- [5,3,<strong><u>1</u></strong>,2,5,1,2]: The third node is a local minima because 1 is less than 3 and 2.
+- [5,3,1,2,<u><strong>5</strong></u>,1,2]: The fifth node is a local maxima because 5 is greater than 2 and 1.
+- [5,3,1,2,5,<u><strong>1</strong></u>,2]: The sixth node is a local minima because 1 is less than 5 and 2.
+The minimum distance is between the fifth and the sixth node. minDistance = 6 - 5 = 1.
+The maximum distance is between the third and the sixth node. maxDistance = 6 - 3 = 3.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/10/14/a5.png" style="width: 624px; height: 39px;">
+<pre><strong>Input:</strong> head = [1,3,2,2,3,2,2,2,7]
+<strong>Output:</strong> [3,3]
+<strong>Explanation:</strong> There are two critical points:
+- [1,<u><strong>3</strong></u>,2,2,3,2,2,2,7]: The second node is a local maxima because 3 is greater than 1 and 2.
+- [1,3,2,2,<u><strong>3</strong></u>,2,2,2,7]: The fifth node is a local maxima because 3 is greater than 2 and 2.
+Both the minimum and maximum distances are between the second and the fifth node.
+Thus, minDistance and maxDistance is 5 - 2 = 3.
+Note that the last node is not considered a local maxima because it does not have a next node.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[2, 10<sup>5</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2085-count-common-words-with-one-occurrence/2085-count-common-words-with-one-occurrence.java b/leetcode/leetcode/2085-count-common-words-with-one-occurrence/2085-count-common-words-with-one-occurrence.java
new file mode 100644
index 0000000..6de5c60
--- /dev/null
+++ b/leetcode/leetcode/2085-count-common-words-with-one-occurrence/2085-count-common-words-with-one-occurrence.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int countWords(String[] words1, String[] words2) {
+        HashMap<String,Integer> map = new HashMap<>();
+        HashSet<String> ignore = new HashSet<>();
+        for(int i = 0;i<words1.length;i++){
+            if(ignore.contains(words1[i])) continue;
+            if(map.containsKey(words1[i])){
+                ignore.add(words1[i]);
+                map.remove(words1[i]);
+            }else{
+                map.put(words1[i],1);
+            }
+        }
+        int ans = 0;
+        for(int i = 0;i<words2.length;i++){
+            if(ignore.contains(words2[i])) continue;
+            int freq = map.getOrDefault(words2[i],0);
+            if(freq == 2){
+                ignore.add(words2[i]);
+                map.remove(words2[i]);
+                ans--;
+            }else if(freq==1){
+                map.put(words2[i],freq+1);
+                ans++;
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2085-count-common-words-with-one-occurrence/README.md b/leetcode/leetcode/2085-count-common-words-with-one-occurrence/README.md
new file mode 100644
index 0000000..0c3b6a6
--- /dev/null
+++ b/leetcode/leetcode/2085-count-common-words-with-one-occurrence/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/count-common-words-with-one-occurrence/">2085. Count Common Words With One Occurrence</a></h2><h3>Easy</h3><hr><div><p>Given two string arrays <code>words1</code> and <code>words2</code>, return <em>the number of strings that appear <strong>exactly once</strong> in <b>each</b>&nbsp;of the two arrays.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> words1 = ["leetcode","is","amazing","as","is"], words2 = ["amazing","leetcode","is"]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+- "leetcode" appears exactly once in each of the two arrays. We count this string.
+- "amazing" appears exactly once in each of the two arrays. We count this string.
+- "is" appears in each of the two arrays, but there are 2 occurrences of it in words1. We do not count this string.
+- "as" appears once in words1, but does not appear in words2. We do not count this string.
+Thus, there are 2 strings that appear exactly once in each of the two arrays.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words1 = ["b","bb","bbb"], words2 = ["a","aa","aaa"]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There are no strings that appear in each of the two arrays.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> words1 = ["a","ab"], words2 = ["a","a","a","ab"]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The only string that appears exactly once in each of the two arrays is "ab".
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= words1.length, words2.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= words1[i].length, words2[j].length &lt;= 30</code></li>
+	<li><code>words1[i]</code> and <code>words2[j]</code> consists only of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2089-find-target-indices-after-sorting-array/2089-find-target-indices-after-sorting-array.java b/leetcode/leetcode/2089-find-target-indices-after-sorting-array/2089-find-target-indices-after-sorting-array.java
new file mode 100644
index 0000000..dcc10a6
--- /dev/null
+++ b/leetcode/leetcode/2089-find-target-indices-after-sorting-array/2089-find-target-indices-after-sorting-array.java
@@ -0,0 +1,19 @@
+class Solution {
+    public List<Integer> targetIndices(int[] nums, int target) {
+        int low = 0;
+        int high = nums.length-1;
+        for(int num: nums){
+            if(num<target){
+                low++;
+            }else if(num>target){
+                high--;
+            }
+        }
+        List<Integer> list = new ArrayList<>();
+        while(low<=high){
+            list.add(low);
+            low++;
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2089-find-target-indices-after-sorting-array/NOTES.md b/leetcode/leetcode/2089-find-target-indices-after-sorting-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2089-find-target-indices-after-sorting-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2090-number-of-ways-to-arrive-at-destination/2090-number-of-ways-to-arrive-at-destination.java b/leetcode/leetcode/2090-number-of-ways-to-arrive-at-destination/2090-number-of-ways-to-arrive-at-destination.java
new file mode 100644
index 0000000..3e7b30c
--- /dev/null
+++ b/leetcode/leetcode/2090-number-of-ways-to-arrive-at-destination/2090-number-of-ways-to-arrive-at-destination.java
@@ -0,0 +1,71 @@
+class Solution {
+
+    private static final int MOD = 1_000_000_007;
+
+    public int countPaths(int n, int[][] roads) {
+        long[][][] dp = new long[n][n][2];
+
+        // dp[src][dest][0] stores the minimum time between src and dest
+        // dp[src][dest][1] stores the number of ways to reach dest from src
+        // with the minimum time
+
+        // Initialize the dp table
+        for (int src = 0; src < n; src++) {
+            for (int dest = 0; dest < n; dest++) {
+                if (src != dest) {
+                    // Set a large initial time
+                    dp[src][dest][0] = (long) 1e12;
+                    // No paths yet
+                    dp[src][dest][1] = 0;
+                } else {
+                    // Distance from a node to itself is 0
+                    dp[src][dest][0] = 0;
+                    // Only one trivial way (staying at the node)
+                    dp[src][dest][1] = 1;
+                }
+            }
+        }
+
+        // Initialize direct roads from the input
+        for (int[] road : roads) {
+            int startNode = road[0], endNode = road[1], travelTime = road[2];
+            dp[startNode][endNode][0] = travelTime;
+            dp[endNode][startNode][0] = travelTime;
+            // There is one direct path
+            dp[startNode][endNode][1] = 1;
+            // Since the roads are bidirectional
+            dp[endNode][startNode][1] = 1;
+        }
+
+        // Apply the Floyd-Warshall algorithm to compute shortest paths
+        // Intermediate node
+        for (int mid = 0; mid < n; mid++) {
+            // Starting node
+            for (int src = 0; src < n; src++) {
+                // Destination node
+                for (int dest = 0; dest < n; dest++) {
+                    // Avoid self-loops
+                    if (src != mid && dest != mid) {
+                        long newTime = dp[src][mid][0] + dp[mid][dest][0];
+
+                        if (newTime < dp[src][dest][0]) {
+                            // Found a shorter path
+                            dp[src][dest][0] = newTime;
+                            dp[src][dest][1] =
+                                (dp[src][mid][1] * dp[mid][dest][1]) % MOD;
+                        } else if (newTime == dp[src][dest][0]) {
+                            // Another way to achieve the same shortest time
+                            dp[src][dest][1] =
+                                (dp[src][dest][1] +
+                                    dp[src][mid][1] * dp[mid][dest][1]) %
+                                MOD;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Return the number of shortest paths from node (n-1) to node 0
+        return (int) dp[n - 1][0][1];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2090-number-of-ways-to-arrive-at-destination/README.md b/leetcode/leetcode/2090-number-of-ways-to-arrive-at-destination/README.md
new file mode 100644
index 0000000..73a0faa
--- /dev/null
+++ b/leetcode/leetcode/2090-number-of-ways-to-arrive-at-destination/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/number-of-ways-to-arrive-at-destination">2090. Number of Ways to Arrive at Destination</a></h2><h3>Medium</h3><hr><p>You are in a city that consists of <code>n</code> intersections numbered from <code>0</code> to <code>n - 1</code> with <strong>bi-directional</strong> roads between some intersections. The inputs are generated such that you can reach any intersection from any other intersection and that there is at most one road between any two intersections.</p>
+
+<p>You are given an integer <code>n</code> and a 2D integer array <code>roads</code> where <code>roads[i] = [u<sub>i</sub>, v<sub>i</sub>, time<sub>i</sub>]</code> means that there is a road between intersections <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> that takes <code>time<sub>i</sub></code> minutes to travel. You want to know in how many ways you can travel from intersection <code>0</code> to intersection <code>n - 1</code> in the <strong>shortest amount of time</strong>.</p>
+
+<p>Return <em>the <strong>number of ways</strong> you can arrive at your destination in the <strong>shortest amount of time</strong></em>. Since the answer may be large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2025/02/14/1976_corrected.png" style="width: 255px; height: 400px;" />
+<pre>
+<strong>Input:</strong> n = 7, roads = [[0,6,7],[0,1,2],[1,2,3],[1,3,3],[6,3,3],[3,5,1],[6,5,1],[2,5,1],[0,4,5],[4,6,2]]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The shortest amount of time it takes to go from intersection 0 to intersection 6 is 7 minutes.
+The four ways to get there in 7 minutes are:
+- 0 ➝ 6
+- 0 ➝ 4 ➝ 6
+- 0 ➝ 1 ➝ 2 ➝ 5 ➝ 6
+- 0 ➝ 1 ➝ 3 ➝ 5 ➝ 6
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 2, roads = [[1,0,10]]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> There is only one way to go from intersection 0 to intersection 1, and it takes 10 minutes.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 200</code></li>
+	<li><code>n - 1 &lt;= roads.length &lt;= n * (n - 1) / 2</code></li>
+	<li><code>roads[i].length == 3</code></li>
+	<li><code>0 &lt;= u<sub>i</sub>, v<sub>i</sub> &lt;= n - 1</code></li>
+	<li><code>1 &lt;= time<sub>i</sub> &lt;= 10<sup>9</sup></code></li>
+	<li><code>u<sub>i </sub>!= v<sub>i</sub></code></li>
+	<li>There is at most one road connecting any two intersections.</li>
+	<li>You can reach any intersection from any other intersection.</li>
+</ul>
diff --git a/leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/2091-removing-minimum-and-maximum-from-array.java b/leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/2091-removing-minimum-and-maximum-from-array.java
new file mode 100644
index 0000000..eae6d40
--- /dev/null
+++ b/leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/2091-removing-minimum-and-maximum-from-array.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int minimumDeletions(int[] nums) {
+        if(nums.length == 1) return 1;
+        int max = 0;
+        int min = 0;
+        int len = nums.length;
+        for(int i = 0;i<len;i++){
+            if(nums[i]<nums[min]) min  = i;
+            if(nums[i]>nums[max]) max  = i;
+        }
+        if(min>max){
+            int temp = min;
+            min = max;
+            max = temp;
+        }
+        return Math.min(max+1,Math.min(len - min, min + 1 + len - max));
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/NOTES.md b/leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/README.md b/leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/README.md
new file mode 100644
index 0000000..01de99c
--- /dev/null
+++ b/leetcode/leetcode/2091-removing-minimum-and-maximum-from-array/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/removing-minimum-and-maximum-from-array/">2091. Removing Minimum and Maximum From Array</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> array of <strong>distinct</strong> integers <code>nums</code>.</p>
+
+<p>There is an element in <code>nums</code> that has the <strong>lowest</strong> value and an element that has the <strong>highest</strong> value. We call them the <strong>minimum</strong> and <strong>maximum</strong> respectively. Your goal is to remove <strong>both</strong> these elements from the array.</p>
+
+<p>A <strong>deletion</strong> is defined as either removing an element from the <strong>front</strong> of the array or removing an element from the <strong>back</strong> of the array.</p>
+
+<p>Return <em>the <strong>minimum</strong> number of deletions it would take to remove <strong>both</strong> the minimum and maximum element from the array.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,<u><strong>10</strong></u>,7,5,4,<u><strong>1</strong></u>,8,6]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> 
+The minimum element in the array is nums[5], which is 1.
+The maximum element in the array is nums[1], which is 10.
+We can remove both the minimum and maximum by removing 2 elements from the front and 3 elements from the back.
+This results in 2 + 3 = 5 deletions, which is the minimum number possible.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,<u><strong>-4</strong></u>,<u><strong>19</strong></u>,1,8,-2,-3,5]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 
+The minimum element in the array is nums[1], which is -4.
+The maximum element in the array is nums[2], which is 19.
+We can remove both the minimum and maximum by removing 3 elements from the front.
+This results in only 3 deletions, which is the minimum number possible.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [<u><strong>101</strong></u>]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong>  
+There is only one element in the array, which makes it both the minimum and maximum element.
+We can remove it with 1 deletion.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>5</sup> &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+	<li>The integers in <code>nums</code> are <strong>distinct</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/21-merge-two-sorted-lists/21-merge-two-sorted-lists.java b/leetcode/leetcode/21-merge-two-sorted-lists/21-merge-two-sorted-lists.java
new file mode 100644
index 0000000..c669178
--- /dev/null
+++ b/leetcode/leetcode/21-merge-two-sorted-lists/21-merge-two-sorted-lists.java
@@ -0,0 +1,44 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+      
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2){
+        if(l1==null) return l2;
+        if(l2==null) return l1;
+        if(l1.val>l2.val){
+            ListNode temp = l1;
+            l1 = l2;
+            l2 = temp;
+        }
+        ListNode res = l1;
+        ListNode temp  = l1;
+        l1 = l1.next;
+        while(l2!=null){
+            if(l1 == null){
+                temp.next = l2;
+                break;
+            }
+            if(l1.val>l2.val){
+                temp.next = l2;
+                l2 =l2.next;
+                temp = temp.next;
+                temp.next = l1;
+            }else{
+                temp = l1;
+                l1 = l1.next;
+            }
+        }
+        return res;
+        
+    }
+    
+    
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/21-merge-two-sorted-lists/NOTES.md b/leetcode/leetcode/21-merge-two-sorted-lists/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/21-merge-two-sorted-lists/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2107-find-unique-binary-string/2107-find-unique-binary-string.java b/leetcode/leetcode/2107-find-unique-binary-string/2107-find-unique-binary-string.java
new file mode 100644
index 0000000..287e716
--- /dev/null
+++ b/leetcode/leetcode/2107-find-unique-binary-string/2107-find-unique-binary-string.java
@@ -0,0 +1,47 @@
+class Solution {
+    public int convertToDecimal(String s){
+        int num = 0;
+        int pow_of_two = 1;
+        for(int i = s.length()-1;i!=-1;i--){
+            if(s.charAt(i) == '0'){
+                pow_of_two = pow_of_two * 2;
+                continue;
+            }
+            num = num + pow_of_two;
+            pow_of_two = pow_of_two * 2;
+
+        }
+        return num;
+    }
+    public String convertToBinary(int num, int bits){
+        StringBuilder sb = new StringBuilder();
+        for(int i = 0;i<bits;i++){
+            sb.append('0');
+        }
+        int index = bits - 1;
+        while(num!=0){
+            if(num%2==0){
+                sb.setCharAt(index,'0');
+            }else{
+                sb.setCharAt(index,'1');
+            }
+            index--;
+            num = num/2;
+        }
+        return sb.toString();
+    }
+    public String findDifferentBinaryString(String[] nums) {   
+        HashSet<Integer> set = new HashSet<>();
+        for(int i = 0;i<nums.length;i++){
+            set.add(convertToDecimal(nums[i]));
+        }
+        int targetNum = 0;
+        for(int i = 0;i<nums.length+1;i++){
+            if(!set.contains(i)){
+                targetNum = i;
+                break;
+            }
+        }
+        return convertToBinary(targetNum,nums.length);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2107-find-unique-binary-string/README.md b/leetcode/leetcode/2107-find-unique-binary-string/README.md
new file mode 100644
index 0000000..b0b6e30
--- /dev/null
+++ b/leetcode/leetcode/2107-find-unique-binary-string/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/find-unique-binary-string">2107. Find Unique Binary String</a></h2><h3>Medium</h3><hr><p>Given an array of strings <code>nums</code> containing <code>n</code> <strong>unique</strong> binary strings each of length <code>n</code>, return <em>a binary string of length </em><code>n</code><em> that <strong>does not appear</strong> in </em><code>nums</code><em>. If there are multiple answers, you may return <strong>any</strong> of them</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [&quot;01&quot;,&quot;10&quot;]
+<strong>Output:</strong> &quot;11&quot;
+<strong>Explanation:</strong> &quot;11&quot; does not appear in nums. &quot;00&quot; would also be correct.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [&quot;00&quot;,&quot;01&quot;]
+<strong>Output:</strong> &quot;11&quot;
+<strong>Explanation:</strong> &quot;11&quot; does not appear in nums. &quot;10&quot; would also be correct.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [&quot;111&quot;,&quot;011&quot;,&quot;001&quot;]
+<strong>Output:</strong> &quot;101&quot;
+<strong>Explanation:</strong> &quot;101&quot; does not appear in nums. &quot;000&quot;, &quot;010&quot;, &quot;100&quot;, and &quot;110&quot; would also be correct.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 16</code></li>
+	<li><code>nums[i].length == n</code></li>
+	<li><code>nums[i] </code>is either <code>&#39;0&#39;</code> or <code>&#39;1&#39;</code>.</li>
+	<li>All the strings of <code>nums</code> are <strong>unique</strong>.</li>
+</ul>
diff --git a/leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/2131-longest-palindrome-by-concatenating-two-letter-words.java b/leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/2131-longest-palindrome-by-concatenating-two-letter-words.java
new file mode 100644
index 0000000..3ca2952
--- /dev/null
+++ b/leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/2131-longest-palindrome-by-concatenating-two-letter-words.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int longestPalindrome(String[] words) {
+        HashMap<String,Integer> map = new HashMap<>(words.length);
+        int res = 0;
+        int unpaired = 0;
+        for(String s: words){
+            if(s.charAt(0) == s.charAt(1)){
+                if(map.containsKey(s) && map.get(s)>0){
+                    unpaired--;
+                    res+=4;
+                    map.put(s,map.getOrDefault(s,1)-1);
+                }else{
+                    unpaired++;
+                    map.put(s, map.getOrDefault(s,0) + 1);
+                }
+            }else{
+                String rev  = Character.toString(s.charAt(1)) +  Character.toString(s.charAt(0));
+                if(map.containsKey(rev) && map.getOrDefault(rev,0) > 0){
+                    res+=4;
+                    map.put(rev,map.getOrDefault(rev,1) -1);
+                }else{
+                    map.put(s,map.getOrDefault(s,0)+1);
+                }
+            }
+        }
+        if(unpaired>0) res+=2;
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/NOTES.md b/leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/README.md b/leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/README.md
new file mode 100644
index 0000000..57acd05
--- /dev/null
+++ b/leetcode/leetcode/2131-longest-palindrome-by-concatenating-two-letter-words/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/">2131. Longest Palindrome by Concatenating Two Letter Words</a></h2><h3>Medium</h3><hr><div><p>You are given an array of strings <code>words</code>. Each element of <code>words</code> consists of <strong>two</strong> lowercase English letters.</p>
+
+<p>Create the <strong>longest possible palindrome</strong> by selecting some elements from <code>words</code> and concatenating them in <strong>any order</strong>. Each element can be selected <strong>at most once</strong>.</p>
+
+<p>Return <em>the <strong>length</strong> of the longest palindrome that you can create</em>. If it is impossible to create any palindrome, return <code>0</code>.</p>
+
+<p>A <strong>palindrome</strong> is a string that reads the same forward and backward.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> words = ["lc","cl","gg"]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> One longest palindrome is "lc" + "gg" + "cl" = "lcggcl", of length 6.
+Note that "clgglc" is another longest palindrome that can be created.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words = ["ab","ty","yt","lc","cl","ab"]
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> One longest palindrome is "ty" + "lc" + "cl" + "yt" = "tylcclyt", of length 8.
+Note that "lcyttycl" is another longest palindrome that can be created.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> words = ["cc","ll","xx"]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> One longest palindrome is "cc", of length 2.
+Note that "ll" is another longest palindrome that can be created, and so is "xx".
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= words.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>words[i].length == 2</code></li>
+	<li><code>words[i]</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/2133-check-if-every-row-and-column-contains-all-numbers.java b/leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/2133-check-if-every-row-and-column-contains-all-numbers.java
new file mode 100644
index 0000000..7849913
--- /dev/null
+++ b/leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/2133-check-if-every-row-and-column-contains-all-numbers.java
@@ -0,0 +1,19 @@
+class Solution {
+    public boolean checkValid(int[][] matrix) {
+        int n = matrix.length;
+        int sum = (n * (n+1))/2;
+        for(int i = 0;i<n;i++){
+            int temp = 0;
+            int temp2 = 0;
+            HashSet<Integer> map = new HashSet<>(n);
+            for(int j = 0;j<n;j++){
+                map.add(matrix[i][j]);
+                temp+=matrix[i][j];
+                temp2+=matrix[j][i];
+            }
+            if(temp!=sum || temp2!=sum) return false;
+            if(map.size()!=n) return false;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/NOTES.md b/leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/README.md b/leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/README.md
new file mode 100644
index 0000000..1276671
--- /dev/null
+++ b/leetcode/leetcode/2133-check-if-every-row-and-column-contains-all-numbers/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/">2133. Check if Every Row and Column Contains All Numbers</a></h2><h3>Easy</h3><hr><div><p>An <code>n x n</code> matrix is <strong>valid</strong> if every row and every column contains <strong>all</strong> the integers from <code>1</code> to <code>n</code> (<strong>inclusive</strong>).</p>
+
+<p>Given an <code>n x n</code> integer matrix <code>matrix</code>, return <code>true</code> <em>if the matrix is <strong>valid</strong>.</em> Otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/21/example1drawio.png" style="width: 250px; height: 251px;">
+<pre><strong>Input:</strong> matrix = [[1,2,3],[3,1,2],[2,3,1]]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> In this case, n = 3, and every row and column contains the numbers 1, 2, and 3.
+Hence, we return true.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/21/example2drawio.png" style="width: 250px; height: 251px;">
+<pre><strong>Input:</strong> matrix = [[1,1,1],[1,2,3],[1,2,3]]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> In this case, n = 3, but the first row and the first column do not contain the numbers 2 or 3.
+Hence, we return false.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == matrix.length == matrix[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>1 &lt;= matrix[i][j] &lt;= n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2138-divide-a-string-into-groups-of-size-k/2138-divide-a-string-into-groups-of-size-k.java b/leetcode/leetcode/2138-divide-a-string-into-groups-of-size-k/2138-divide-a-string-into-groups-of-size-k.java
new file mode 100644
index 0000000..8313743
--- /dev/null
+++ b/leetcode/leetcode/2138-divide-a-string-into-groups-of-size-k/2138-divide-a-string-into-groups-of-size-k.java
@@ -0,0 +1,20 @@
+class Solution {
+    public String[] divideString(String s, int k, char fill) {
+        int len = s.length();
+        int size = len/k;
+        if(len%k != 0) size++; 
+        String[] res = new String[size];
+        int start = 0;
+        int end = k;
+        for(int i = 0;start<len;i++){
+            res[i] =  s.substring(start,Math.min(end,len));
+            while(res[i].length()!=k){
+                res[i]+=fill;
+            }
+            start+=k;
+            end+=k;
+
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2138-divide-a-string-into-groups-of-size-k/README.md b/leetcode/leetcode/2138-divide-a-string-into-groups-of-size-k/README.md
new file mode 100644
index 0000000..00c4a73
--- /dev/null
+++ b/leetcode/leetcode/2138-divide-a-string-into-groups-of-size-k/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/divide-a-string-into-groups-of-size-k/">2138. Divide a String Into Groups of Size k</a></h2><h3>Easy</h3><hr><div><p>A string <code>s</code> can be partitioned into groups of size <code>k</code> using the following procedure:</p>
+
+<ul>
+	<li>The first group consists of the first <code>k</code> characters of the string, the second group consists of the next <code>k</code> characters of the string, and so on. Each character can be a part of <strong>exactly one</strong> group.</li>
+	<li>For the last group, if the string <strong>does not</strong> have <code>k</code> characters remaining, a character <code>fill</code> is used to complete the group.</li>
+</ul>
+
+<p>Note that the partition is done so that after removing the <code>fill</code> character from the last group (if it exists) and concatenating all the groups in order, the resultant string should be <code>s</code>.</p>
+
+<p>Given the string <code>s</code>, the size of each group <code>k</code> and the character <code>fill</code>, return <em>a string array denoting the <strong>composition of every group</strong> </em><code>s</code><em> has been divided into, using the above procedure</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "abcdefghi", k = 3, fill = "x"
+<strong>Output:</strong> ["abc","def","ghi"]
+<strong>Explanation:</strong>
+The first 3 characters "abc" form the first group.
+The next 3 characters "def" form the second group.
+The last 3 characters "ghi" form the third group.
+Since all groups can be completely filled by characters from the string, we do not need to use fill.
+Thus, the groups formed are "abc", "def", and "ghi".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "abcdefghij", k = 3, fill = "x"
+<strong>Output:</strong> ["abc","def","ghi","jxx"]
+<strong>Explanation:</strong>
+Similar to the previous example, we are forming the first three groups "abc", "def", and "ghi".
+For the last group, we can only use the character 'j' from the string. To complete this group, we add 'x' twice.
+Thus, the 4 groups formed are "abc", "def", "ghi", and "jxx".
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 100</code></li>
+	<li><code>s</code> consists of lowercase English letters only.</li>
+	<li><code>1 &lt;= k &lt;= 100</code></li>
+	<li><code>fill</code> is a lowercase English letter.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2139-minimum-moves-to-reach-target-score/2139-minimum-moves-to-reach-target-score.java b/leetcode/leetcode/2139-minimum-moves-to-reach-target-score/2139-minimum-moves-to-reach-target-score.java
new file mode 100644
index 0000000..7fe0e1a
--- /dev/null
+++ b/leetcode/leetcode/2139-minimum-moves-to-reach-target-score/2139-minimum-moves-to-reach-target-score.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int minMoves(int target, int maxDoubles) {
+        int res = 0;
+        while(target!=1){
+            if(maxDoubles==0) break;
+            if(target%2==0){
+                target = target/2;
+                target++;
+                maxDoubles--;
+            }
+            target--;
+            res++;
+        }
+        return res + target -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2139-minimum-moves-to-reach-target-score/NOTES.md b/leetcode/leetcode/2139-minimum-moves-to-reach-target-score/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2139-minimum-moves-to-reach-target-score/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2139-minimum-moves-to-reach-target-score/README.md b/leetcode/leetcode/2139-minimum-moves-to-reach-target-score/README.md
new file mode 100644
index 0000000..af413b6
--- /dev/null
+++ b/leetcode/leetcode/2139-minimum-moves-to-reach-target-score/README.md
@@ -0,0 +1,52 @@
+<h2><a href="https://leetcode.com/problems/minimum-moves-to-reach-target-score/">2139. Minimum Moves to Reach Target Score</a></h2><h3>Medium</h3><hr><div><p>You are playing a game with integers. You start with the integer <code>1</code> and you want to reach the integer <code>target</code>.</p>
+
+<p>In one move, you can either:</p>
+
+<ul>
+	<li><strong>Increment</strong> the current integer by one (i.e., <code>x = x + 1</code>).</li>
+	<li><strong>Double</strong> the current integer (i.e., <code>x = 2 * x</code>).</li>
+</ul>
+
+<p>You can use the <strong>increment</strong> operation <strong>any</strong> number of times, however, you can only use the <strong>double</strong> operation <strong>at most</strong> <code>maxDoubles</code> times.</p>
+
+<p>Given the two integers <code>target</code> and <code>maxDoubles</code>, return <em>the minimum number of moves needed to reach </em><code>target</code><em> starting with </em><code>1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> target = 5, maxDoubles = 0
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Keep incrementing by 1 until you reach target.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> target = 19, maxDoubles = 2
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Initially, x = 1
+Increment 3 times so x = 4
+Double once so x = 8
+Increment once so x = 9
+Double again so x = 18
+Increment once so x = 19
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> target = 10, maxDoubles = 4
+<strong>Output:</strong> 4
+<strong>Explanation:</strong><b> </b>Initially, x = 1
+Increment once so x = 2
+Double once so x = 4
+Increment once so x = 5
+Double again so x = 10
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= target &lt;= 10<sup>9</sup></code></li>
+	<li><code>0 &lt;= maxDoubles &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/2148-count-elements-with-strictly-smaller-and-greater-elements.java b/leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/2148-count-elements-with-strictly-smaller-and-greater-elements.java
new file mode 100644
index 0000000..bdeab38
--- /dev/null
+++ b/leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/2148-count-elements-with-strictly-smaller-and-greater-elements.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int countElements(int[] nums) {
+
+        int max = Integer.MIN_VALUE;
+        int min = Integer.MAX_VALUE;
+        int countMax = 0;
+        int countMin = 0;
+        for(int num: nums){
+            if(num>max){
+                max = num;
+                countMax = 1;
+            }else if(num == max) countMax++;
+            if(num<min){
+                min = num;
+                countMin = 1;
+            }else if(num == min) countMin++;
+        }
+        if(max == min){
+            return nums.length - (countMax);
+        }
+        return nums.length - (countMax+countMin);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/NOTES.md b/leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/README.md b/leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/README.md
new file mode 100644
index 0000000..e5e3089
--- /dev/null
+++ b/leetcode/leetcode/2148-count-elements-with-strictly-smaller-and-greater-elements/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/count-elements-with-strictly-smaller-and-greater-elements/">2148. Count Elements With Strictly Smaller and Greater Elements </a></h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code>, return <em>the number of elements that have <strong>both</strong> a strictly smaller and a strictly greater element appear in </em><code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [11,7,2,15]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The element 7 has the element 2 strictly smaller than it and the element 11 strictly greater than it.
+Element 11 has element 7 strictly smaller than it and element 15 strictly greater than it.
+In total there are 2 elements having both a strictly smaller and a strictly greater element appear in <code>nums</code>.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-3,3,3,90]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The element 3 has the element -3 strictly smaller than it and the element 90 strictly greater than it.
+Since there are two elements with the value 3, in total there are 2 elements having both a strictly smaller and a strictly greater element appear in <code>nums</code>.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>-10<sup>5</sup> &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2149-rearrange-array-elements-by-sign/2149-rearrange-array-elements-by-sign.java b/leetcode/leetcode/2149-rearrange-array-elements-by-sign/2149-rearrange-array-elements-by-sign.java
new file mode 100644
index 0000000..ac4e2f2
--- /dev/null
+++ b/leetcode/leetcode/2149-rearrange-array-elements-by-sign/2149-rearrange-array-elements-by-sign.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int[] rearrangeArray(int[] nums) {
+        int neg = 0;
+        int pos = 0;
+        int[] result = new int[nums.length];
+        for(int i = 0;i<nums.length;i++){
+            int j = 0;
+            if(i%2==0) j = pos;
+            else j = neg;
+            for(;j<nums.length;j++){
+                if(nums[j] == 0) continue;
+                if(i%2 == 0){
+                    if(nums[j]>0){
+                        pos = j;
+                        break;
+                    } 
+                }else{
+                    if(nums[j]<0){
+                        neg = j;
+                        break;
+                    }
+                }
+            }
+            result[i] = nums[j];
+            nums[j]=0;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2149-rearrange-array-elements-by-sign/NOTES.md b/leetcode/leetcode/2149-rearrange-array-elements-by-sign/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2149-rearrange-array-elements-by-sign/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2149-rearrange-array-elements-by-sign/README.md b/leetcode/leetcode/2149-rearrange-array-elements-by-sign/README.md
new file mode 100644
index 0000000..2f3191e
--- /dev/null
+++ b/leetcode/leetcode/2149-rearrange-array-elements-by-sign/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/rearrange-array-elements-by-sign/">2149. Rearrange Array Elements by Sign</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> of <strong>even</strong> length consisting of an <strong>equal</strong> number of positive and negative integers.</p>
+
+<p>You should <strong>rearrange</strong> the elements of <code>nums</code> such that the modified array follows the given conditions:</p>
+
+<ol>
+	<li>Every <strong>consecutive pair</strong> of integers have <strong>opposite signs</strong>.</li>
+	<li>For all integers with the same sign, the <strong>order</strong> in which they were present in <code>nums</code> is <strong>preserved</strong>.</li>
+	<li>The rearranged array begins with a positive integer.</li>
+</ol>
+
+<p>Return <em>the modified array after rearranging the elements to satisfy the aforementioned conditions</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,1,-2,-5,2,-4]
+<strong>Output:</strong> [3,-2,1,-5,2,-4]
+<strong>Explanation:</strong>
+The positive integers in nums are [3,1,2]. The negative integers are [-2,-5,-4].
+The only possible way to rearrange them such that they satisfy all conditions is [3,-2,1,-5,2,-4].
+Other ways such as [1,-2,2,-5,3,-4], [3,1,2,-2,-5,-4], [-2,3,-5,1,-4,2] are incorrect because they do not satisfy one or more conditions.  
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,1]
+<strong>Output:</strong> [1,-1]
+<strong>Explanation:</strong>
+1 is the only positive integer and -1 the only negative integer in nums.
+So nums is rearranged to [1,-1].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 2 * 10<sup>5</sup></code></li>
+	<li><code>nums.length</code> is <strong>even</strong></li>
+	<li><code>1 &lt;= |nums[i]| &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums</code> consists of <strong>equal</strong> number of positive and negative integers.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/215-kth-largest-element-in-an-array/215-kth-largest-element-in-an-array.java b/leetcode/leetcode/215-kth-largest-element-in-an-array/215-kth-largest-element-in-an-array.java
new file mode 100644
index 0000000..68fa3f6
--- /dev/null
+++ b/leetcode/leetcode/215-kth-largest-element-in-an-array/215-kth-largest-element-in-an-array.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        for(int num: nums){
+            pq.add(num);
+            if(pq.size()>k) pq.remove();
+        }
+        return pq.remove();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/215-kth-largest-element-in-an-array/NOTES.md b/leetcode/leetcode/215-kth-largest-element-in-an-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/215-kth-largest-element-in-an-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/215-kth-largest-element-in-an-array/README.md b/leetcode/leetcode/215-kth-largest-element-in-an-array/README.md
new file mode 100644
index 0000000..827d7b7
--- /dev/null
+++ b/leetcode/leetcode/215-kth-largest-element-in-an-array/README.md
@@ -0,0 +1,20 @@
+<h2><a href="https://leetcode.com/problems/kth-largest-element-in-an-array/">215. Kth Largest Element in an Array</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <em>the</em> <code>k<sup>th</sup></code> <em>largest element in the array</em>.</p>
+
+<p>Note that it is the <code>k<sup>th</sup></code> largest element in the sorted order, not the <code>k<sup>th</sup></code> distinct element.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,1,5,6,4], k = 2
+<strong>Output:</strong> 5
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,3,1,2,4,5,5,6], k = 4
+<strong>Output:</strong> 4
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/2150-find-all-lonely-numbers-in-the-array.java b/leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/2150-find-all-lonely-numbers-in-the-array.java
new file mode 100644
index 0000000..2f00312
--- /dev/null
+++ b/leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/2150-find-all-lonely-numbers-in-the-array.java
@@ -0,0 +1,15 @@
+class Solution {
+    public List<Integer> findLonely(int[] nums) {
+        HashMap<Integer,Integer> map = new HashMap<>(nums.length);
+        for(int num: nums){
+            map.put(num,map.getOrDefault(num,0)+1);
+        }
+        List<Integer> list = new ArrayList<>(nums.length);
+        for(int num: nums){
+            if(map.get(num)==1){
+                if(!map.containsKey(num+1) && !map.containsKey(num-1)) list.add(num);
+            }
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/NOTES.md b/leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/README.md b/leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/README.md
new file mode 100644
index 0000000..0c97057
--- /dev/null
+++ b/leetcode/leetcode/2150-find-all-lonely-numbers-in-the-array/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/find-all-lonely-numbers-in-the-array/">2150. Find All Lonely Numbers in the Array</a></h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>nums</code>. A number <code>x</code> is <strong>lonely</strong> when it appears only <strong>once</strong>, and no <strong>adjacent</strong> numbers (i.e. <code>x + 1</code> and <code>x - 1)</code> appear in the array.</p>
+
+<p>Return <em><strong>all</strong> lonely numbers in </em><code>nums</code>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [10,6,5,8]
+<strong>Output:</strong> [10,8]
+<strong>Explanation:</strong> 
+- 10 is a lonely number since it appears exactly once and 9 and 11 does not appear in nums.
+- 8 is a lonely number since it appears exactly once and 7 and 9 does not appear in nums.
+- 5 is not a lonely number since 6 appears in nums and vice versa.
+Hence, the lonely numbers in nums are [10, 8].
+Note that [8, 10] may also be returned.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3,5,3]
+<strong>Output:</strong> [1,5]
+<strong>Explanation:</strong> 
+- 1 is a lonely number since it appears exactly once and 0 and 2 does not appear in nums.
+- 5 is a lonely number since it appears exactly once and 4 and 6 does not appear in nums.
+- 3 is not a lonely number since it appears twice.
+Hence, the lonely numbers in nums are [1, 5].
+Note that [5, 1] may also be returned.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2154-keep-multiplying-found-values-by-two/2154-keep-multiplying-found-values-by-two.java b/leetcode/leetcode/2154-keep-multiplying-found-values-by-two/2154-keep-multiplying-found-values-by-two.java
new file mode 100644
index 0000000..21204ce
--- /dev/null
+++ b/leetcode/leetcode/2154-keep-multiplying-found-values-by-two/2154-keep-multiplying-found-values-by-two.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int findFinalValue(int[] nums, int original) {
+        Arrays.sort(nums);
+        for(int num: nums){
+            if(num == original)
+                original = original*2;
+        }
+        return original;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2154-keep-multiplying-found-values-by-two/README.md b/leetcode/leetcode/2154-keep-multiplying-found-values-by-two/README.md
new file mode 100644
index 0000000..9c74144
--- /dev/null
+++ b/leetcode/leetcode/2154-keep-multiplying-found-values-by-two/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/keep-multiplying-found-values-by-two/">2154. Keep Multiplying Found Values by Two</a></h2><h3>Easy</h3><hr><div><p>You are given an array of integers <code>nums</code>. You are also given an integer <code>original</code> which is the first number that needs to be searched for in <code>nums</code>.</p>
+
+<p>You then do the following steps:</p>
+
+<ol>
+	<li>If <code>original</code> is found in <code>nums</code>, <strong>multiply</strong> it by two (i.e., set <code>original = 2 * original</code>).</li>
+	<li>Otherwise, <strong>stop</strong> the process.</li>
+	<li><strong>Repeat</strong> this process with the new number as long as you keep finding the number.</li>
+</ol>
+
+<p>Return <em>the <strong>final</strong> value of </em><code>original</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [5,3,6,1,12], original = 3
+<strong>Output:</strong> 24
+<strong>Explanation:</strong> 
+- 3 is found in nums. 3 is multiplied by 2 to obtain 6.
+- 6 is found in nums. 6 is multiplied by 2 to obtain 12.
+- 12 is found in nums. 12 is multiplied by 2 to obtain 24.
+- 24 is not found in nums. Thus, 24 is returned.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,7,9], original = 4
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+- 4 is not found in nums. Thus, 4 is returned.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= nums[i], original &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2160-minimum-operations-to-make-a-uni-value-grid/2160-minimum-operations-to-make-a-uni-value-grid.java b/leetcode/leetcode/2160-minimum-operations-to-make-a-uni-value-grid/2160-minimum-operations-to-make-a-uni-value-grid.java
new file mode 100644
index 0000000..51e9df6
--- /dev/null
+++ b/leetcode/leetcode/2160-minimum-operations-to-make-a-uni-value-grid/2160-minimum-operations-to-make-a-uni-value-grid.java
@@ -0,0 +1,25 @@
+class Solution {
+
+    public int minOperations(int[][] grid, int x) {
+        int[] ansArray = new int[grid.length * grid[0].length];
+        
+        int index = 0;
+        for(int i = 0;i<grid.length;i++){
+            for(int j = 0;j<grid[i].length;j++){
+                ansArray[index] = grid[i][j];
+                index++;
+            }
+        }
+        Arrays.sort(ansArray);
+        int median = ansArray[ansArray.length / 2];
+        int ans = 0;
+        int remiander = grid[0][0] % x;
+        for (int num : ansArray) {
+            if (num % x != remiander)
+                return -1;
+            ans += (Math.abs(median - num) / x);
+        }
+        return ans;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2160-minimum-operations-to-make-a-uni-value-grid/README.md b/leetcode/leetcode/2160-minimum-operations-to-make-a-uni-value-grid/README.md
new file mode 100644
index 0000000..c38f21e
--- /dev/null
+++ b/leetcode/leetcode/2160-minimum-operations-to-make-a-uni-value-grid/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/minimum-operations-to-make-a-uni-value-grid/description/?envType=daily-question&envId=2025-03-26">2160. Minimum Operations to Make a Uni-Value Grid</a></h2><h3>Medium</h3><hr><p>You are given a 2D integer <code>grid</code> of size <code>m x n</code> and an integer <code>x</code>. In one operation, you can <strong>add</strong> <code>x</code> to or <strong>subtract</strong> <code>x</code> from any element in the <code>grid</code>.</p>
+
+<p>A <strong>uni-value grid</strong> is a grid where all the elements of it are equal.</p>
+
+<p>Return <em>the <strong>minimum</strong> number of operations to make the grid <strong>uni-value</strong></em>. If it is not possible, return <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/09/21/gridtxt.png" style="width: 164px; height: 165px;" />
+<pre>
+<strong>Input:</strong> grid = [[2,4],[6,8]], x = 2
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> We can make every element equal to 4 by doing the following: 
+- Add x to 2 once.
+- Subtract x from 6 once.
+- Subtract x from 8 twice.
+A total of 4 operations were used.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/09/21/gridtxt-1.png" style="width: 164px; height: 165px;" />
+<pre>
+<strong>Input:</strong> grid = [[1,5],[2,3]], x = 1
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> We can make every element equal to 3.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/09/21/gridtxt-2.png" style="width: 164px; height: 165px;" />
+<pre>
+<strong>Input:</strong> grid = [[1,2],[3,4]], x = 2
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> It is impossible to make every element equal.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= x, grid[i][j] &lt;= 10<sup>4</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/2160-minimum-sum-of-four-digit-number-after-splitting-digits.java b/leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/2160-minimum-sum-of-four-digit-number-after-splitting-digits.java
new file mode 100644
index 0000000..380fadf
--- /dev/null
+++ b/leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/2160-minimum-sum-of-four-digit-number-after-splitting-digits.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int minimumSum(int num) {
+        int[] nums = new int[4];
+        int i = 0;
+        while(num!=0){
+            nums[i++] = num%10;
+            num = num/10;
+        }
+        Arrays.sort(nums);
+        if(nums[0] == 0 && nums[1]==0 && nums[2] == 0) return nums[3];
+        if(nums[0]==0 && nums[1]==0) return nums[2]+nums[3];
+        if(nums[0]==0) return nums[1]*10 + nums[2] + nums[3];
+        return nums[0]*10+nums[3] + nums[1]*10 + nums[2];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/NOTES.md b/leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/README.md b/leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/README.md
new file mode 100644
index 0000000..c7f1abb
--- /dev/null
+++ b/leetcode/leetcode/2160-minimum-sum-of-four-digit-number-after-splitting-digits/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/minimum-sum-of-four-digit-number-after-splitting-digits/">2160. Minimum Sum of Four Digit Number After Splitting Digits</a></h2><h3>Easy</h3><hr><div><p>You are given a <strong>positive</strong> integer <code>num</code> consisting of exactly four digits. Split <code>num</code> into two new integers <code>new1</code> and <code>new2</code> by using the <strong>digits</strong> found in <code>num</code>. <strong>Leading zeros</strong> are allowed in <code>new1</code> and <code>new2</code>, and <strong>all</strong> the digits found in <code>num</code> must be used.</p>
+
+<ul>
+	<li>For example, given <code>num = 2932</code>, you have the following digits: two <code>2</code>'s, one <code>9</code> and one <code>3</code>. Some of the possible pairs <code>[new1, new2]</code> are <code>[22, 93]</code>, <code>[23, 92]</code>, <code>[223, 9]</code> and <code>[2, 329]</code>.</li>
+</ul>
+
+<p>Return <em>the <strong>minimum</strong> possible sum of </em><code>new1</code><em> and </em><code>new2</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 2932
+<strong>Output:</strong> 52
+<strong>Explanation:</strong> Some possible pairs [new1, new2] are [29, 23], [223, 9], etc.
+The minimum sum can be obtained by the pair [29, 23]: 29 + 23 = 52.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = 4009
+<strong>Output:</strong> 13
+<strong>Explanation:</strong> Some possible pairs [new1, new2] are [0, 49], [490, 0], etc. 
+The minimum sum can be obtained by the pair [4, 9]: 4 + 9 = 13.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1000 &lt;= num &lt;= 9999</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2161-partition-array-according-to-given-pivot/2161-partition-array-according-to-given-pivot.java b/leetcode/leetcode/2161-partition-array-according-to-given-pivot/2161-partition-array-according-to-given-pivot.java
new file mode 100644
index 0000000..38d898c
--- /dev/null
+++ b/leetcode/leetcode/2161-partition-array-according-to-given-pivot/2161-partition-array-according-to-given-pivot.java
@@ -0,0 +1,25 @@
+class Solution {
+    public int[] pivotArray(int[] nums, int pivot) {
+        int[] res = new int[nums.length];
+        int counter = 0;
+        int num = 0;
+        for(int i = 0;i<nums.length;i++){
+            if(nums[i]<pivot){
+                res[counter] = nums[i];
+                counter++;
+            }else if(nums[i] == pivot) num++;
+        }
+        while(num!=0){
+            res[counter] = pivot;
+            counter++;
+            num--;
+        }
+        for(int i = 0;i<nums.length;i++){
+            if(nums[i]>pivot){
+                res[counter] = nums[i];
+                counter++;
+            }
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2161-partition-array-according-to-given-pivot/README.md b/leetcode/leetcode/2161-partition-array-according-to-given-pivot/README.md
new file mode 100644
index 0000000..2830f75
--- /dev/null
+++ b/leetcode/leetcode/2161-partition-array-according-to-given-pivot/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/partition-array-according-to-given-pivot/">2161. Partition Array According to Given Pivot</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and an integer <code>pivot</code>. Rearrange <code>nums</code> such that the following conditions are satisfied:</p>
+
+<ul>
+	<li>Every element less than <code>pivot</code> appears <strong>before</strong> every element greater than <code>pivot</code>.</li>
+	<li>Every element equal to <code>pivot</code> appears <strong>in between</strong> the elements less than and greater than <code>pivot</code>.</li>
+	<li>The <strong>relative order</strong> of the elements less than <code>pivot</code> and the elements greater than <code>pivot</code> is maintained.
+	<ul>
+		<li>More formally, consider every <code>p<sub>i</sub></code>, <code>p<sub>j</sub></code> where <code>p<sub>i</sub></code> is the new position of the <code>i<sup>th</sup></code> element and <code>p<sub>j</sub></code> is the new position of the <code>j<sup>th</sup></code> element. For elements less than <code>pivot</code>, if <code>i &lt; j</code> and <code>nums[i] &lt; pivot</code> and <code>nums[j] &lt; pivot</code>, then <code>p<sub>i</sub> &lt; p<sub>j</sub></code>. Similarly for elements greater than <code>pivot</code>, if <code>i &lt; j</code> and <code>nums[i] &gt; pivot</code> and <code>nums[j] &gt; pivot</code>, then <code>p<sub>i</sub> &lt; p<sub>j</sub></code>.</li>
+	</ul>
+	</li>
+</ul>
+
+<p>Return <code>nums</code><em> after the rearrangement.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [9,12,5,10,14,3,10], pivot = 10
+<strong>Output:</strong> [9,5,3,10,10,12,14]
+<strong>Explanation:</strong> 
+The elements 9, 5, and 3 are less than the pivot so they are on the left side of the array.
+The elements 12 and 14 are greater than the pivot so they are on the right side of the array.
+The relative ordering of the elements less than and greater than pivot is also maintained. [9, 5, 3] and [12, 14] are the respective orderings.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-3,4,3,2], pivot = 2
+<strong>Output:</strong> [-3,2,4,3]
+<strong>Explanation:</strong> 
+The element -3 is less than the pivot so it is on the left side of the array.
+The elements 4 and 3 are greater than the pivot so they are on the right side of the array.
+The relative ordering of the elements less than and greater than pivot is also maintained. [-3] and [4, 3] are the respective orderings.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>6</sup> &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+	<li><code>pivot</code> equals to an element of <code>nums</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2164-sort-even-and-odd-indices-independently/2164-sort-even-and-odd-indices-independently.java b/leetcode/leetcode/2164-sort-even-and-odd-indices-independently/2164-sort-even-and-odd-indices-independently.java
new file mode 100644
index 0000000..55d4a94
--- /dev/null
+++ b/leetcode/leetcode/2164-sort-even-and-odd-indices-independently/2164-sort-even-and-odd-indices-independently.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int[] sortEvenOdd(int[] nums) {
+        if(nums.length<3) return nums;
+        PriorityQueue<Integer> pq = new PriorityQueue<>(nums.length/2);
+        PriorityQueue<Integer> pq1 = new PriorityQueue<>(nums.length/2,  Collections.reverseOrder());
+        for(int i = 0;i<nums.length;i+=2){
+            pq.add(nums[i]);
+            if(i+1!=nums.length) pq1.add(nums[i+1]);
+        }
+        for(int i = 0;i<nums.length;i+=2){
+            nums[i] = pq.remove();
+            if(i+1!=nums.length) nums[i+1] = pq1.remove();
+        }
+        return nums;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2164-sort-even-and-odd-indices-independently/NOTES.md b/leetcode/leetcode/2164-sort-even-and-odd-indices-independently/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2164-sort-even-and-odd-indices-independently/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2164-sort-even-and-odd-indices-independently/README.md b/leetcode/leetcode/2164-sort-even-and-odd-indices-independently/README.md
new file mode 100644
index 0000000..5085b16
--- /dev/null
+++ b/leetcode/leetcode/2164-sort-even-and-odd-indices-independently/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/sort-even-and-odd-indices-independently/">2164. Sort Even and Odd Indices Independently</a></h2><h3>Easy</h3><hr><div><p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>. Rearrange the values of <code>nums</code> according to the following rules:</p>
+
+<ol>
+	<li>Sort the values at <strong>odd indices</strong> of <code>nums</code> in <strong>non-increasing</strong> order.
+
+	<ul>
+		<li>For example, if <code>nums = [4,<strong><u>1</u></strong>,2,<u><strong>3</strong></u>]</code> before this step, it becomes <code>[4,<u><strong>3</strong></u>,2,<strong><u>1</u></strong>]</code> after. The values at odd indices <code>1</code> and <code>3</code> are sorted in non-increasing order.</li>
+	</ul>
+	</li>
+	<li>Sort the values at <strong>even indices</strong> of <code>nums</code> in <strong>non-decreasing</strong> order.
+	<ul>
+		<li>For example, if <code>nums = [<u><strong>4</strong></u>,1,<u><strong>2</strong></u>,3]</code> before this step, it becomes <code>[<u><strong>2</strong></u>,1,<u><strong>4</strong></u>,3]</code> after. The values at even indices <code>0</code> and <code>2</code> are sorted in non-decreasing order.</li>
+	</ul>
+	</li>
+</ol>
+
+<p>Return <em>the array formed after rearranging the values of</em> <code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [4,1,2,3]
+<strong>Output:</strong> [2,3,4,1]
+<strong>Explanation:</strong> 
+First, we sort the values present at odd indices (1 and 3) in non-increasing order.
+So, nums changes from [4,<strong><u>1</u></strong>,2,<strong><u>3</u></strong>] to [4,<u><strong>3</strong></u>,2,<strong><u>1</u></strong>].
+Next, we sort the values present at even indices (0 and 2) in non-decreasing order.
+So, nums changes from [<u><strong>4</strong></u>,1,<strong><u>2</u></strong>,3] to [<u><strong>2</strong></u>,3,<u><strong>4</strong></u>,1].
+Thus, the array formed after rearranging the values is [2,3,4,1].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,1]
+<strong>Output:</strong> [2,1]
+<strong>Explanation:</strong> 
+Since there is exactly one odd index and one even index, no rearrangement of values takes place.
+The resultant array formed is [2,1], which is the same as the initial array. 
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/2165-smallest-value-of-the-rearranged-number.java b/leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/2165-smallest-value-of-the-rearranged-number.java
new file mode 100644
index 0000000..8d38c40
--- /dev/null
+++ b/leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/2165-smallest-value-of-the-rearranged-number.java
@@ -0,0 +1,44 @@
+class Solution {
+    public long smallestNumber(long num) {
+        if(num==0) return 0;
+        boolean negative = false;
+        if(num<0) {
+            negative = true;
+            num = -num;
+        }
+        List<Integer> list = new ArrayList<>(15);
+        int zeros = 0;
+        while(num!=0){
+            long digit = num%10;
+            if(digit==0){
+                zeros++;
+            }else{
+                list.add((int)digit);
+            }
+            num = num/10;
+            
+        }
+        Collections.sort(list);
+        if(!negative){
+            num = list.get(0);
+            while(zeros!=0){
+                num = num*10;
+                zeros--;
+            }
+            for(int i = 1;i<list.size();i++){
+                num = num*10+list.get(i);
+            }
+        }else{
+            for(int i = list.size()-1;i!=-1;i--){
+                num = num*10+list.get(i);
+            }
+            
+            while(zeros!=0){
+                num = num*10;
+                zeros--;
+            }
+            num = - num;
+        }
+        return num;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/NOTES.md b/leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/README.md b/leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/README.md
new file mode 100644
index 0000000..6204ff7
--- /dev/null
+++ b/leetcode/leetcode/2165-smallest-value-of-the-rearranged-number/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/smallest-value-of-the-rearranged-number/">2165. Smallest Value of the Rearranged Number</a></h2><h3>Medium</h3><hr><div><p>You are given an integer <code>num.</code> <strong>Rearrange</strong> the digits of <code>num</code> such that its value is <strong>minimized</strong> and it does not contain <strong>any</strong> leading zeros.</p>
+
+<p>Return <em>the rearranged number with minimal value</em>.</p>
+
+<p>Note that the sign of the number does not change after rearranging the digits.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 310
+<strong>Output:</strong> 103
+<strong>Explanation:</strong> The possible arrangements for the digits of 310 are 013, 031, 103, 130, 301, 310. 
+The arrangement with the smallest value that does not contain any leading zeros is 103.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = -7605
+<strong>Output:</strong> -7650
+<strong>Explanation:</strong> Some possible arrangements for the digits of -7605 are -7650, -6705, -5076, -0567.
+The arrangement with the smallest value that does not contain any leading zeros is -7650.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-10<sup>15</sup> &lt;= num &lt;= 10<sup>15</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2166-design-bitset/2166-design-bitset.java b/leetcode/leetcode/2166-design-bitset/2166-design-bitset.java
new file mode 100644
index 0000000..56c0b9b
--- /dev/null
+++ b/leetcode/leetcode/2166-design-bitset/2166-design-bitset.java
@@ -0,0 +1,91 @@
+class Bitset {
+    boolean[] set;
+    boolean isFlipped;
+    int count1;
+    public Bitset(int size) {
+        set = new boolean[size];
+        for(int i=0;i<size;i++) set[i] = true;
+        isFlipped = false;
+        count1 = 0;
+    }
+    
+    public void fix(int idx) {
+        if(isFlipped){
+            if(set[idx] == false){
+                set[idx] = true;
+                count1++;
+            }
+        }else{
+            if(set[idx] == true){
+                set[idx] = false;
+                count1++;
+            }
+        }
+    }
+    
+    public void unfix(int idx) {
+        if(!isFlipped){
+            if(set[idx] == false){
+                set[idx] = true;
+                count1--;
+            }
+        }else{
+            if(set[idx] == true){
+                set[idx] = false;
+                count1--;
+            }
+        }
+    }
+    
+    public void flip() {
+        isFlipped = !isFlipped;
+        count1 = set.length - count1;
+    }
+    
+    public boolean all() {
+        return count1 == set.length;
+    }
+    
+    public boolean one() {
+        return count1>=1;
+    }
+    
+    public int count() {
+        return count1;
+    }
+    
+    public String toString() {
+        StringBuilder sb = new StringBuilder(set.length);
+        if(isFlipped){
+            
+            for(int i = 0;i<set.length;i++){
+                if(set[i]){
+                    sb.append("1");
+                }else{
+                    sb.append("0");
+                }
+            }
+        }else{
+            for(int i = 0;i<set.length;i++){
+                if(set[i]){
+                    sb.append("0");
+                }else{
+                    sb.append("1");
+                }
+            }
+        }
+        return sb.toString();
+    }
+}
+
+/**
+ * Your Bitset object will be instantiated and called as such:
+ * Bitset obj = new Bitset(size);
+ * obj.fix(idx);
+ * obj.unfix(idx);
+ * obj.flip();
+ * boolean param_4 = obj.all();
+ * boolean param_5 = obj.one();
+ * int param_6 = obj.count();
+ * String param_7 = obj.toString();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/2166-design-bitset/NOTES.md b/leetcode/leetcode/2166-design-bitset/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2166-design-bitset/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2166-design-bitset/README.md b/leetcode/leetcode/2166-design-bitset/README.md
new file mode 100644
index 0000000..cbdb7bc
--- /dev/null
+++ b/leetcode/leetcode/2166-design-bitset/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/design-bitset/">2166. Design Bitset</a></h2><h3>Medium</h3><hr><div><p>A <strong>Bitset</strong> is a data structure that compactly stores bits.</p>
+
+<p>Implement the <code>Bitset</code> class:</p>
+
+<ul>
+	<li><code>Bitset(int size)</code> Initializes the Bitset with <code>size</code> bits, all of which are <code>0</code>.</li>
+	<li><code>void fix(int idx)</code> Updates the value of the bit at the index <code>idx</code> to <code>1</code>. If the value was already <code>1</code>, no change occurs.</li>
+	<li><code>void unfix(int idx)</code> Updates the value of the bit at the index <code>idx</code> to <code>0</code>. If the value was already <code>0</code>, no change occurs.</li>
+	<li><code>void flip()</code> Flips the values of each bit in the Bitset. In other words, all bits with value <code>0</code> will now have value <code>1</code> and vice versa.</li>
+	<li><code>boolean all()</code> Checks if the value of <strong>each</strong> bit in the Bitset is <code>1</code>. Returns <code>true</code> if it satisfies the condition, <code>false</code> otherwise.</li>
+	<li><code>boolean one()</code> Checks if there is <strong>at least one</strong> bit in the Bitset with value <code>1</code>. Returns <code>true</code> if it satisfies the condition, <code>false</code> otherwise.</li>
+	<li><code>int count()</code> Returns the <strong>total number</strong> of bits in the Bitset which have value <code>1</code>.</li>
+	<li><code>String toString()</code> Returns the current composition of the Bitset. Note that in the resultant string, the character at the <code>i<sup>th</sup></code> index should coincide with the value at the <code>i<sup>th</sup></code> bit of the Bitset.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["Bitset", "fix", "fix", "flip", "all", "unfix", "flip", "one", "unfix", "count", "toString"]
+[[5], [3], [1], [], [], [0], [], [], [0], [], []]
+<strong>Output</strong>
+[null, null, null, null, false, null, null, true, null, 2, "01010"]
+
+<strong>Explanation</strong>
+Bitset bs = new Bitset(5); // bitset = "00000".
+bs.fix(3);     // the value at idx = 3 is updated to 1, so bitset = "00010".
+bs.fix(1);     // the value at idx = 1 is updated to 1, so bitset = "01010". 
+bs.flip();     // the value of each bit is flipped, so bitset = "10101". 
+bs.all();      // return False, as not all values of the bitset are 1.
+bs.unfix(0);   // the value at idx = 0 is updated to 0, so bitset = "00101".
+bs.flip();     // the value of each bit is flipped, so bitset = "11010". 
+bs.one();      // return True, as there is at least 1 index with value 1.
+bs.unfix(0);   // the value at idx = 0 is updated to 0, so bitset = "01010".
+bs.count();    // return 2, as there are 2 bits with value 1.
+bs.toString(); // return "01010", which is the composition of bitset.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= size &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= idx &lt;= size - 1</code></li>
+	<li>At most <code>10<sup>5</sup></code> calls will be made <strong>in total</strong> to <code>fix</code>, <code>unfix</code>, <code>flip</code>, <code>all</code>, <code>one</code>, <code>count</code>, and <code>toString</code>.</li>
+	<li>At least one call will be made to <code>all</code>, <code>one</code>, <code>count</code>, or <code>toString</code>.</li>
+	<li>At most <code>5</code> calls will be made to <code>toString</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2174-next-greater-numerically-balanced-number/2174-next-greater-numerically-balanced-number.java b/leetcode/leetcode/2174-next-greater-numerically-balanced-number/2174-next-greater-numerically-balanced-number.java
new file mode 100644
index 0000000..5ecd4ff
--- /dev/null
+++ b/leetcode/leetcode/2174-next-greater-numerically-balanced-number/2174-next-greater-numerically-balanced-number.java
@@ -0,0 +1,21 @@
+class Solution {
+    public boolean isBalanced(int num){
+        HashMap<Integer,Integer> map = new HashMap<>();
+        while(num!=0){
+            map.put(num%10, map.getOrDefault(num%10,0)+1);
+            num = num/10;
+        }
+        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
+            if(entry.getKey()!= entry.getValue()) return false;
+            
+        }
+        return true;
+    }
+    public int nextBeautifulNumber(int n) {
+        n++;
+        while(!isBalanced(n)){
+            n++;
+        }
+        return n;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2174-next-greater-numerically-balanced-number/README.md b/leetcode/leetcode/2174-next-greater-numerically-balanced-number/README.md
new file mode 100644
index 0000000..c00541d
--- /dev/null
+++ b/leetcode/leetcode/2174-next-greater-numerically-balanced-number/README.md
@@ -0,0 +1,47 @@
+<h2><a href="https://leetcode.com/problems/next-greater-numerically-balanced-number">2174. Next Greater Numerically Balanced Number</a></h2><h3>Medium</h3><hr><p>An integer <code>x</code> is <strong>numerically balanced</strong> if for every digit <code>d</code> in the number <code>x</code>, there are <strong>exactly</strong> <code>d</code> occurrences of that digit in <code>x</code>.</p>
+
+<p>Given an integer <code>n</code>, return <em>the <strong>smallest numerically balanced</strong> number <strong>strictly greater</strong> than </em><code>n</code><em>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 1
+<strong>Output:</strong> 22
+<strong>Explanation:</strong> 
+22 is numerically balanced since:
+- The digit 2 occurs 2 times. 
+It is also the smallest numerically balanced number strictly greater than 1.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 1000
+<strong>Output:</strong> 1333
+<strong>Explanation:</strong> 
+1333 is numerically balanced since:
+- The digit 1 occurs 1 time.
+- The digit 3 occurs 3 times. 
+It is also the smallest numerically balanced number strictly greater than 1000.
+Note that 1022 cannot be the answer because 0 appeared more than 0 times.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 3000
+<strong>Output:</strong> 3133
+<strong>Explanation:</strong> 
+3133 is numerically balanced since:
+- The digit 1 occurs 1 time.
+- The digit 3 occurs 3 times.
+It is also the smallest numerically balanced number strictly greater than 3000.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 10<sup>6</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/2177-find-three-consecutive-integers-that-sum-to-a-given-number.java b/leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/2177-find-three-consecutive-integers-that-sum-to-a-given-number.java
new file mode 100644
index 0000000..c8c6cab
--- /dev/null
+++ b/leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/2177-find-three-consecutive-integers-that-sum-to-a-given-number.java
@@ -0,0 +1,12 @@
+class Solution {
+    public long[] sumOfThree(long num) {
+        num = num - 3 ;
+        if(num%3 != 0) return new long[0];
+        long[] res = new long[3];
+        num = num/3;
+        res[0] = num++;
+        res[1] = num++;
+        res[2] = num;
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/NOTES.md b/leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/README.md b/leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/README.md
new file mode 100644
index 0000000..eb13c5b
--- /dev/null
+++ b/leetcode/leetcode/2177-find-three-consecutive-integers-that-sum-to-a-given-number/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/find-three-consecutive-integers-that-sum-to-a-given-number/">2177. Find Three Consecutive Integers That Sum to a Given Number</a></h2><h3>Medium</h3><hr><div><p>Given an integer <code>num</code>, return <em>three consecutive integers (as a sorted array)</em><em> that <strong>sum</strong> to </em><code>num</code>. If <code>num</code> cannot be expressed as the sum of three consecutive integers, return<em> an <strong>empty</strong> array.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 33
+<strong>Output:</strong> [10,11,12]
+<strong>Explanation:</strong> 33 can be expressed as 10 + 11 + 12 = 33.
+10, 11, 12 are 3 consecutive integers, so we return [10, 11, 12].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = 4
+<strong>Output:</strong> []
+<strong>Explanation:</strong> There is no way to express 4 as the sum of 3 consecutive integers.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= num &lt;= 10<sup>15</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2180-count-integers-with-even-digit-sum/2180-count-integers-with-even-digit-sum.java b/leetcode/leetcode/2180-count-integers-with-even-digit-sum/2180-count-integers-with-even-digit-sum.java
new file mode 100644
index 0000000..f11ce27
--- /dev/null
+++ b/leetcode/leetcode/2180-count-integers-with-even-digit-sum/2180-count-integers-with-even-digit-sum.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int countEven(int num) {
+        int temp = num;
+        int sum = 0;
+        while(num!=0){
+            sum+=(num%10);
+            num = num/10;
+        }
+        return sum%2==0 ? temp/2 : (temp-1)/2;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2180-count-integers-with-even-digit-sum/README.md b/leetcode/leetcode/2180-count-integers-with-even-digit-sum/README.md
new file mode 100644
index 0000000..6bb3e96
--- /dev/null
+++ b/leetcode/leetcode/2180-count-integers-with-even-digit-sum/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/count-integers-with-even-digit-sum/">2180. Count Integers With Even Digit Sum</a></h2><h3>Easy</h3><hr><div><p>Given a positive integer <code>num</code>, return <em>the number of positive integers <strong>less than or equal to</strong></em> <code>num</code> <em>whose digit sums are <strong>even</strong></em>.</p>
+
+<p>The <strong>digit sum</strong> of a positive integer is the sum of all its digits.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 4
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+The only integers less than or equal to 4 whose digit sums are even are 2 and 4.    
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = 30
+<strong>Output:</strong> 14
+<strong>Explanation:</strong>
+The 14 integers less than or equal to 30 whose digit sums are even are
+2, 4, 6, 8, 11, 13, 15, 17, 19, 20, 22, 24, 26, and 28.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= num &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2181-merge-nodes-in-between-zeros/2181-merge-nodes-in-between-zeros.java b/leetcode/leetcode/2181-merge-nodes-in-between-zeros/2181-merge-nodes-in-between-zeros.java
new file mode 100644
index 0000000..95c1b17
--- /dev/null
+++ b/leetcode/leetcode/2181-merge-nodes-in-between-zeros/2181-merge-nodes-in-between-zeros.java
@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode mergeNodes(ListNode head) {
+        ListNode head2 = head;
+        head = head.next;
+        while(head!=null){
+            ListNode temp = head;
+            head = head.next;
+            while(head.val!=0){
+                temp.val+=head.val;
+                head = head.next;
+            }
+            head = head.next;
+            temp.next = head;
+        }
+        return head2.next;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2181-merge-nodes-in-between-zeros/NOTES.md b/leetcode/leetcode/2181-merge-nodes-in-between-zeros/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2181-merge-nodes-in-between-zeros/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2181-merge-nodes-in-between-zeros/README.md b/leetcode/leetcode/2181-merge-nodes-in-between-zeros/README.md
new file mode 100644
index 0000000..56a63a5
--- /dev/null
+++ b/leetcode/leetcode/2181-merge-nodes-in-between-zeros/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/merge-nodes-in-between-zeros/">2181. Merge Nodes in Between Zeros</a></h2><h3>Medium</h3><hr><div><p>You are given the <code>head</code> of a linked list, which contains a series of integers <strong>separated</strong> by <code>0</code>'s. The <strong>beginning</strong> and <strong>end</strong> of the linked list will have <code>Node.val == 0</code>.</p>
+
+<p>For <strong>every </strong>two consecutive <code>0</code>'s, <strong>merge</strong> all the nodes lying in between them into a single node whose value is the <strong>sum</strong> of all the merged nodes. The modified list should not contain any <code>0</code>'s.</p>
+
+<p>Return <em>the</em> <code>head</code> <em>of the modified linked list</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/02/02/ex1-1.png" style="width: 600px; height: 41px;">
+<pre><strong>Input:</strong> head = [0,3,1,0,4,5,2,0]
+<strong>Output:</strong> [4,11]
+<strong>Explanation:</strong> 
+The above figure represents the given linked list. The modified list contains
+- The sum of the nodes marked in green: 3 + 1 = 4.
+- The sum of the nodes marked in red: 4 + 5 + 2 = 11.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/02/02/ex2-1.png" style="width: 600px; height: 41px;">
+<pre><strong>Input:</strong> head = [0,1,0,3,0,2,2,0]
+<strong>Output:</strong> [1,3,4]
+<strong>Explanation:</strong> 
+The above figure represents the given linked list. The modified list contains
+- The sum of the nodes marked in green: 1 = 1.
+- The sum of the nodes marked in red: 3 = 3.
+- The sum of the nodes marked in yellow: 2 + 2 = 4.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[3, 2 * 10<sup>5</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 1000</code></li>
+	<li>There are <strong>no</strong> two consecutive nodes with <code>Node.val == 0</code>.</li>
+	<li>The <strong>beginning</strong> and <strong>end</strong> of the linked list have <code>Node.val == 0</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2183-count-array-pairs-divisible-by-k/2183-count-array-pairs-divisible-by-k.java b/leetcode/leetcode/2183-count-array-pairs-divisible-by-k/2183-count-array-pairs-divisible-by-k.java
new file mode 100644
index 0000000..a688c1e
--- /dev/null
+++ b/leetcode/leetcode/2183-count-array-pairs-divisible-by-k/2183-count-array-pairs-divisible-by-k.java
@@ -0,0 +1,21 @@
+class Solution {
+    public long countPairs(int[] nums, int k) {
+        Map<Integer,Integer> map = new HashMap<>();
+        long ans = 0;
+        for(int i =0;i<nums.length;i++){
+            int curr_gcd = gcd(nums[i], k);
+            for(int num: map.keySet()){
+                if((long)curr_gcd*num%k==0)
+                    ans+=map.get(num);
+            }
+            map.put(curr_gcd,map.getOrDefault(curr_gcd,0)+1);
+        }
+        return ans;
+    }
+    private int gcd(int x, int y) {
+        if (x < y) {
+            return gcd(y, x);
+        }
+        return y == 0 ? x : gcd(y, x % y);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2183-count-array-pairs-divisible-by-k/NOTES.md b/leetcode/leetcode/2183-count-array-pairs-divisible-by-k/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2183-count-array-pairs-divisible-by-k/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2183-count-array-pairs-divisible-by-k/README.md b/leetcode/leetcode/2183-count-array-pairs-divisible-by-k/README.md
new file mode 100644
index 0000000..d653669
--- /dev/null
+++ b/leetcode/leetcode/2183-count-array-pairs-divisible-by-k/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/count-array-pairs-divisible-by-k/">2183. Count Array Pairs Divisible by K</a></h2><h3>Hard</h3><hr><div><p>Given a <strong>0-indexed</strong> integer array <code>nums</code> of length <code>n</code> and an integer <code>k</code>, return <em>the <strong>number of pairs</strong></em> <code>(i, j)</code> <em>such that:</em></p>
+
+<ul>
+	<li><code>0 &lt;= i &lt; j &lt;= n - 1</code> <em>and</em></li>
+	<li><code>nums[i] * nums[j]</code> <em>is divisible by</em> <code>k</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,5], k = 2
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> 
+The 7 pairs of indices whose corresponding products are divisible by 2 are
+(0, 1), (0, 3), (1, 2), (1, 3), (1, 4), (2, 3), and (3, 4).
+Their products are 2, 4, 6, 8, 10, 12, and 20 respectively.
+Other pairs such as (0, 2) and (2, 4) have products 3 and 15 respectively, which are not divisible by 2.    
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4], k = 5
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There does not exist any pair of indices whose corresponding product is divisible by 5.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i], k &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2190-most-frequent-number-following-key-in-an-array/2190-most-frequent-number-following-key-in-an-array.java b/leetcode/leetcode/2190-most-frequent-number-following-key-in-an-array/2190-most-frequent-number-following-key-in-an-array.java
new file mode 100644
index 0000000..79e832b
--- /dev/null
+++ b/leetcode/leetcode/2190-most-frequent-number-following-key-in-an-array/2190-most-frequent-number-following-key-in-an-array.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int mostFrequent(int[] nums, int key) {
+        int[] freq = new int[1001];
+        for(int i = 0;i<nums.length-1;i++){
+            if(nums[i] == key){
+                freq[nums[i+1]]++;
+                
+            }
+        }
+        int max = 0;
+        int ans = 0;
+        for(int i = 0;i<1001;i++){
+            if(max<freq[i]){
+                max = freq[i];
+                ans = i;
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2190-most-frequent-number-following-key-in-an-array/README.md b/leetcode/leetcode/2190-most-frequent-number-following-key-in-an-array/README.md
new file mode 100644
index 0000000..672dfc8
--- /dev/null
+++ b/leetcode/leetcode/2190-most-frequent-number-following-key-in-an-array/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/most-frequent-number-following-key-in-an-array/">2190. Most Frequent Number Following Key In an Array</a></h2><h3>Easy</h3><hr><div><p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>.<strong> </strong>You are also given an integer <code>key</code>, which is present in <code>nums</code>.</p>
+
+<p>For every unique integer <code>target</code> in <code>nums</code>, <strong>count</strong> the number of times <code>target</code> immediately follows an occurrence of <code>key</code> in <code>nums</code>. In other words, count the number of indices <code>i</code> such that:</p>
+
+<ul>
+	<li><code>0 &lt;= i &lt;= n - 2</code>,</li>
+	<li><code>nums[i] == key</code> and,</li>
+	<li><code>nums[i + 1] == target</code>.</li>
+</ul>
+
+<p>Return <em>the </em><code>target</code><em> with the <strong>maximum</strong> count</em>. The test cases will be generated such that the <code>target</code> with maximum count is unique.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,100,200,1,100], key = 1
+<strong>Output:</strong> 100
+<strong>Explanation:</strong> For target = 100, there are 2 occurrences at indices 1 and 4 which follow an occurrence of key.
+No other integers follow an occurrence of key, so we return 100.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,2,2,2,3], key = 2
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> For target = 2, there are 3 occurrences at indices 1, 2, and 3 which follow an occurrence of key.
+For target = 3, there is only one occurrence at index 4 which follows an occurrence of key.
+target = 2 has the maximum number of occurrences following an occurrence of key, so we return 2.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 1000</code></li>
+	<li>The test cases will be generated such that the answer is unique.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2215-find-the-difference-of-two-arrays/2215-find-the-difference-of-two-arrays.java b/leetcode/leetcode/2215-find-the-difference-of-two-arrays/2215-find-the-difference-of-two-arrays.java
new file mode 100644
index 0000000..be3b86c
--- /dev/null
+++ b/leetcode/leetcode/2215-find-the-difference-of-two-arrays/2215-find-the-difference-of-two-arrays.java
@@ -0,0 +1,29 @@
+class Solution {
+    public List<List<Integer>> findDifference(int[] nums1, int[] nums2) {
+        HashSet<Integer> nums1Set = new HashSet<>();
+        HashSet<Integer> nums2Set = new HashSet<>();
+        for(int num: nums1){
+            nums1Set.add(num);
+        }
+        for(int num: nums2){
+            nums2Set.add(num);
+        }
+        List<List<Integer>> result = new ArrayList<>();
+        List<Integer> list = new ArrayList<>();
+        for(int num: nums1Set){
+            if(!nums2Set.contains(num)){
+                list.add(num);
+            }
+        }
+        result.add(list);
+        list = new ArrayList<>();
+        for(int num: nums2Set){
+            if(!nums1Set.contains(num)){
+                list.add(num);
+            }
+        }
+        result.add(list);
+        return result;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2215-find-the-difference-of-two-arrays/NOTES.md b/leetcode/leetcode/2215-find-the-difference-of-two-arrays/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2215-find-the-difference-of-two-arrays/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2215-find-the-difference-of-two-arrays/README.md b/leetcode/leetcode/2215-find-the-difference-of-two-arrays/README.md
new file mode 100644
index 0000000..27ad699
--- /dev/null
+++ b/leetcode/leetcode/2215-find-the-difference-of-two-arrays/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/find-the-difference-of-two-arrays/">2215. Find the Difference of Two Arrays</a></h2><h3>Easy</h3><hr><div><p>Given two <strong>0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code>, return <em>a list</em> <code>answer</code> <em>of size</em> <code>2</code> <em>where:</em></p>
+
+<ul>
+	<li><code>answer[0]</code> <em>is a list of all <strong>distinct</strong> integers in</em> <code>nums1</code> <em>which are <strong>not</strong> present in</em> <code>nums2</code><em>.</em></li>
+	<li><code>answer[1]</code> <em>is a list of all <strong>distinct</strong> integers in</em> <code>nums2</code> <em>which are <strong>not</strong> present in</em> <code>nums1</code>.</li>
+</ul>
+
+<p><strong>Note</strong> that the integers in the lists may be returned in <strong>any</strong> order.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2,3], nums2 = [2,4,6]
+<strong>Output:</strong> [[1,3],[4,6]]
+<strong>Explanation:
+</strong>For nums1, nums1[1] = 2 is present at index 0 of nums2, whereas nums1[0] = 1 and nums1[2] = 3 are not present in nums2. Therefore, answer[0] = [1,3].
+For nums2, nums2[0] = 2 is present at index 1 of nums1, whereas nums2[1] = 4 and nums2[2] = 6 are not present in nums2. Therefore, answer[1] = [4,6].</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2,3,3], nums2 = [1,1,2,2]
+<strong>Output:</strong> [[3],[]]
+<strong>Explanation:
+</strong>For nums1, nums1[2] and nums1[3] are not present in nums2. Since nums1[2] == nums1[3], their value is only included once and answer[0] = [3].
+Every integer in nums2 is present in nums1. Therefore, answer[1] = [].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums1.length, nums2.length &lt;= 1000</code></li>
+	<li><code>-1000 &lt;= nums1[i], nums2[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2216-delete-the-middle-node-of-a-linked-list/2216-delete-the-middle-node-of-a-linked-list.java b/leetcode/leetcode/2216-delete-the-middle-node-of-a-linked-list/2216-delete-the-middle-node-of-a-linked-list.java
new file mode 100644
index 0000000..0485074
--- /dev/null
+++ b/leetcode/leetcode/2216-delete-the-middle-node-of-a-linked-list/2216-delete-the-middle-node-of-a-linked-list.java
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode deleteMiddle(ListNode head) {
+        if(head == null || head.next == null) return null;
+        ListNode prev = null;
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast!=null && fast.next!=null){
+            prev = slow;
+            slow = slow.next;
+            fast = fast.next.next;
+        } 
+        prev.next = prev.next.next; // prev.next = slow.next;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2216-delete-the-middle-node-of-a-linked-list/README.md b/leetcode/leetcode/2216-delete-the-middle-node-of-a-linked-list/README.md
new file mode 100644
index 0000000..c16c8af
--- /dev/null
+++ b/leetcode/leetcode/2216-delete-the-middle-node-of-a-linked-list/README.md
@@ -0,0 +1,47 @@
+<h2><a href="https://leetcode.com/problems/delete-the-middle-node-of-a-linked-list">2216. Delete the Middle Node of a Linked List</a></h2><h3>Medium</h3><hr><p>You are given the <code>head</code> of a linked list. <strong>Delete</strong> the <strong>middle node</strong>, and return <em>the</em> <code>head</code> <em>of the modified linked list</em>.</p>
+
+<p>The <strong>middle node</strong> of a linked list of size <code>n</code> is the <code>&lfloor;n / 2&rfloor;<sup>th</sup></code> node from the <b>start</b> using <strong>0-based indexing</strong>, where <code>&lfloor;x&rfloor;</code> denotes the largest integer less than or equal to <code>x</code>.</p>
+
+<ul>
+	<li>For <code>n</code> = <code>1</code>, <code>2</code>, <code>3</code>, <code>4</code>, and <code>5</code>, the middle nodes are <code>0</code>, <code>1</code>, <code>1</code>, <code>2</code>, and <code>2</code>, respectively.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/16/eg1drawio.png" style="width: 500px; height: 77px;" />
+<pre>
+<strong>Input:</strong> head = [1,3,4,7,1,2,6]
+<strong>Output:</strong> [1,3,4,1,2,6]
+<strong>Explanation:</strong>
+The above figure represents the given linked list. The indices of the nodes are written below.
+Since n = 7, node 3 with value 7 is the middle node, which is marked in red.
+We return the new list after removing this node. 
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/16/eg2drawio.png" style="width: 250px; height: 43px;" />
+<pre>
+<strong>Input:</strong> head = [1,2,3,4]
+<strong>Output:</strong> [1,2,4]
+<strong>Explanation:</strong>
+The above figure represents the given linked list.
+For n = 4, node 2 with value 3 is the middle node, which is marked in red.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/16/eg3drawio.png" style="width: 150px; height: 58px;" />
+<pre>
+<strong>Input:</strong> head = [2,1]
+<strong>Output:</strong> [2]
+<strong>Explanation:</strong>
+The above figure represents the given linked list.
+For n = 2, node 1 with value 1 is the middle node, which is marked in red.
+Node 0 with value 2 is the only node remaining after removing node 1.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/2220-find-all-possible-recipes-from-given-supplies/2220-find-all-possible-recipes-from-given-supplies.java b/leetcode/leetcode/2220-find-all-possible-recipes-from-given-supplies/2220-find-all-possible-recipes-from-given-supplies.java
new file mode 100644
index 0000000..1989c97
--- /dev/null
+++ b/leetcode/leetcode/2220-find-all-possible-recipes-from-given-supplies/2220-find-all-possible-recipes-from-given-supplies.java
@@ -0,0 +1,98 @@
+// class Solution {
+
+//     public List<String> findAllRecipes(String[] recipes, List<List<String>> ingredients, String[] supplies) {
+//         HashMap<String, Integer> inDegrees = new HashMap<>();
+//         HashMap<String, List<String>> depencenies = new HashMap<>();
+//         Set<String> suppliesSet = new HashSet<>(Set.of(supplies));
+
+//         for(int i = 0;i<recipes.length;i++){
+//             for(int j = 0;j<ingredients.get(i).size();j++){
+                
+//                 if(!suppliesSet.contains(ingredients.get(i).get(j))){
+//                     inDegrees.put(ingredients.get(i).get(j),inDegrees.getOrDefault(ingredients.get(i).get(j),0)+1);
+//                     List<String> list = new ArrayList<>();
+//                     if(depencenies.containsKey(ingredients.get(i).get(j)))
+//                         list = depencenies.get(ingredients.get(i).get(j));
+//                     list.add(recipes[i]);
+//                     depencenies.put(ingredients.get(i).get(j),list);
+//                 }
+//             }
+//         }
+//         // for(String i : inDegrees.keySet()){
+//         //     System.out.println(i + " :" + inDegrees.get(i));
+//         // }
+//         Queue<String> q = new LinkedList<>();
+//         return new ArrayList<>();
+//     }
+// }
+class Solution {
+
+    public List<String> findAllRecipes(
+        String[] recipes,
+        List<List<String>> ingredients,
+        String[] supplies
+    ) {
+        // Store available supplies
+        Set<String> availableSupplies = new HashSet<>();
+        // Map recipe to its index
+        Map<String, Integer> recipeToIndex = new HashMap<>();
+        // Map ingredient to recipes that need it
+        Map<String, List<String>> dependencyGraph = new HashMap<>();
+
+        // Initialize available supplies
+        for (String supply : supplies) {
+            availableSupplies.add(supply);
+        }
+
+        // Create recipe to index mapping
+        for (int idx = 0; idx < recipes.length; idx++) {
+            recipeToIndex.put(recipes[idx], idx);
+        }
+
+        // Count of non-supply ingredients needed for each recipe
+        int[] inDegree = new int[recipes.length];
+
+        // Build dependency graph
+        for (int recipeIdx = 0; recipeIdx < recipes.length; recipeIdx++) {
+            for (String ingredient : ingredients.get(recipeIdx)) {
+                if (!availableSupplies.contains(ingredient)) {
+                    // Add edge: ingredient -> recipe
+                    dependencyGraph.putIfAbsent(
+                        ingredient,
+                        new ArrayList<String>()
+                    );
+                    dependencyGraph.get(ingredient).add(recipes[recipeIdx]);
+                    inDegree[recipeIdx]++;
+                }
+            }
+        }
+
+        // Start with recipes that only need supplies
+        Queue<Integer> queue = new LinkedList<>();
+        for (int recipeIdx = 0; recipeIdx < recipes.length; recipeIdx++) {
+            if (inDegree[recipeIdx] == 0) {
+                queue.add(recipeIdx);
+            }
+        }
+
+        // Process recipes in topological order
+        List<String> createdRecipes = new ArrayList<>();
+        while (!queue.isEmpty()) {
+            int recipeIdx = queue.poll();
+            String recipe = recipes[recipeIdx];
+            createdRecipes.add(recipe);
+
+            // Skip if no recipes depend on this one
+            if (!dependencyGraph.containsKey(recipe)) continue;
+
+            // Update recipes that depend on current recipe
+            for (String dependentRecipe : dependencyGraph.get(recipe)) {
+                if (--inDegree[recipeToIndex.get(dependentRecipe)] == 0) {
+                    queue.add(recipeToIndex.get(dependentRecipe));
+                }
+            }
+        }
+
+        return createdRecipes;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2220-find-all-possible-recipes-from-given-supplies/README.md b/leetcode/leetcode/2220-find-all-possible-recipes-from-given-supplies/README.md
new file mode 100644
index 0000000..2a6be38
--- /dev/null
+++ b/leetcode/leetcode/2220-find-all-possible-recipes-from-given-supplies/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/find-all-possible-recipes-from-given-supplies">2220. Find All Possible Recipes from Given Supplies</a></h2><h3>Medium</h3><hr><p>You have information about <code>n</code> different recipes. You are given a string array <code>recipes</code> and a 2D string array <code>ingredients</code>. The <code>i<sup>th</sup></code> recipe has the name <code>recipes[i]</code>, and you can <strong>create</strong> it if you have <strong>all</strong> the needed ingredients from <code>ingredients[i]</code>. A recipe can also be an ingredient for <strong>other </strong>recipes, i.e., <code>ingredients[i]</code> may contain a string that is in <code>recipes</code>.</p>
+
+<p>You are also given a string array <code>supplies</code> containing all the ingredients that you initially have, and you have an infinite supply of all of them.</p>
+
+<p>Return <em>a list of all the recipes that you can create. </em>You may return the answer in <strong>any order</strong>.</p>
+
+<p>Note that two recipes may contain each other in their ingredients.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> recipes = [&quot;bread&quot;], ingredients = [[&quot;yeast&quot;,&quot;flour&quot;]], supplies = [&quot;yeast&quot;,&quot;flour&quot;,&quot;corn&quot;]
+<strong>Output:</strong> [&quot;bread&quot;]
+<strong>Explanation:</strong>
+We can create &quot;bread&quot; since we have the ingredients &quot;yeast&quot; and &quot;flour&quot;.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> recipes = [&quot;bread&quot;,&quot;sandwich&quot;], ingredients = [[&quot;yeast&quot;,&quot;flour&quot;],[&quot;bread&quot;,&quot;meat&quot;]], supplies = [&quot;yeast&quot;,&quot;flour&quot;,&quot;meat&quot;]
+<strong>Output:</strong> [&quot;bread&quot;,&quot;sandwich&quot;]
+<strong>Explanation:</strong>
+We can create &quot;bread&quot; since we have the ingredients &quot;yeast&quot; and &quot;flour&quot;.
+We can create &quot;sandwich&quot; since we have the ingredient &quot;meat&quot; and can create the ingredient &quot;bread&quot;.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> recipes = [&quot;bread&quot;,&quot;sandwich&quot;,&quot;burger&quot;], ingredients = [[&quot;yeast&quot;,&quot;flour&quot;],[&quot;bread&quot;,&quot;meat&quot;],[&quot;sandwich&quot;,&quot;meat&quot;,&quot;bread&quot;]], supplies = [&quot;yeast&quot;,&quot;flour&quot;,&quot;meat&quot;]
+<strong>Output:</strong> [&quot;bread&quot;,&quot;sandwich&quot;,&quot;burger&quot;]
+<strong>Explanation:</strong>
+We can create &quot;bread&quot; since we have the ingredients &quot;yeast&quot; and &quot;flour&quot;.
+We can create &quot;sandwich&quot; since we have the ingredient &quot;meat&quot; and can create the ingredient &quot;bread&quot;.
+We can create &quot;burger&quot; since we have the ingredient &quot;meat&quot; and can create the ingredients &quot;bread&quot; and &quot;sandwich&quot;.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == recipes.length == ingredients.length</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>1 &lt;= ingredients[i].length, supplies.length &lt;= 100</code></li>
+	<li><code>1 &lt;= recipes[i].length, ingredients[i][j].length, supplies[k].length &lt;= 10</code></li>
+	<li><code>recipes[i], ingredients[i][j]</code>, and <code>supplies[k]</code> consist only of lowercase English letters.</li>
+	<li>All the values of <code>recipes</code> and <code>supplies</code>&nbsp;combined are unique.</li>
+	<li>Each <code>ingredients[i]</code> does not contain any duplicate values.</li>
+</ul>
diff --git a/leetcode/leetcode/2220-minimum-bit-flips-to-convert-number/2220-minimum-bit-flips-to-convert-number.java b/leetcode/leetcode/2220-minimum-bit-flips-to-convert-number/2220-minimum-bit-flips-to-convert-number.java
new file mode 100644
index 0000000..3c21b65
--- /dev/null
+++ b/leetcode/leetcode/2220-minimum-bit-flips-to-convert-number/2220-minimum-bit-flips-to-convert-number.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int minBitFlips(int start, int goal) {
+        int ans = 0;
+        while(start!=0 || goal!=0){
+            if(start%2!=goal%2) ans++;
+            start = start/2;
+            goal = goal/2;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2220-minimum-bit-flips-to-convert-number/README.md b/leetcode/leetcode/2220-minimum-bit-flips-to-convert-number/README.md
new file mode 100644
index 0000000..1e4201d
--- /dev/null
+++ b/leetcode/leetcode/2220-minimum-bit-flips-to-convert-number/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/minimum-bit-flips-to-convert-number/">2220. Minimum Bit Flips to Convert Number</a></h2><h3>Easy</h3><hr><div><p>A <strong>bit flip</strong> of a number <code>x</code> is choosing a bit in the binary representation of <code>x</code> and <strong>flipping</strong> it from either <code>0</code> to <code>1</code> or <code>1</code> to <code>0</code>.</p>
+
+<ul>
+	<li>For example, for <code>x = 7</code>, the binary representation is <code>111</code> and we may choose any bit (including any leading zeros not shown) and flip it. We can flip the first bit from the right to get <code>110</code>, flip the second bit from the right to get <code>101</code>, flip the fifth bit from the right (a leading zero) to get <code>10111</code>, etc.</li>
+</ul>
+
+<p>Given two integers <code>start</code> and <code>goal</code>, return<em> the <strong>minimum</strong> number of <strong>bit flips</strong> to convert </em><code>start</code><em> to </em><code>goal</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> start = 10, goal = 7
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The binary representation of 10 and 7 are 1010 and 0111 respectively. We can convert 10 to 7 in 3 steps:
+- Flip the first bit from the right: 101<u>0</u> -&gt; 101<u>1</u>.
+- Flip the third bit from the right: 1<u>0</u>11 -&gt; 1<u>1</u>11.
+- Flip the fourth bit from the right: <u>1</u>111 -&gt; <u>0</u>111.
+It can be shown we cannot convert 10 to 7 in less than 3 steps. Hence, we return 3.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> start = 3, goal = 4
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The binary representation of 3 and 4 are 011 and 100 respectively. We can convert 3 to 4 in 3 steps:
+- Flip the first bit from the right: 01<u>1</u> -&gt; 01<u>0</u>.
+- Flip the second bit from the right: 0<u>1</u>0 -&gt; 0<u>0</u>0.
+- Flip the third bit from the right: <u>0</u>00 -&gt; <u>1</u>00.
+It can be shown we cannot convert 3 to 4 in less than 3 steps. Hence, we return 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= start, goal &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/2244-minimum-rounds-to-complete-all-tasks.java b/leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/2244-minimum-rounds-to-complete-all-tasks.java
new file mode 100644
index 0000000..c5f660b
--- /dev/null
+++ b/leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/2244-minimum-rounds-to-complete-all-tasks.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int minimumRounds(int[] tasks) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: tasks){
+            map.put(num,map.getOrDefault(num,0)+1);
+        }
+        int ans = 0;
+        for(int val: map.values()){
+            if(val == 1) return -1;
+            if(val%3==0) ans+=val/3;
+            else ans+=(val/3 +1);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/NOTES.md b/leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/README.md b/leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/README.md
new file mode 100644
index 0000000..b1d0537
--- /dev/null
+++ b/leetcode/leetcode/2244-minimum-rounds-to-complete-all-tasks/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/minimum-rounds-to-complete-all-tasks/">2244. Minimum Rounds to Complete All Tasks</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> integer array <code>tasks</code>, where <code>tasks[i]</code> represents the difficulty level of a task. In each round, you can complete either 2 or 3 tasks of the <strong>same difficulty level</strong>.</p>
+
+<p>Return <em>the <strong>minimum</strong> rounds required to complete all the tasks, or </em><code>-1</code><em> if it is not possible to complete all the tasks.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> tasks = [2,2,3,3,2,4,4,4,4,4]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> To complete all the tasks, a possible plan is:
+- In the first round, you complete 3 tasks of difficulty level 2. 
+- In the second round, you complete 2 tasks of difficulty level 3. 
+- In the third round, you complete 3 tasks of difficulty level 4. 
+- In the fourth round, you complete 2 tasks of difficulty level 4.  
+It can be shown that all the tasks cannot be completed in fewer than 4 rounds, so the answer is 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> tasks = [2,3,3]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> There is only 1 task of difficulty level 2, but in each round, you can only complete either 2 or 3 tasks of the same difficulty level. Hence, you cannot complete all the tasks, and the answer is -1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= tasks.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= tasks[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2246-longest-path-with-different-adjacent-characters/2246-longest-path-with-different-adjacent-characters.java b/leetcode/leetcode/2246-longest-path-with-different-adjacent-characters/2246-longest-path-with-different-adjacent-characters.java
new file mode 100644
index 0000000..c137d4e
--- /dev/null
+++ b/leetcode/leetcode/2246-longest-path-with-different-adjacent-characters/2246-longest-path-with-different-adjacent-characters.java
@@ -0,0 +1,34 @@
+class Solution {
+    private int longestPath = 1;
+    public int maxOpenPath(int curr, HashMap<Integer,List<Integer>> map, String s){
+        if(!map.containsKey(curr)) return 1;
+        List<Integer> list = map.get(curr);
+        int longestChain = 0;
+        int secondLongestChain = 0;
+        for(int child: list){
+            int longestChainStartingFromChild = maxOpenPath(child, map, s);
+            if(s.charAt(curr)  == s.charAt(child)) continue;
+            if (longestChainStartingFromChild > longestChain) {
+                secondLongestChain = longestChain;
+                longestChain = longestChainStartingFromChild;
+            } else if (longestChainStartingFromChild > secondLongestChain) {
+                secondLongestChain = longestChainStartingFromChild;
+            }
+        }
+        longestPath = Math.max(longestPath, longestChain + secondLongestChain + 1);
+        return longestChain + 1;
+        
+    }
+    public int longestPath(int[] parent, String s) {
+        HashMap<Integer,List<Integer>> map = new HashMap<>();
+        map.put(0,new ArrayList<Integer>());
+        for(int i = 1;i<parent.length;i++){
+            List<Integer> list = map.getOrDefault(parent[i],new ArrayList<Integer>());
+            list.add(i);
+            map.put(parent[i],list);
+        }
+        maxOpenPath(0,map,s);
+        return longestPath;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2246-longest-path-with-different-adjacent-characters/README.md b/leetcode/leetcode/2246-longest-path-with-different-adjacent-characters/README.md
new file mode 100644
index 0000000..78cb587
--- /dev/null
+++ b/leetcode/leetcode/2246-longest-path-with-different-adjacent-characters/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/longest-path-with-different-adjacent-characters/">2246. Longest Path With Different Adjacent Characters</a></h2><h3>Hard</h3><hr><div><p>You are given a <strong>tree</strong> (i.e. a connected, undirected graph that has no cycles) <strong>rooted</strong> at node <code>0</code> consisting of <code>n</code> nodes numbered from <code>0</code> to <code>n - 1</code>. The tree is represented by a <strong>0-indexed</strong> array <code>parent</code> of size <code>n</code>, where <code>parent[i]</code> is the parent of node <code>i</code>. Since node <code>0</code> is the root, <code>parent[0] == -1</code>.</p>
+
+<p>You are also given a string <code>s</code> of length <code>n</code>, where <code>s[i]</code> is the character assigned to node <code>i</code>.</p>
+
+<p>Return <em>the length of the <strong>longest path</strong> in the tree such that no pair of <strong>adjacent</strong> nodes on the path have the same character assigned to them.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/03/25/testingdrawio.png" style="width: 201px; height: 241px;">
+<pre><strong>Input:</strong> parent = [-1,0,0,1,1,2], s = "abacbe"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The longest path where each two adjacent nodes have different characters in the tree is the path: 0 -&gt; 1 -&gt; 3. The length of this path is 3, so 3 is returned.
+It can be proven that there is no longer path that satisfies the conditions. 
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/03/25/graph2drawio.png" style="width: 201px; height: 221px;">
+<pre><strong>Input:</strong> parent = [-1,0,0,0], s = "aabc"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The longest path where each two adjacent nodes have different characters is the path: 2 -&gt; 0 -&gt; 3. The length of this path is 3, so 3 is returned.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == parent.length == s.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= parent[i] &lt;= n - 1</code> for all <code>i &gt;= 1</code></li>
+	<li><code>parent[0] == -1</code></li>
+	<li><code>parent</code> represents a valid tree.</li>
+	<li><code>s</code> consists of only lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/225-implement-stack-using-queues/225-implement-stack-using-queues.java b/leetcode/leetcode/225-implement-stack-using-queues/225-implement-stack-using-queues.java
new file mode 100644
index 0000000..3759a6a
--- /dev/null
+++ b/leetcode/leetcode/225-implement-stack-using-queues/225-implement-stack-using-queues.java
@@ -0,0 +1,39 @@
+class MyStack {
+    Queue<Integer> q1;
+    Queue<Integer> q2;
+    public MyStack() {
+        q1 = new LinkedList();
+        q2 = new LinkedList();
+    }
+    
+    public void push(int x) {
+        while(!q1.isEmpty()){
+            q2.add(q1.remove());
+        }
+        q1.offer(x);
+        while(!q2.isEmpty()){
+            q1.add(q2.remove());
+        }
+    }
+    
+    public int pop() {
+        return q1.remove();
+    }
+    
+    public int top() {
+        return q1.peek();
+    }
+    
+    public boolean empty() {
+        return q1.size()==0;
+    }
+}
+
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * MyStack obj = new MyStack();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.top();
+ * boolean param_4 = obj.empty();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/225-implement-stack-using-queues/NOTES.md b/leetcode/leetcode/225-implement-stack-using-queues/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/225-implement-stack-using-queues/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/225-implement-stack-using-queues/README.md b/leetcode/leetcode/225-implement-stack-using-queues/README.md
new file mode 100644
index 0000000..451a9a8
--- /dev/null
+++ b/leetcode/leetcode/225-implement-stack-using-queues/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/implement-stack-using-queues/">225. Implement Stack using Queues</a></h2><h3>Easy</h3><hr><div><p>Implement a last-in-first-out (LIFO) stack using only two queues. The implemented stack should support all the functions of a normal stack (<code>push</code>, <code>top</code>, <code>pop</code>, and <code>empty</code>).</p>
+
+<p>Implement the <code>MyStack</code> class:</p>
+
+<ul>
+	<li><code>void push(int x)</code> Pushes element x to the top of the stack.</li>
+	<li><code>int pop()</code> Removes the element on the top of the stack and returns it.</li>
+	<li><code>int top()</code> Returns the element on the top of the stack.</li>
+	<li><code>boolean empty()</code> Returns <code>true</code> if the stack is empty, <code>false</code> otherwise.</li>
+</ul>
+
+<p><b>Notes:</b></p>
+
+<ul>
+	<li>You must use <strong>only</strong> standard operations of a queue, which means that only <code>push to back</code>, <code>peek/pop from front</code>, <code>size</code> and <code>is empty</code> operations are valid.</li>
+	<li>Depending on your language, the queue may not be supported natively. You may simulate a queue using a list or deque (double-ended queue) as long as you use only a queue's standard operations.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["MyStack", "push", "push", "top", "pop", "empty"]
+[[], [1], [2], [], [], []]
+<strong>Output</strong>
+[null, null, null, 2, 2, false]
+
+<strong>Explanation</strong>
+MyStack myStack = new MyStack();
+myStack.push(1);
+myStack.push(2);
+myStack.top(); // return 2
+myStack.pop(); // return 2
+myStack.empty(); // return False
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= x &lt;= 9</code></li>
+	<li>At most <code>100</code> calls will be made to <code>push</code>, <code>pop</code>, <code>top</code>, and <code>empty</code>.</li>
+	<li>All the calls to <code>pop</code> and <code>top</code> are valid.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong> Can you implement the stack using only one queue?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2255-minimum-swaps-to-group-all-1s-together-ii/2255-minimum-swaps-to-group-all-1s-together-ii.java b/leetcode/leetcode/2255-minimum-swaps-to-group-all-1s-together-ii/2255-minimum-swaps-to-group-all-1s-together-ii.java
new file mode 100644
index 0000000..c37f07c
--- /dev/null
+++ b/leetcode/leetcode/2255-minimum-swaps-to-group-all-1s-together-ii/2255-minimum-swaps-to-group-all-1s-together-ii.java
@@ -0,0 +1,28 @@
+class Solution {
+    public int minSwaps(int[] nums) {
+        int ones = 0;
+
+        for (int num : nums) {
+            if(num == 1){
+                ones++;
+            }
+        }
+        int ans = ones;
+        int start = 0;
+        int end = 0;
+        int zeroCount = 0;
+        while(end<ones){
+            if(nums[end] == 0) zeroCount++;
+            end++;
+        }
+        ans = zeroCount;
+        while(start<nums.length){
+            if(nums[start] == 0) zeroCount--;
+            if(nums[end%nums.length] == 0)zeroCount++;
+            start++;
+            end++;
+            ans = Math.min(ans,zeroCount);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2255-minimum-swaps-to-group-all-1s-together-ii/README.md b/leetcode/leetcode/2255-minimum-swaps-to-group-all-1s-together-ii/README.md
new file mode 100644
index 0000000..5a1f6a1
--- /dev/null
+++ b/leetcode/leetcode/2255-minimum-swaps-to-group-all-1s-together-ii/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii">2255. Minimum Swaps to Group All 1's Together II</a></h2><h3>Medium</h3><hr><p>A <strong>swap</strong> is defined as taking two <strong>distinct</strong> positions in an array and swapping the values in them.</p>
+
+<p>A <strong>circular</strong> array is defined as an array where we consider the <strong>first</strong> element and the <strong>last</strong> element to be <strong>adjacent</strong>.</p>
+
+<p>Given a <strong>binary</strong> <strong>circular</strong> array <code>nums</code>, return <em>the minimum number of swaps required to group all </em><code>1</code><em>&#39;s present in the array together at <strong>any location</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,1,0,1,1,0,0]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> Here are a few of the ways to group all the 1&#39;s together:
+[0,<u>0</u>,<u>1</u>,1,1,0,0] using 1 swap.
+[0,1,<u>1</u>,1,<u>0</u>,0,0] using 1 swap.
+[1,1,0,0,0,0,1] using 2 swaps (using the circular property of the array).
+There is no way to group all 1&#39;s together with 0 swaps.
+Thus, the minimum number of swaps required is 1.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,1,1,1,0,0,1,1,0]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Here are a few of the ways to group all the 1&#39;s together:
+[1,1,1,0,0,0,0,1,1] using 2 swaps (using the circular property of the array).
+[1,1,1,1,1,0,0,0,0] using 2 swaps.
+There is no way to group all 1&#39;s together with 0 or 1 swaps.
+Thus, the minimum number of swaps required is 2.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,1,0,0,1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> All the 1&#39;s are already grouped together due to the circular property of the array.
+Thus, the minimum number of swaps required is 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/2260-divide-a-string-into-groups-of-size-k/2260-divide-a-string-into-groups-of-size-k.java b/leetcode/leetcode/2260-divide-a-string-into-groups-of-size-k/2260-divide-a-string-into-groups-of-size-k.java
new file mode 100644
index 0000000..8313743
--- /dev/null
+++ b/leetcode/leetcode/2260-divide-a-string-into-groups-of-size-k/2260-divide-a-string-into-groups-of-size-k.java
@@ -0,0 +1,20 @@
+class Solution {
+    public String[] divideString(String s, int k, char fill) {
+        int len = s.length();
+        int size = len/k;
+        if(len%k != 0) size++; 
+        String[] res = new String[size];
+        int start = 0;
+        int end = k;
+        for(int i = 0;start<len;i++){
+            res[i] =  s.substring(start,Math.min(end,len));
+            while(res[i].length()!=k){
+                res[i]+=fill;
+            }
+            start+=k;
+            end+=k;
+
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2260-divide-a-string-into-groups-of-size-k/README.md b/leetcode/leetcode/2260-divide-a-string-into-groups-of-size-k/README.md
new file mode 100644
index 0000000..5cb523e
--- /dev/null
+++ b/leetcode/leetcode/2260-divide-a-string-into-groups-of-size-k/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/divide-a-string-into-groups-of-size-k">2260. Divide a String Into Groups of Size k</a></h2><h3>Easy</h3><hr><p>A string <code>s</code> can be partitioned into groups of size <code>k</code> using the following procedure:</p>
+
+<ul>
+	<li>The first group consists of the first <code>k</code> characters of the string, the second group consists of the next <code>k</code> characters of the string, and so on. Each element can be a part of <strong>exactly one</strong> group.</li>
+	<li>For the last group, if the string <strong>does not</strong> have <code>k</code> characters remaining, a character <code>fill</code> is used to complete the group.</li>
+</ul>
+
+<p>Note that the partition is done so that after removing the <code>fill</code> character from the last group (if it exists) and concatenating all the groups in order, the resultant string should be <code>s</code>.</p>
+
+<p>Given the string <code>s</code>, the size of each group <code>k</code> and the character <code>fill</code>, return <em>a string array denoting the <strong>composition of every group</strong> </em><code>s</code><em> has been divided into, using the above procedure</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcdefghi&quot;, k = 3, fill = &quot;x&quot;
+<strong>Output:</strong> [&quot;abc&quot;,&quot;def&quot;,&quot;ghi&quot;]
+<strong>Explanation:</strong>
+The first 3 characters &quot;abc&quot; form the first group.
+The next 3 characters &quot;def&quot; form the second group.
+The last 3 characters &quot;ghi&quot; form the third group.
+Since all groups can be completely filled by characters from the string, we do not need to use fill.
+Thus, the groups formed are &quot;abc&quot;, &quot;def&quot;, and &quot;ghi&quot;.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcdefghij&quot;, k = 3, fill = &quot;x&quot;
+<strong>Output:</strong> [&quot;abc&quot;,&quot;def&quot;,&quot;ghi&quot;,&quot;jxx&quot;]
+<strong>Explanation:</strong>
+Similar to the previous example, we are forming the first three groups &quot;abc&quot;, &quot;def&quot;, and &quot;ghi&quot;.
+For the last group, we can only use the character &#39;j&#39; from the string. To complete this group, we add &#39;x&#39; twice.
+Thus, the 4 groups formed are &quot;abc&quot;, &quot;def&quot;, &quot;ghi&quot;, and &quot;jxx&quot;.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 100</code></li>
+	<li><code>s</code> consists of lowercase English letters only.</li>
+	<li><code>1 &lt;= k &lt;= 100</code></li>
+	<li><code>fill</code> is a lowercase English letter.</li>
+</ul>
diff --git a/leetcode/leetcode/2264-largest-3-same-digit-number-in-string/2264-largest-3-same-digit-number-in-string.java b/leetcode/leetcode/2264-largest-3-same-digit-number-in-string/2264-largest-3-same-digit-number-in-string.java
new file mode 100644
index 0000000..02993a6
--- /dev/null
+++ b/leetcode/leetcode/2264-largest-3-same-digit-number-in-string/2264-largest-3-same-digit-number-in-string.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int getAnswer(char a){
+        int num = (int) (a - '0');
+        return num*100 + num*10 + num;
+    }
+    public String largestGoodInteger(String num) {
+        int i =0;
+        int ans = -1;
+        while(i+2<num.length()){
+            if(num.charAt(i) == num.charAt(i+1) && num.charAt(i+1) == num.charAt(i+2)){
+                ans = Math.max(ans,getAnswer(num.charAt(i)));
+                i = i+2;
+                
+            }else i++;
+        }
+        if(ans == -1) return "";
+        else if(ans == 0) return "000";
+        return Integer.toString(ans);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2264-largest-3-same-digit-number-in-string/NOTES.md b/leetcode/leetcode/2264-largest-3-same-digit-number-in-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2264-largest-3-same-digit-number-in-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2264-largest-3-same-digit-number-in-string/README.md b/leetcode/leetcode/2264-largest-3-same-digit-number-in-string/README.md
new file mode 100644
index 0000000..6dfcc6a
--- /dev/null
+++ b/leetcode/leetcode/2264-largest-3-same-digit-number-in-string/README.md
@@ -0,0 +1,47 @@
+<h2><a href="https://leetcode.com/problems/largest-3-same-digit-number-in-string/">2264. Largest 3-Same-Digit Number in String</a></h2><h3>Easy</h3><hr><div><p>You are given a string <code>num</code> representing a large integer. An integer is <strong>good</strong> if it meets the following conditions:</p>
+
+<ul>
+	<li>It is a <strong>substring</strong> of <code>num</code> with length <code>3</code>.</li>
+	<li>It consists of only one unique digit.</li>
+</ul>
+
+<p>Return <em>the <strong>maximum good </strong>integer as a <strong>string</strong> or an empty string </em><code>""</code><em> if no such integer exists</em>.</p>
+
+<p>Note:</p>
+
+<ul>
+	<li>A <strong>substring</strong> is a contiguous sequence of characters within a string.</li>
+	<li>There may be <strong>leading zeroes</strong> in <code>num</code> or a good integer.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = "6<strong><u>777</u></strong>133339"
+<strong>Output:</strong> "777"
+<strong>Explanation:</strong> There are two distinct good integers: "777" and "333".
+"777" is the largest, so we return "777".
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = "23<strong><u>000</u></strong>19"
+<strong>Output:</strong> "000"
+<strong>Explanation:</strong> "000" is the only good integer.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> num = "42352338"
+<strong>Output:</strong> ""
+<strong>Explanation:</strong> No substring of length 3 consists of only one unique digit. Therefore, there are no good integers.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= num.length &lt;= 1000</code></li>
+	<li><code>num</code> only consists of digits.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2265-partition-array-according-to-given-pivot/2265-partition-array-according-to-given-pivot.java b/leetcode/leetcode/2265-partition-array-according-to-given-pivot/2265-partition-array-according-to-given-pivot.java
new file mode 100644
index 0000000..38d898c
--- /dev/null
+++ b/leetcode/leetcode/2265-partition-array-according-to-given-pivot/2265-partition-array-according-to-given-pivot.java
@@ -0,0 +1,25 @@
+class Solution {
+    public int[] pivotArray(int[] nums, int pivot) {
+        int[] res = new int[nums.length];
+        int counter = 0;
+        int num = 0;
+        for(int i = 0;i<nums.length;i++){
+            if(nums[i]<pivot){
+                res[counter] = nums[i];
+                counter++;
+            }else if(nums[i] == pivot) num++;
+        }
+        while(num!=0){
+            res[counter] = pivot;
+            counter++;
+            num--;
+        }
+        for(int i = 0;i<nums.length;i++){
+            if(nums[i]>pivot){
+                res[counter] = nums[i];
+                counter++;
+            }
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2265-partition-array-according-to-given-pivot/README.md b/leetcode/leetcode/2265-partition-array-according-to-given-pivot/README.md
new file mode 100644
index 0000000..5ed7d33
--- /dev/null
+++ b/leetcode/leetcode/2265-partition-array-according-to-given-pivot/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/partition-array-according-to-given-pivot">2265. Partition Array According to Given Pivot</a></h2><h3>Medium</h3><hr><p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and an integer <code>pivot</code>. Rearrange <code>nums</code> such that the following conditions are satisfied:</p>
+
+<ul>
+	<li>Every element less than <code>pivot</code> appears <strong>before</strong> every element greater than <code>pivot</code>.</li>
+	<li>Every element equal to <code>pivot</code> appears <strong>in between</strong> the elements less than and greater than <code>pivot</code>.</li>
+	<li>The <strong>relative order</strong> of the elements less than <code>pivot</code> and the elements greater than <code>pivot</code> is maintained.
+	<ul>
+		<li>More formally, consider every <code>p<sub>i</sub></code>, <code>p<sub>j</sub></code> where <code>p<sub>i</sub></code> is the new position of the <code>i<sup>th</sup></code> element and <code>p<sub>j</sub></code> is the new position of the <code>j<sup>th</sup></code> element. If <code>i &lt; j</code> and <strong>both</strong> elements are smaller (<em>or larger</em>) than <code>pivot</code>, then <code>p<sub>i</sub> &lt; p<sub>j</sub></code>.</li>
+	</ul>
+	</li>
+</ul>
+
+<p>Return <code>nums</code><em> after the rearrangement.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [9,12,5,10,14,3,10], pivot = 10
+<strong>Output:</strong> [9,5,3,10,10,12,14]
+<strong>Explanation:</strong> 
+The elements 9, 5, and 3 are less than the pivot so they are on the left side of the array.
+The elements 12 and 14 are greater than the pivot so they are on the right side of the array.
+The relative ordering of the elements less than and greater than pivot is also maintained. [9, 5, 3] and [12, 14] are the respective orderings.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [-3,4,3,2], pivot = 2
+<strong>Output:</strong> [-3,2,4,3]
+<strong>Explanation:</strong> 
+The element -3 is less than the pivot so it is on the left side of the array.
+The elements 4 and 3 are greater than the pivot so they are on the right side of the array.
+The relative ordering of the elements less than and greater than pivot is also maintained. [-3] and [4, 3] are the respective orderings.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>6</sup> &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+	<li><code>pivot</code> equals to an element of <code>nums</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/228-summary-ranges/228-summary-ranges.java b/leetcode/leetcode/228-summary-ranges/228-summary-ranges.java
new file mode 100644
index 0000000..9f85dd2
--- /dev/null
+++ b/leetcode/leetcode/228-summary-ranges/228-summary-ranges.java
@@ -0,0 +1,27 @@
+class Solution {
+    public List<String> summaryRanges(int[] nums) {
+        List<String> list = new ArrayList<>();
+        int i = 0;
+        while(i<nums.length){
+            int start = nums[i];
+            int end = nums[i]+1;
+            while(i<nums.length-1){
+                if(nums[i+1] == end){
+                    i++;
+                    end++;
+                }else{
+                    break;
+                }
+            }
+            StringBuilder sb = new StringBuilder();
+            sb.append(Integer.toString(start));
+            if(start<end-1){
+                sb.append("->");
+                sb.append(Integer.toString(end-1));
+            }
+            list.add(sb.toString());
+            i++;            
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/228-summary-ranges/NOTES.md b/leetcode/leetcode/228-summary-ranges/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/228-summary-ranges/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/228-summary-ranges/README.md b/leetcode/leetcode/228-summary-ranges/README.md
new file mode 100644
index 0000000..bde2502
--- /dev/null
+++ b/leetcode/leetcode/228-summary-ranges/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/summary-ranges/">228. Summary Ranges</a></h2><h3>Easy</h3><hr><div><p>You are given a <strong>sorted unique</strong> integer array <code>nums</code>.</p>
+
+<p>Return <em>the <strong>smallest sorted</strong> list of ranges that <strong>cover all the numbers in the array exactly</strong></em>. That is, each element of <code>nums</code> is covered by exactly one of the ranges, and there is no integer <code>x</code> such that <code>x</code> is in one of the ranges but not in <code>nums</code>.</p>
+
+<p>Each range <code>[a,b]</code> in the list should be output as:</p>
+
+<ul>
+	<li><code>"a-&gt;b"</code> if <code>a != b</code></li>
+	<li><code>"a"</code> if <code>a == b</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1,2,4,5,7]
+<strong>Output:</strong> ["0-&gt;2","4-&gt;5","7"]
+<strong>Explanation:</strong> The ranges are:
+[0,2] --&gt; "0-&gt;2"
+[4,5] --&gt; "4-&gt;5"
+[7,7] --&gt; "7"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,2,3,4,6,8,9]
+<strong>Output:</strong> ["0","2-&gt;4","6","8-&gt;9"]
+<strong>Explanation:</strong> The ranges are:
+[0,0] --&gt; "0"
+[2,4] --&gt; "2-&gt;4"
+[6,6] --&gt; "6"
+[8,9] --&gt; "8-&gt;9"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= nums.length &lt;= 20</code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+	<li>All the values of <code>nums</code> are <strong>unique</strong>.</li>
+	<li><code>nums</code> is sorted in ascending order.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/23-merge-k-sorted-lists/23-merge-k-sorted-lists.java b/leetcode/leetcode/23-merge-k-sorted-lists/23-merge-k-sorted-lists.java
new file mode 100644
index 0000000..65cd59f
--- /dev/null
+++ b/leetcode/leetcode/23-merge-k-sorted-lists/23-merge-k-sorted-lists.java
@@ -0,0 +1,46 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public class pair implements Comparable<pair>{
+        public ListNode head;
+        pair(ListNode head){
+            this.head = head;
+        }
+        public int compareTo(pair p){
+            return this.head.val - p.head.val;
+        }
+    }
+    public ListNode mergeKLists(ListNode[] lists) {
+        if(lists.length == 0) return null;
+        if(lists.length == 1) return lists[0];
+        PriorityQueue<pair> pq = new PriorityQueue<>();
+        for(int i =0;i<lists.length;i++){
+            if(lists[i]!=null){
+                pair p = new pair(lists[i]);
+                pq.add(p);
+            }
+
+        }
+        ListNode head = new ListNode();
+        ListNode temp = head;
+        while(pq.size()!=0){
+            pair p = pq.remove();
+            ListNode temp2 = p.head;
+            temp.next = temp2;
+            temp = temp.next;
+            if(temp2.next !=null){
+                p.head = temp2.next;
+                pq.add(p);
+            }
+        }
+        return head.next;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/23-merge-k-sorted-lists/NOTES.md b/leetcode/leetcode/23-merge-k-sorted-lists/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/23-merge-k-sorted-lists/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/23-merge-k-sorted-lists/README.md b/leetcode/leetcode/23-merge-k-sorted-lists/README.md
new file mode 100644
index 0000000..b6d6e1e
--- /dev/null
+++ b/leetcode/leetcode/23-merge-k-sorted-lists/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/merge-k-sorted-lists/">23. Merge k Sorted Lists</a></h2><h3>Hard</h3><hr><div><p>You are given an array of <code>k</code> linked-lists <code>lists</code>, each linked-list is sorted in ascending order.</p>
+
+<p><em>Merge all the linked-lists into one sorted linked-list and return it.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> lists = [[1,4,5],[1,3,4],[2,6]]
+<strong>Output:</strong> [1,1,2,3,4,4,5,6]
+<strong>Explanation:</strong> The linked-lists are:
+[
+  1-&gt;4-&gt;5,
+  1-&gt;3-&gt;4,
+  2-&gt;6
+]
+merging them into one sorted list:
+1-&gt;1-&gt;2-&gt;3-&gt;4-&gt;4-&gt;5-&gt;6
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> lists = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> lists = [[]]
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>k == lists.length</code></li>
+	<li><code>0 &lt;= k &lt;= 10^4</code></li>
+	<li><code>0 &lt;= lists[i].length &lt;= 500</code></li>
+	<li><code>-10^4 &lt;= lists[i][j] &lt;= 10^4</code></li>
+	<li><code>lists[i]</code> is sorted in <strong>ascending order</strong>.</li>
+	<li>The sum of <code>lists[i].length</code> won't exceed <code>10^4</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/230-kth-smallest-element-in-a-bst/230-kth-smallest-element-in-a-bst.java b/leetcode/leetcode/230-kth-smallest-element-in-a-bst/230-kth-smallest-element-in-a-bst.java
new file mode 100644
index 0000000..e703e8f
--- /dev/null
+++ b/leetcode/leetcode/230-kth-smallest-element-in-a-bst/230-kth-smallest-element-in-a-bst.java
@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    int val;
+    public int helper(TreeNode root){
+        if(root == null) return -1;
+        if(val == 0) return root.val;
+        int ans = helper(root.left);
+        if(ans!=-1) return ans;
+        val--;
+        if(val == 0) return root.val;
+        ans = helper(root.right);
+        return ans;
+        
+    }
+    public int kthSmallest(TreeNode root, int k) {
+        val = k;
+        return helper(root);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/230-kth-smallest-element-in-a-bst/NOTES.md b/leetcode/leetcode/230-kth-smallest-element-in-a-bst/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/230-kth-smallest-element-in-a-bst/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2307-replace-non-coprime-numbers-in-array/2307-replace-non-coprime-numbers-in-array.py b/leetcode/leetcode/2307-replace-non-coprime-numbers-in-array/2307-replace-non-coprime-numbers-in-array.py
new file mode 100644
index 0000000..310ea73
--- /dev/null
+++ b/leetcode/leetcode/2307-replace-non-coprime-numbers-in-array/2307-replace-non-coprime-numbers-in-array.py
@@ -0,0 +1,10 @@
+class Solution:
+    def replaceNonCoprimes(self, nums: List[int]) -> List[int]:
+        ans = []
+        for num in nums:
+            # keep merging while last element and current num are not coprime
+            while ans and math.gcd(ans[-1], num) > 1:
+                num = (ans[-1] * num) // math.gcd(ans[-1], num)
+                ans.pop()
+            ans.append(num)
+        return ans
\ No newline at end of file
diff --git a/leetcode/leetcode/2307-replace-non-coprime-numbers-in-array/README.md b/leetcode/leetcode/2307-replace-non-coprime-numbers-in-array/README.md
new file mode 100644
index 0000000..3258f49
--- /dev/null
+++ b/leetcode/leetcode/2307-replace-non-coprime-numbers-in-array/README.md
@@ -0,0 +1,53 @@
+<h2><a href="https://leetcode.com/problems/replace-non-coprime-numbers-in-array/?envType=daily-question&envId=2025-09-16">2307. Replace Non-Coprime Numbers in Array</a></h2><h3>Hard</h3><hr><p>You are given an array of integers <code>nums</code>. Perform the following steps:</p>
+
+<ol>
+	<li>Find <strong>any</strong> two <strong>adjacent</strong> numbers in <code>nums</code> that are <strong>non-coprime</strong>.</li>
+	<li>If no such numbers are found, <strong>stop</strong> the process.</li>
+	<li>Otherwise, delete the two numbers and <strong>replace</strong> them with their <strong>LCM (Least Common Multiple)</strong>.</li>
+	<li><strong>Repeat</strong> this process as long as you keep finding two adjacent non-coprime numbers.</li>
+</ol>
+
+<p>Return <em>the <strong>final</strong> modified array.</em> It can be shown that replacing adjacent non-coprime numbers in <strong>any</strong> arbitrary order will lead to the same result.</p>
+
+<p>The test cases are generated such that the values in the final array are <strong>less than or equal</strong> to <code>10<sup>8</sup></code>.</p>
+
+<p>Two values <code>x</code> and <code>y</code> are <strong>non-coprime</strong> if <code>GCD(x, y) &gt; 1</code> where <code>GCD(x, y)</code> is the <strong>Greatest Common Divisor</strong> of <code>x</code> and <code>y</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [6,4,3,2,7,6,2]
+<strong>Output:</strong> [12,7,6]
+<strong>Explanation:</strong> 
+- (6, 4) are non-coprime with LCM(6, 4) = 12. Now, nums = [<strong><u>12</u></strong>,3,2,7,6,2].
+- (12, 3) are non-coprime with LCM(12, 3) = 12. Now, nums = [<strong><u>12</u></strong>,2,7,6,2].
+- (12, 2) are non-coprime with LCM(12, 2) = 12. Now, nums = [<strong><u>12</u></strong>,7,6,2].
+- (6, 2) are non-coprime with LCM(6, 2) = 6. Now, nums = [12,7,<u><strong>6</strong></u>].
+There are no more adjacent non-coprime numbers in nums.
+Thus, the final modified array is [12,7,6].
+Note that there are other ways to obtain the same resultant array.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,2,1,1,3,3,3]
+<strong>Output:</strong> [2,1,1,3]
+<strong>Explanation:</strong> 
+- (3, 3) are non-coprime with LCM(3, 3) = 3. Now, nums = [2,2,1,1,<u><strong>3</strong></u>,3].
+- (3, 3) are non-coprime with LCM(3, 3) = 3. Now, nums = [2,2,1,1,<u><strong>3</strong></u>].
+- (2, 2) are non-coprime with LCM(2, 2) = 2. Now, nums = [<u><strong>2</strong></u>,1,1,3].
+There are no more adjacent non-coprime numbers in nums.
+Thus, the final modified array is [2,1,1,3].
+Note that there are other ways to obtain the same resultant array.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+	<li>The test cases are generated such that the values in the final array are <strong>less than or equal</strong> to <code>10<sup>8</sup></code>.</li>
+</ul>
diff --git a/leetcode/leetcode/2308-divide-array-into-equal-pairs/2308-divide-array-into-equal-pairs.java b/leetcode/leetcode/2308-divide-array-into-equal-pairs/2308-divide-array-into-equal-pairs.java
new file mode 100644
index 0000000..2c3f139
--- /dev/null
+++ b/leetcode/leetcode/2308-divide-array-into-equal-pairs/2308-divide-array-into-equal-pairs.java
@@ -0,0 +1,61 @@
+// class Solution {
+// Approach 1: Using Sorting
+// Time: O(n*log(n)), Space: O(1)
+//     public boolean divideArray(int[] arr) {
+//       Arrays.sort(arr);
+//       for(int i = 0;i<arr.length;i+=2){
+//         if(arr[i]!=arr[i+1]) return false;
+//       }  
+//       return true;
+//     }
+// }
+
+// class Solution {
+//     public boolean divideArray(int[] arr) {
+//     // Approach 2: using Frequency array.
+//     // Time: O(n), Space: O(n)
+//         int max = 0;
+//         for(int num: arr){
+//             max = Math.max(max,num);
+//         }
+//         int[] freq = new int[max+1];
+//         for(int num: arr){
+//             freq[num]++;
+//         }
+//         for(int i = 0;i<=max;i++){
+//             if(freq[i]%2!=0) return false;
+//         }
+//         return true;
+//     }
+// }
+
+// class Solution {
+//     public boolean divideArray(int[] arr) {
+//     // Approach 3: using Frequency array.
+//     // Time: O(n), Space: O(1)
+//         int[] freq = new int[501];
+//         for(int num: arr){
+//             freq[num]++;
+//         }
+//         for(int i = 0;i<=500;i++){
+//             if(freq[i]%2!=0) return false;
+//         }
+//         return true;
+//     }
+// }
+
+
+class Solution {
+    public boolean divideArray(int[] arr) {
+    // Approach 4: using boolean Frequency array.
+    // Time: O(n), Space: O(1)
+        boolean[] freq = new boolean[501];
+        for(int num: arr){
+            freq[num] = !freq[num];
+        }
+        for(int i = 0;i<=500;i++){
+            if(freq[i]) return false;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2308-divide-array-into-equal-pairs/README.md b/leetcode/leetcode/2308-divide-array-into-equal-pairs/README.md
new file mode 100644
index 0000000..32caea1
--- /dev/null
+++ b/leetcode/leetcode/2308-divide-array-into-equal-pairs/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/divide-array-into-equal-pairs">2308. Divide Array Into Equal Pairs</a></h2><h3>Easy</h3><hr><p>You are given an integer array <code>nums</code> consisting of <code>2 * n</code> integers.</p>
+
+<p>You need to divide <code>nums</code> into <code>n</code> pairs such that:</p>
+
+<ul>
+	<li>Each element belongs to <strong>exactly one</strong> pair.</li>
+	<li>The elements present in a pair are <strong>equal</strong>.</li>
+</ul>
+
+<p>Return <code>true</code> <em>if nums can be divided into</em> <code>n</code> <em>pairs, otherwise return</em> <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,2,3,2,2,2]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> 
+There are 6 elements in nums, so they should be divided into 6 / 2 = 3 pairs.
+If nums is divided into the pairs (2, 2), (3, 3), and (2, 2), it will satisfy all the conditions.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> 
+There is no way to divide nums into 4 / 2 = 2 pairs such that the pairs satisfy every condition.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>nums.length == 2 * n</code></li>
+	<li><code>1 &lt;= n &lt;= 500</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 500</code></li>
+</ul>
diff --git a/leetcode/leetcode/232-implement-queue-using-stacks/232-implement-queue-using-stacks.java b/leetcode/leetcode/232-implement-queue-using-stacks/232-implement-queue-using-stacks.java
new file mode 100644
index 0000000..fa0a415
--- /dev/null
+++ b/leetcode/leetcode/232-implement-queue-using-stacks/232-implement-queue-using-stacks.java
@@ -0,0 +1,39 @@
+class MyQueue {
+    Stack<Integer> s1;
+    Stack<Integer> s2;
+    public MyQueue() {
+        s1 = new Stack<>();
+        s2 = new Stack<>();
+    }
+    
+    public void push(int x) {
+        while(!s1.empty()){
+            s2.push(s1.pop());
+        }
+        s1.push(x);
+        while(!s2.empty()){
+            s1.push(s2.pop());
+        }
+    }
+    
+    public int pop() {
+        return s1.pop();
+    }
+    
+    public int peek() {
+        return s1.peek();
+    }
+    
+    public boolean empty() {
+        return s1.empty();
+    }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * MyQueue obj = new MyQueue();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.peek();
+ * boolean param_4 = obj.empty();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/232-implement-queue-using-stacks/NOTES.md b/leetcode/leetcode/232-implement-queue-using-stacks/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/232-implement-queue-using-stacks/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/232-implement-queue-using-stacks/README.md b/leetcode/leetcode/232-implement-queue-using-stacks/README.md
new file mode 100644
index 0000000..5268042
--- /dev/null
+++ b/leetcode/leetcode/232-implement-queue-using-stacks/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/implement-queue-using-stacks/">232. Implement Queue using Stacks</a></h2><h3>Easy</h3><hr><div><p>Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue (<code>push</code>, <code>peek</code>, <code>pop</code>, and <code>empty</code>).</p>
+
+<p>Implement the <code>MyQueue</code> class:</p>
+
+<ul>
+	<li><code>void push(int x)</code> Pushes element x to the back of the queue.</li>
+	<li><code>int pop()</code> Removes the element from the front of the queue and returns it.</li>
+	<li><code>int peek()</code> Returns the element at the front of the queue.</li>
+	<li><code>boolean empty()</code> Returns <code>true</code> if the queue is empty, <code>false</code> otherwise.</li>
+</ul>
+
+<p><strong>Notes:</strong></p>
+
+<ul>
+	<li>You must use <strong>only</strong> standard operations of a stack, which means only <code>push to top</code>, <code>peek/pop from top</code>, <code>size</code>, and <code>is empty</code> operations are valid.</li>
+	<li>Depending on your language, the stack may not be supported natively. You may simulate a stack using a list or deque (double-ended queue) as long as you use only a stack's standard operations.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["MyQueue", "push", "push", "peek", "pop", "empty"]
+[[], [1], [2], [], [], []]
+<strong>Output</strong>
+[null, null, null, 1, 1, false]
+
+<strong>Explanation</strong>
+MyQueue myQueue = new MyQueue();
+myQueue.push(1); // queue is: [1]
+myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
+myQueue.peek(); // return 1
+myQueue.pop(); // return 1, queue is [2]
+myQueue.empty(); // return false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= x &lt;= 9</code></li>
+	<li>At most <code>100</code>&nbsp;calls will be made to <code>push</code>, <code>pop</code>, <code>peek</code>, and <code>empty</code>.</li>
+	<li>All the calls to <code>pop</code> and <code>peek</code> are valid.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong> Can you implement the queue such that each operation is <strong><a href="https://en.wikipedia.org/wiki/Amortized_analysis" target="_blank">amortized</a></strong> <code>O(1)</code> time complexity? In other words, performing <code>n</code> operations will take overall <code>O(n)</code> time even if one of those operations may take longer.</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2324-find-triangular-sum-of-an-array/2324-find-triangular-sum-of-an-array.java b/leetcode/leetcode/2324-find-triangular-sum-of-an-array/2324-find-triangular-sum-of-an-array.java
new file mode 100644
index 0000000..a553469
--- /dev/null
+++ b/leetcode/leetcode/2324-find-triangular-sum-of-an-array/2324-find-triangular-sum-of-an-array.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int triangularSum(int[] nums) {
+        for(int index = nums.length-1;index!=0;index--){
+            for(int i = 0;i<index;i++){
+                nums[i] = (nums[i] + nums[i+1])%10;
+            }
+        }
+        return nums[0];
+
+    }
+}   
\ No newline at end of file
diff --git a/leetcode/leetcode/2324-find-triangular-sum-of-an-array/README.md b/leetcode/leetcode/2324-find-triangular-sum-of-an-array/README.md
new file mode 100644
index 0000000..1ab984b
--- /dev/null
+++ b/leetcode/leetcode/2324-find-triangular-sum-of-an-array/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/find-triangular-sum-of-an-array">2324. Find Triangular Sum of an Array</a></h2><h3>Medium</h3><hr><p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>, where <code>nums[i]</code> is a digit between <code>0</code> and <code>9</code> (<strong>inclusive</strong>).</p>
+
+<p>The <strong>triangular sum</strong> of <code>nums</code> is the value of the only element present in <code>nums</code> after the following process terminates:</p>
+
+<ol>
+	<li>Let <code>nums</code> comprise of <code>n</code> elements. If <code>n == 1</code>, <strong>end</strong> the process. Otherwise, <strong>create</strong> a new <strong>0-indexed</strong> integer array <code>newNums</code> of length <code>n - 1</code>.</li>
+	<li>For each index <code>i</code>, where <code>0 &lt;= i &lt;&nbsp;n - 1</code>, <strong>assign</strong> the value of <code>newNums[i]</code> as <code>(nums[i] + nums[i+1]) % 10</code>, where <code>%</code> denotes modulo operator.</li>
+	<li><strong>Replace</strong> the array <code>nums</code> with <code>newNums</code>.</li>
+	<li><strong>Repeat</strong> the entire process starting from step 1.</li>
+</ol>
+
+<p>Return <em>the triangular sum of</em> <code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/02/22/ex1drawio.png" style="width: 250px; height: 250px;" />
+<pre>
+<strong>Input:</strong> nums = [1,2,3,4,5]
+<strong>Output:</strong> 8
+<strong>Explanation:</strong>
+The above diagram depicts the process from which we obtain the triangular sum of the array.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [5]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong>
+Since there is only one element in nums, the triangular sum is the value of that element itself.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 9</code></li>
+</ul>
diff --git a/leetcode/leetcode/234-palindrome-linked-list/README.md b/leetcode/leetcode/234-palindrome-linked-list/README.md
new file mode 100644
index 0000000..2efe818
--- /dev/null
+++ b/leetcode/leetcode/234-palindrome-linked-list/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/palindrome-linked-list/">234. Palindrome Linked List</a></h2><h3>Easy</h3><hr><div><p>Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;">
+<pre><strong>Input:</strong> head = [1,2,2,1]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;">
+<pre><strong>Input:</strong> head = [1,2]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 9</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2352-equal-row-and-column-pairs/2352-equal-row-and-column-pairs.java b/leetcode/leetcode/2352-equal-row-and-column-pairs/2352-equal-row-and-column-pairs.java
new file mode 100644
index 0000000..89d4ec7
--- /dev/null
+++ b/leetcode/leetcode/2352-equal-row-and-column-pairs/2352-equal-row-and-column-pairs.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int equalPairs(int[][] grid) {
+        HashMap<String,Integer> map = new HashMap<>();
+        for(int i = 0;i<grid.length;i++){
+            StringBuilder sb = new StringBuilder();
+            for(int j = 0;j<grid[0].length;j++){
+                sb.append(Integer.toString(grid[i][j]));
+                sb.append(",");
+            }
+            map.put(sb.toString(),map.getOrDefault(sb.toString(),0)+1);
+        }
+        int ans = 0;
+        for(int i = 0;i<grid.length;i++){
+            StringBuilder sb = new StringBuilder();
+            for(int j =0;j<grid[0].length;j++){
+                sb.append(Integer.toString(grid[j][i]));
+                sb.append(",");
+            }
+            ans+=map.getOrDefault(sb.toString(),0);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2352-equal-row-and-column-pairs/NOTES.md b/leetcode/leetcode/2352-equal-row-and-column-pairs/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2352-equal-row-and-column-pairs/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/236-lowest-common-ancestor-of-a-binary-tree.java b/leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/236-lowest-common-ancestor-of-a-binary-tree.java
new file mode 100644
index 0000000..0227802
--- /dev/null
+++ b/leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/236-lowest-common-ancestor-of-a-binary-tree.java
@@ -0,0 +1,20 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if(root == null) return null;
+        if(root == p || root == q) return root;
+        TreeNode left = lowestCommonAncestor(root.left,p,q);
+        TreeNode right = lowestCommonAncestor(root.right,p,q);
+        if(left == null) return right;
+        if(right == null) return left;
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/NOTES.md b/leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/README.md b/leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/README.md
new file mode 100644
index 0000000..3261cce
--- /dev/null
+++ b/leetcode/leetcode/236-lowest-common-ancestor-of-a-binary-tree/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/">236. Lowest Common Ancestor of a Binary Tree</a></h2><h3>Medium</h3><hr><div><p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p>
+
+<p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: “The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).”</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;">
+<pre><strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;">
+<pre><strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,2], p = 1, q = 2
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li>
+	<li><code>-10<sup>9</sup> &lt;= Node.val &lt;= 10<sup>9</sup></code></li>
+	<li>All <code>Node.val</code> are <strong>unique</strong>.</li>
+	<li><code>p != q</code></li>
+	<li><code>p</code> and <code>q</code> will exist in the tree.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/238-product-of-array-except-self/238-product-of-array-except-self.java b/leetcode/leetcode/238-product-of-array-except-self/238-product-of-array-except-self.java
new file mode 100644
index 0000000..340b24b
--- /dev/null
+++ b/leetcode/leetcode/238-product-of-array-except-self/238-product-of-array-except-self.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int n = nums.length;
+        int[] left = new int[n];
+        int[] right = new int[n];
+        int leftMost = 1;
+        int rightMost = 1;
+        for(int i=0;i<n;i++){
+            left[i] = leftMost * nums[i];
+            right[n - i - 1] = rightMost * nums[n - i - 1];
+            leftMost = left[i];
+            rightMost = right[n - i - 1];
+        }
+        int[] res = new int[n];
+        res[0] = right[1];
+        res[n - 1] = left[n - 2];
+        for(int i = 1;i<n - 1;i++){
+            res[i] = left[i-1] * right[i+1];
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/238-product-of-array-except-self/NOTES.md b/leetcode/leetcode/238-product-of-array-except-self/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/238-product-of-array-except-self/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/238-product-of-array-except-self/README.md b/leetcode/leetcode/238-product-of-array-except-self/README.md
new file mode 100644
index 0000000..ef80e78
--- /dev/null
+++ b/leetcode/leetcode/238-product-of-array-except-self/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/product-of-array-except-self/">238. Product of Array Except Self</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, return <em>an array</em> <code>answer</code> <em>such that</em> <code>answer[i]</code> <em>is equal to the product of all the elements of</em> <code>nums</code> <em>except</em> <code>nums[i]</code>.</p>
+
+<p>The product of any prefix or suffix of <code>nums</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</p>
+
+<p>You must write an algorithm that runs in&nbsp;<code>O(n)</code>&nbsp;time and without using the division operation.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> [24,12,8,6]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [-1,1,0,-3,3]
+<strong>Output:</strong> [0,0,9,0,0]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-30 &lt;= nums[i] &lt;= 30</code></li>
+	<li>The product of any prefix or suffix of <code>nums</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong>&nbsp;Can you solve the problem in <code>O(1)&nbsp;</code>extra&nbsp;space complexity? (The output array <strong>does not</strong> count as extra space for space complexity analysis.)</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2390-removing-stars-from-a-string/2390-removing-stars-from-a-string.java b/leetcode/leetcode/2390-removing-stars-from-a-string/2390-removing-stars-from-a-string.java
new file mode 100644
index 0000000..41199e1
--- /dev/null
+++ b/leetcode/leetcode/2390-removing-stars-from-a-string/2390-removing-stars-from-a-string.java
@@ -0,0 +1,24 @@
+class Solution {
+    public String removeStars(String s) {
+        StringBuilder sb = new StringBuilder();
+        int currentIndex = s.length()-1;
+        while(currentIndex!=-1){
+            if(s.charAt(currentIndex)!='*'){
+                sb.append(s.charAt(currentIndex));
+                currentIndex--;
+            }else{
+                int toRemove = 0;
+                while(currentIndex!=-1){
+                    if(s.charAt(currentIndex)=='*'){
+                        toRemove++;
+                    }else{
+                        toRemove--;
+                    }
+                    currentIndex--;
+                    if(toRemove==0) break;
+                }
+            }
+        }
+        return sb.reverse().toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2390-removing-stars-from-a-string/NOTES.md b/leetcode/leetcode/2390-removing-stars-from-a-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2390-removing-stars-from-a-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2390-removing-stars-from-a-string/README.md b/leetcode/leetcode/2390-removing-stars-from-a-string/README.md
new file mode 100644
index 0000000..341e423
--- /dev/null
+++ b/leetcode/leetcode/2390-removing-stars-from-a-string/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/removing-stars-from-a-string/">2390. Removing Stars From a String</a></h2><h3>Medium</h3><hr><div><p>You are given a string <code>s</code>, which contains stars <code>*</code>.</p>
+
+<p>In one operation, you can:</p>
+
+<ul>
+	<li>Choose a star in <code>s</code>.</li>
+	<li>Remove the closest <strong>non-star</strong> character to its <strong>left</strong>, as well as remove the star itself.</li>
+</ul>
+
+<p>Return <em>the string after <strong>all</strong> stars have been removed</em>.</p>
+
+<p><strong>Note:</strong></p>
+
+<ul>
+	<li>The input will be generated such that the operation is always possible.</li>
+	<li>It can be shown that the resulting string will always be unique.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "leet**cod*e"
+<strong>Output:</strong> "lecoe"
+<strong>Explanation:</strong> Performing the removals from left to right:
+- The closest character to the 1<sup>st</sup> star is 't' in "lee<strong><u>t</u></strong>**cod*e". s becomes "lee*cod*e".
+- The closest character to the 2<sup>nd</sup> star is 'e' in "le<strong><u>e</u></strong>*cod*e". s becomes "lecod*e".
+- The closest character to the 3<sup>rd</sup> star is 'd' in "leco<strong><u>d</u></strong>*e". s becomes "lecoe".
+There are no more stars, so we return "lecoe".</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "erase*****"
+<strong>Output:</strong> ""
+<strong>Explanation:</strong> The entire string is removed, so we return an empty string.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> consists of lowercase English letters and stars <code>*</code>.</li>
+	<li>The operation above can be performed on <code>s</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2394-count-subarrays-with-score-less-than-k/2394-count-subarrays-with-score-less-than-k.java b/leetcode/leetcode/2394-count-subarrays-with-score-less-than-k/2394-count-subarrays-with-score-less-than-k.java
new file mode 100644
index 0000000..8e5ef41
--- /dev/null
+++ b/leetcode/leetcode/2394-count-subarrays-with-score-less-than-k/2394-count-subarrays-with-score-less-than-k.java
@@ -0,0 +1,17 @@
+class Solution {
+    public long countSubarrays(int[] nums, long k) {
+        long currentSum = 0;
+        int start,end;
+        long ans =0;
+        for(start = 0,end =0;end<nums.length;end++){
+            currentSum+=nums[end];
+            while(start<=end && currentSum * (end-start+1) >= k ){
+                currentSum -= nums[start];
+                start++;
+            }
+            // this portion
+            ans+=(end-start+1);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2394-count-subarrays-with-score-less-than-k/README.md b/leetcode/leetcode/2394-count-subarrays-with-score-less-than-k/README.md
new file mode 100644
index 0000000..5fe8df9
--- /dev/null
+++ b/leetcode/leetcode/2394-count-subarrays-with-score-less-than-k/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/count-subarrays-with-score-less-than-k">2394. Count Subarrays With Score Less Than K</a></h2><h3>Hard</h3><hr><p>The <strong>score</strong> of an array is defined as the <strong>product</strong> of its sum and its length.</p>
+
+<ul>
+	<li>For example, the score of <code>[1, 2, 3, 4, 5]</code> is <code>(1 + 2 + 3 + 4 + 5) * 5 = 75</code>.</li>
+</ul>
+
+<p>Given a positive integer array <code>nums</code> and an integer <code>k</code>, return <em>the <strong>number of non-empty subarrays</strong> of</em> <code>nums</code> <em>whose score is <strong>strictly less</strong> than</em> <code>k</code>.</p>
+
+<p>A <strong>subarray</strong> is a contiguous sequence of elements within an array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,1,4,3,5], k = 10
+<strong>Output:</strong> 6
+<strong>Explanation:</strong>
+The 6 subarrays having scores less than 10 are:
+- [2] with score 2 * 1 = 2.
+- [1] with score 1 * 1 = 1.
+- [4] with score 4 * 1 = 4.
+- [3] with score 3 * 1 = 3. 
+- [5] with score 5 * 1 = 5.
+- [2,1] with score (2 + 1) * 2 = 6.
+Note that subarrays such as [1,4] and [4,3,5] are not considered because their scores are 10 and 36 respectively, while we need scores strictly less than 10.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,1,1], k = 5
+<strong>Output:</strong> 5
+<strong>Explanation:</strong>
+Every subarray except [1,1,1] has a score less than 5.
+[1,1,1] has a score (1 + 1 + 1) * 3 = 9, which is greater than 5.
+Thus, there are 5 subarrays having scores less than 5.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>15</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/24-swap-nodes-in-pairs/24-swap-nodes-in-pairs.java b/leetcode/leetcode/24-swap-nodes-in-pairs/24-swap-nodes-in-pairs.java
new file mode 100644
index 0000000..afb96b2
--- /dev/null
+++ b/leetcode/leetcode/24-swap-nodes-in-pairs/24-swap-nodes-in-pairs.java
@@ -0,0 +1,21 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode swapPairs(ListNode head) {
+        if(head == null || head.next ==null)  return head;
+        head.next.next = swapPairs(head.next.next);
+        ListNode temp = head.next;
+        head.next = temp.next;
+        temp.next = head;
+        head = temp;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/24-swap-nodes-in-pairs/README.md b/leetcode/leetcode/24-swap-nodes-in-pairs/README.md
new file mode 100644
index 0000000..562c353
--- /dev/null
+++ b/leetcode/leetcode/24-swap-nodes-in-pairs/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/swap-nodes-in-pairs/">24. Swap Nodes in Pairs</a></h2><h3>Medium</h3><hr><div><p>Given a&nbsp;linked list, swap every two adjacent nodes and return its head. You must solve the problem without&nbsp;modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg" style="width: 422px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4]
+<strong>Output:</strong> [2,1,4,3]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the&nbsp;list&nbsp;is in the range <code>[0, 100]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/240-search-a-2d-matrix-ii/240-search-a-2d-matrix-ii.java b/leetcode/leetcode/240-search-a-2d-matrix-ii/240-search-a-2d-matrix-ii.java
new file mode 100644
index 0000000..90cb606
--- /dev/null
+++ b/leetcode/leetcode/240-search-a-2d-matrix-ii/240-search-a-2d-matrix-ii.java
@@ -0,0 +1,61 @@
+class Solution {
+    // public boolean helper(int[][] matrix, int current, int target){
+    //     if(current>=matrix.length|| current>=matrix[0].length) return false;
+    //     if(matrix[current][current]>target) return false;
+    //     int low = current;
+    //     int high = matrix[current].length -1;
+    //     while(low<=high){
+    //         int mid = (low+high)/2;
+    //         if(matrix[current][mid]>target){
+    //             high = mid -1;
+    //         }else if(matrix[current][mid]<target){
+    //             low = mid+1;
+    //         }else{
+    //             return true;
+    //         }
+    //     }
+    //     low = current;
+    //     high = matrix.length - 1;
+    //     while(low<=high){
+    //         int mid = (low+high)/2;
+    //         if(matrix[mid][current]>target){
+    //             high = mid -1;
+    //         }else if(matrix[mid][current]<target){
+    //             low = mid+1;
+    //         }else return true;
+    //     }
+    //     return helper(matrix,current+1,target);
+    // }
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int current = 0;
+        int row = matrix.length;
+        int col = matrix[0].length;
+        while(current<row && current<col){
+            if(matrix[current][current]>target) return false;
+            int low = current;
+            int high = col - 1;
+            while(low<=high){
+                int mid = (low+high)/2;
+                if(matrix[current][mid]>target){
+                    high = mid -1;
+                }else if(matrix[current][mid]<target){
+                    low = mid+1;
+                }else{
+                    return true;
+                }
+            }
+            low = current;
+            high = row - 1;
+            while(low<=high){
+                int mid = (low+high)/2;
+                if(matrix[mid][current]>target){
+                    high = mid -1;
+                }else if(matrix[mid][current]<target){
+                    low = mid+1;
+                }else return true;
+            }
+            current++; 
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/240-search-a-2d-matrix-ii/NOTES.md b/leetcode/leetcode/240-search-a-2d-matrix-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/240-search-a-2d-matrix-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/240-search-a-2d-matrix-ii/README.md b/leetcode/leetcode/240-search-a-2d-matrix-ii/README.md
new file mode 100644
index 0000000..4a112cf
--- /dev/null
+++ b/leetcode/leetcode/240-search-a-2d-matrix-ii/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/search-a-2d-matrix-ii/">240. Search a 2D Matrix II</a></h2><h3>Medium</h3><hr><div><p>Write an efficient algorithm that searches for a <code>target</code> value in an <code>m x n</code> integer <code>matrix</code>. The <code>matrix</code> has the following properties:</p>
+
+<ul>
+	<li>Integers in each row are sorted in ascending from left to right.</li>
+	<li>Integers in each column are sorted in ascending from top to bottom.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/24/searchgrid2.jpg" style="width: 300px; height: 300px;">
+<pre><strong>Input:</strong> matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/24/searchgrid.jpg" style="width: 300px; height: 300px;">
+<pre><strong>Input:</strong> matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == matrix.length</code></li>
+	<li><code>n == matrix[i].length</code></li>
+	<li><code>1 &lt;= n, m &lt;= 300</code></li>
+	<li><code>-10<sup>9</sup> &lt;= matrix[i][j] &lt;= 10<sup>9</sup></code></li>
+	<li>All the integers in each row are <strong>sorted</strong> in ascending order.</li>
+	<li>All the integers in each column are <strong>sorted</strong> in ascending order.</li>
+	<li><code>-10<sup>9</sup> &lt;= target &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2405-optimal-partition-of-string/2405-optimal-partition-of-string.java b/leetcode/leetcode/2405-optimal-partition-of-string/2405-optimal-partition-of-string.java
new file mode 100644
index 0000000..e6ab2ae
--- /dev/null
+++ b/leetcode/leetcode/2405-optimal-partition-of-string/2405-optimal-partition-of-string.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int partitionString(String s) {
+        int ans = 1;
+        Set<Character> set = new HashSet<>();
+        for(int i = 0;i<s.length();i++){
+            if(set.contains(s.charAt(i))){
+                set.clear();
+                ans++;
+            }
+            set.add(s.charAt(i));
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2405-optimal-partition-of-string/NOTES.md b/leetcode/leetcode/2405-optimal-partition-of-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2405-optimal-partition-of-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2405-optimal-partition-of-string/README.md b/leetcode/leetcode/2405-optimal-partition-of-string/README.md
new file mode 100644
index 0000000..bb11394
--- /dev/null
+++ b/leetcode/leetcode/2405-optimal-partition-of-string/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/optimal-partition-of-string/">2405. Optimal Partition of String</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code>, partition the string into one or more <strong>substrings</strong> such that the characters in each substring are <strong>unique</strong>. That is, no letter appears in a single substring more than <strong>once</strong>.</p>
+
+<p>Return <em>the <strong>minimum</strong> number of substrings in such a partition.</em></p>
+
+<p>Note that each character should belong to exactly one substring in a partition.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "abacaba"
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+Two possible partitions are ("a","ba","cab","a") and ("ab","a","ca","ba").
+It can be shown that 4 is the minimum number of substrings needed.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "ssssss"
+<strong>Output:</strong> 6
+<strong>Explanation:
+</strong>The only valid partition is ("s","s","s","s","s","s").
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> consists of only English lowercase letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/2419-longest-subarray-with-maximum-bitwise-and.java b/leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/2419-longest-subarray-with-maximum-bitwise-and.java
new file mode 100644
index 0000000..637aac1
--- /dev/null
+++ b/leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/2419-longest-subarray-with-maximum-bitwise-and.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int longestSubarray(int[] nums) {
+        int maxNum = Integer.MIN_VALUE;
+        int count = 0;
+        int ans = 1;
+        for(int num: nums){
+            if(num==maxNum) count++;
+            else if(num>maxNum){
+                ans = 1;
+                count = 1;
+                maxNum = num;
+            }else{
+                count = 0;
+            }
+            ans = Math.max(ans,count);
+            
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/NOTES.md b/leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/README.md b/leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/README.md
new file mode 100644
index 0000000..de377d4
--- /dev/null
+++ b/leetcode/leetcode/2419-longest-subarray-with-maximum-bitwise-and/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/longest-subarray-with-maximum-bitwise-and/">2419. Longest Subarray With Maximum Bitwise AND</a></h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>nums</code> of size <code>n</code>.</p>
+
+<p>Consider a <strong>non-empty</strong> subarray from <code>nums</code> that has the <strong>maximum</strong> possible <strong>bitwise AND</strong>.</p>
+
+<ul>
+	<li>In other words, let <code>k</code> be the maximum value of the bitwise AND of <strong>any</strong> subarray of <code>nums</code>. Then, only subarrays with a bitwise AND equal to <code>k</code> should be considered.</li>
+</ul>
+
+<p>Return <em>the length of the <strong>longest</strong> such subarray</em>.</p>
+
+<p>The bitwise AND of an array is the bitwise AND of all the numbers in it.</p>
+
+<p>A <strong>subarray</strong> is a contiguous sequence of elements within an array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,3,2,2]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+The maximum possible bitwise AND of a subarray is 3.
+The longest subarray with that value is [3,3], so we return 2.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong>
+The maximum possible bitwise AND of a subarray is 4.
+The longest subarray with that value is [4], so we return 1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2421-number-of-good-paths/2421-number-of-good-paths.java b/leetcode/leetcode/2421-number-of-good-paths/2421-number-of-good-paths.java
new file mode 100644
index 0000000..796499d
--- /dev/null
+++ b/leetcode/leetcode/2421-number-of-good-paths/2421-number-of-good-paths.java
@@ -0,0 +1,85 @@
+class UnionFind {
+    int[] parent;
+    int[] rank;
+
+    public UnionFind(int size) {
+        parent = new int[size];
+        for (int i = 0; i < size; i++)
+            parent[i] = i;
+        rank = new int[size];
+    }
+
+    public int find(int x) {
+        if (parent[x] != x)
+            parent[x] = find(parent[x]);
+        return parent[x];
+    }
+
+    public void union_set(int x, int y) {
+        int xset = find(x), yset = find(y);
+        if (xset == yset) {
+            return;
+        } else if (rank[xset] < rank[yset]) {
+            parent[xset] = yset;
+        } else if (rank[xset] > rank[yset]) {
+            parent[yset] = xset;
+        } else {
+            parent[yset] = xset;
+            rank[xset]++;
+        }
+    }
+}
+
+class Solution {
+    public int numberOfGoodPaths(int[] vals, int[][] edges) {
+        Map<Integer, List<Integer>> adj = new HashMap<>();
+        for (int[] edge : edges) {
+            int a = edge[0], b = edge[1];
+            adj.computeIfAbsent(a, value -> new ArrayList<Integer>()).add(b);
+            adj.computeIfAbsent(b, value -> new ArrayList<Integer>()).add(a);
+        }
+
+        int n = vals.length;
+        // Mapping from value to all the nodes having the same value in sorted order of
+        // values.
+        TreeMap<Integer, List<Integer>> valuesToNodes = new TreeMap<>();
+        for (int i = 0; i < n; i++) {
+            valuesToNodes.computeIfAbsent(vals[i], value -> new ArrayList<Integer>()).add(i);
+        }
+
+        UnionFind dsu = new UnionFind(n);
+        int goodPaths = 0;
+
+        // Iterate over all the nodes with the same value in sorted order, starting from
+        // the lowest value.
+        for (int value : valuesToNodes.keySet()) {
+            // For every node in nodes, combine the sets of the node and its neighbors into
+            // one set.
+            for (int node : valuesToNodes.get(value)) {
+                if (!adj.containsKey(node))
+                    continue;
+                for (int neighbor : adj.get(node)) {
+                    // Only choose neighbors with a smaller value, as there is no point in
+                    // traversing to other neighbors.
+                    if (vals[node] >= vals[neighbor]) {
+                        dsu.union_set(node, neighbor);
+                    }
+                }
+            }
+            // Map to compute the number of nodes under observation (with the same values)
+            // in each of the sets.
+            Map<Integer, Integer> group = new HashMap<>();
+            // Iterate over all the nodes. Get the set of each node and increase the count
+            // of the set by 1.
+            for (int u : valuesToNodes.get(value)) {
+                group.put(dsu.find(u), group.getOrDefault(dsu.find(u), 0) + 1);
+            }
+            // For each set of "size", add size * (size + 1) / 2 to the number of goodPaths.
+            for (int key : group.keySet()) {
+                int size = group.get(key);
+                goodPaths += size * (size + 1) / 2;
+            }
+        }
+        return goodPaths;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2421-number-of-good-paths/README.md b/leetcode/leetcode/2421-number-of-good-paths/README.md
new file mode 100644
index 0000000..2c71021
--- /dev/null
+++ b/leetcode/leetcode/2421-number-of-good-paths/README.md
@@ -0,0 +1,55 @@
+<h2><a href="https://leetcode.com/problems/number-of-good-paths/">2421. Number of Good Paths</a></h2><h3>Hard</h3><hr><div><p>There is a tree (i.e. a connected, undirected graph with no cycles) consisting of <code>n</code> nodes numbered from <code>0</code> to <code>n - 1</code> and exactly <code>n - 1</code> edges.</p>
+
+<p>You are given a <strong>0-indexed</strong> integer array <code>vals</code> of length <code>n</code> where <code>vals[i]</code> denotes the value of the <code>i<sup>th</sup></code> node. You are also given a 2D integer array <code>edges</code> where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> denotes that there exists an <strong>undirected</strong> edge connecting nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>.</p>
+
+<p>A <strong>good path</strong> is a simple path that satisfies the following conditions:</p>
+
+<ol>
+	<li>The starting node and the ending node have the <strong>same</strong> value.</li>
+	<li>All nodes between the starting node and the ending node have values <strong>less than or equal to</strong> the starting node (i.e. the starting node's value should be the maximum value along the path).</li>
+</ol>
+
+<p>Return <em>the number of distinct good paths</em>.</p>
+
+<p>Note that a path and its reverse are counted as the <strong>same</strong> path. For example, <code>0 -&gt; 1</code> is considered to be the same as <code>1 -&gt; 0</code>. A single node is also considered as a valid path.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/08/04/f9caaac15b383af9115c5586779dec5.png" style="width: 400px; height: 333px;">
+<pre><strong>Input:</strong> vals = [1,3,2,1,3], edges = [[0,1],[0,2],[2,3],[2,4]]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> There are 5 good paths consisting of a single node.
+There is 1 additional good path: 1 -&gt; 0 -&gt; 2 -&gt; 4.
+(The reverse path 4 -&gt; 2 -&gt; 0 -&gt; 1 is treated as the same as 1 -&gt; 0 -&gt; 2 -&gt; 4.)
+Note that 0 -&gt; 2 -&gt; 3 is not a good path because vals[2] &gt; vals[0].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/08/04/149d3065ec165a71a1b9aec890776ff.png" style="width: 273px; height: 350px;">
+<pre><strong>Input:</strong> vals = [1,1,2,2,3], edges = [[0,1],[1,2],[2,3],[2,4]]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> There are 5 good paths consisting of a single node.
+There are 2 additional good paths: 0 -&gt; 1 and 2 -&gt; 3.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/08/04/31705e22af3d9c0a557459bc7d1b62d.png" style="width: 100px; height: 88px;">
+<pre><strong>Input:</strong> vals = [1], edges = []
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The tree consists of only one node, so there is one good path.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == vals.length</code></li>
+	<li><code>1 &lt;= n &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= vals[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>edges.length == n - 1</code></li>
+	<li><code>edges[i].length == 2</code></li>
+	<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt; n</code></li>
+	<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
+	<li><code>edges</code> represents a valid tree.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2427-first-letter-to-appear-twice/2427-first-letter-to-appear-twice.java b/leetcode/leetcode/2427-first-letter-to-appear-twice/2427-first-letter-to-appear-twice.java
new file mode 100644
index 0000000..36b8cdf
--- /dev/null
+++ b/leetcode/leetcode/2427-first-letter-to-appear-twice/2427-first-letter-to-appear-twice.java
@@ -0,0 +1,37 @@
+class Solution {
+    // Approach 2: Bit-wise approach.
+    // Using 32-bit number to track 26 alphabet characters.
+    // We are mapping each bit for each character since a number has 32 bit.
+    // if any bit is already set to 1 we return that character
+    public int setKBit(int num, int k) { // Setting the k-bit to 1 in the number num
+        return (1 << k) | num;
+    }
+
+    public boolean checkKBit(int num, int k) { // checking if kth bit is already one if yes return true
+        return ((1 << k) & num) != 0;
+    }
+
+    public char repeatedCharacter(String s) {
+        int value = 0;
+        for (char c : s.toCharArray()) {
+            int k = c - 'a'; // mapping a - 0, b-1, c-2 ... z-25 index
+            if (checkKBit(value, k))
+                return c; // checking for k bit in the number if set to 1 or not
+            value = setKBit(value, k); // setting kth bit to 1 for any character
+        }
+        return '1';
+    }
+}
+
+// Approach 1: Using Frequency array
+// class Solution {
+// public char repeatedCharacter(String s) {
+// boolean[] freq = new boolean[26];
+// for(char c: s.toCharArray()){
+// int index = c - 'a';
+// if(freq[index] == true) return truec;
+// freq[index] = !freq[index];
+// }
+// return '-1';
+// }
+// }
diff --git a/leetcode/leetcode/2427-first-letter-to-appear-twice/README.md b/leetcode/leetcode/2427-first-letter-to-appear-twice/README.md
new file mode 100644
index 0000000..e16f9b1
--- /dev/null
+++ b/leetcode/leetcode/2427-first-letter-to-appear-twice/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/first-letter-to-appear-twice">2427. First Letter to Appear Twice</a></h2><h3>Easy</h3><hr><p>Given a string <code>s</code> consisting of lowercase English letters, return <em>the first letter to appear <strong>twice</strong></em>.</p>
+
+<p><strong>Note</strong>:</p>
+
+<ul>
+	<li>A letter <code>a</code> appears twice before another letter <code>b</code> if the <strong>second</strong> occurrence of <code>a</code> is before the <strong>second</strong> occurrence of <code>b</code>.</li>
+	<li><code>s</code> will contain at least one letter that appears twice.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abccbaacz&quot;
+<strong>Output:</strong> &quot;c&quot;
+<strong>Explanation:</strong>
+The letter &#39;a&#39; appears on the indexes 0, 5 and 6.
+The letter &#39;b&#39; appears on the indexes 1 and 4.
+The letter &#39;c&#39; appears on the indexes 2, 3 and 7.
+The letter &#39;z&#39; appears on the index 8.
+The letter &#39;c&#39; is the first letter to appear twice, because out of all the letters the index of its second occurrence is the smallest.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcdd&quot;
+<strong>Output:</strong> &quot;d&quot;
+<strong>Explanation:</strong>
+The only letter that appears twice is &#39;d&#39; so we return &#39;d&#39;.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= s.length &lt;= 100</code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+	<li><code>s</code> has at least one repeated letter.</li>
+</ul>
diff --git a/leetcode/leetcode/2429-design-a-food-rating-system/2429-design-a-food-rating-system.java b/leetcode/leetcode/2429-design-a-food-rating-system/2429-design-a-food-rating-system.java
new file mode 100644
index 0000000..667fd8e
--- /dev/null
+++ b/leetcode/leetcode/2429-design-a-food-rating-system/2429-design-a-food-rating-system.java
@@ -0,0 +1,61 @@
+class FoodRatings {
+    private Map<String, String> foodCuisineMap = new HashMap<>();
+    private Map<String, Integer> foodRatingMap = new HashMap<>();
+    private Map<String, TreeSet<Pair>> cuisineToPairs = new HashMap<>();
+    class Pair implements Comparable<Pair>{
+        String food;
+        int rating;
+        Pair(String food, int rating){
+            this.food = food;
+            this.rating = rating;
+        }
+        @Override
+        public int compareTo(Pair o) {
+            if (this.rating != o.rating) {
+                return Integer.compare(o.rating, this.rating); // higher rating first
+            }
+            return this.food.compareTo(o.food);
+        }
+
+    }
+
+    public FoodRatings(String[] foods, String[] cuisines, int[] ratings) {
+        for (int i = 0; i < foods.length; i++) {
+            String f = foods[i];
+            String c = cuisines[i];
+            int r = ratings[i];
+            foodCuisineMap.put(f, c);
+            foodRatingMap.put(f, r);
+
+            cuisineToPairs.computeIfAbsent(c, k -> new TreeSet<>()).add(new Pair(f, r));
+        }
+    }
+    
+    public void changeRating(String food, int newRating) {
+        String cuisine = foodCuisineMap.get(food);
+        if (cuisine == null) return;
+        int oldRating = foodRatingMap.getOrDefault(food, newRating);
+        // remove old pair
+        TreeSet<Pair> set = cuisineToPairs.get(cuisine);
+        if (set != null) {
+            set.remove(new Pair(food, oldRating));
+            set.add(new Pair(food, newRating));
+        }
+        foodRatingMap.put(food, newRating);
+
+
+    }
+    
+    public String highestRated(String cuisine) {
+        TreeSet<Pair> set = cuisineToPairs.get(cuisine);
+        if (set == null || set.isEmpty()) return "";
+        return set.first().food;
+    }
+}
+
+/**
+ * Your FoodRatings object will be instantiated and called as such:
+ * FoodRatings obj = new FoodRatings(foods, cuisines, ratings);
+ * obj.changeRating(food,newRating);
+ * String param_2 = obj.highestRated(cuisine);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/2429-design-a-food-rating-system/README.md b/leetcode/leetcode/2429-design-a-food-rating-system/README.md
new file mode 100644
index 0000000..ae2882a
--- /dev/null
+++ b/leetcode/leetcode/2429-design-a-food-rating-system/README.md
@@ -0,0 +1,63 @@
+<h2><a href="https://leetcode.com/problems/design-a-food-rating-system">2429. Design a Food Rating System</a></h2><h3>Medium</h3><hr><p>Design a food rating system that can do the following:</p>
+
+<ul>
+	<li><strong>Modify</strong> the rating of a food item listed in the system.</li>
+	<li>Return the highest-rated food item for a type of cuisine in the system.</li>
+</ul>
+
+<p>Implement the <code>FoodRatings</code> class:</p>
+
+<ul>
+	<li><code>FoodRatings(String[] foods, String[] cuisines, int[] ratings)</code> Initializes the system. The food items are described by <code>foods</code>, <code>cuisines</code> and <code>ratings</code>, all of which have a length of <code>n</code>.
+
+	<ul>
+		<li><code>foods[i]</code> is the name of the <code>i<sup>th</sup></code> food,</li>
+		<li><code>cuisines[i]</code> is the type of cuisine of the <code>i<sup>th</sup></code> food, and</li>
+		<li><code>ratings[i]</code> is the initial rating of the <code>i<sup>th</sup></code> food.</li>
+	</ul>
+	</li>
+	<li><code>void changeRating(String food, int newRating)</code> Changes the rating of the food item with the name <code>food</code>.</li>
+	<li><code>String highestRated(String cuisine)</code> Returns the name of the food item that has the highest rating for the given type of <code>cuisine</code>. If there is a tie, return the item with the <strong>lexicographically smaller</strong> name.</li>
+</ul>
+
+<p>Note that a string <code>x</code> is lexicographically smaller than string <code>y</code> if <code>x</code> comes before <code>y</code> in dictionary order, that is, either <code>x</code> is a prefix of <code>y</code>, or if <code>i</code> is the first position such that <code>x[i] != y[i]</code>, then <code>x[i]</code> comes before <code>y[i]</code> in alphabetic order.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input</strong>
+[&quot;FoodRatings&quot;, &quot;highestRated&quot;, &quot;highestRated&quot;, &quot;changeRating&quot;, &quot;highestRated&quot;, &quot;changeRating&quot;, &quot;highestRated&quot;]
+[[[&quot;kimchi&quot;, &quot;miso&quot;, &quot;sushi&quot;, &quot;moussaka&quot;, &quot;ramen&quot;, &quot;bulgogi&quot;], [&quot;korean&quot;, &quot;japanese&quot;, &quot;japanese&quot;, &quot;greek&quot;, &quot;japanese&quot;, &quot;korean&quot;], [9, 12, 8, 15, 14, 7]], [&quot;korean&quot;], [&quot;japanese&quot;], [&quot;sushi&quot;, 16], [&quot;japanese&quot;], [&quot;ramen&quot;, 16], [&quot;japanese&quot;]]
+<strong>Output</strong>
+[null, &quot;kimchi&quot;, &quot;ramen&quot;, null, &quot;sushi&quot;, null, &quot;ramen&quot;]
+
+<strong>Explanation</strong>
+FoodRatings foodRatings = new FoodRatings([&quot;kimchi&quot;, &quot;miso&quot;, &quot;sushi&quot;, &quot;moussaka&quot;, &quot;ramen&quot;, &quot;bulgogi&quot;], [&quot;korean&quot;, &quot;japanese&quot;, &quot;japanese&quot;, &quot;greek&quot;, &quot;japanese&quot;, &quot;korean&quot;], [9, 12, 8, 15, 14, 7]);
+foodRatings.highestRated(&quot;korean&quot;); // return &quot;kimchi&quot;
+                                    // &quot;kimchi&quot; is the highest rated korean food with a rating of 9.
+foodRatings.highestRated(&quot;japanese&quot;); // return &quot;ramen&quot;
+                                      // &quot;ramen&quot; is the highest rated japanese food with a rating of 14.
+foodRatings.changeRating(&quot;sushi&quot;, 16); // &quot;sushi&quot; now has a rating of 16.
+foodRatings.highestRated(&quot;japanese&quot;); // return &quot;sushi&quot;
+                                      // &quot;sushi&quot; is the highest rated japanese food with a rating of 16.
+foodRatings.changeRating(&quot;ramen&quot;, 16); // &quot;ramen&quot; now has a rating of 16.
+foodRatings.highestRated(&quot;japanese&quot;); // return &quot;ramen&quot;
+                                      // Both &quot;sushi&quot; and &quot;ramen&quot; have a rating of 16.
+                                      // However, &quot;ramen&quot; is lexicographically smaller than &quot;sushi&quot;.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>n == foods.length == cuisines.length == ratings.length</code></li>
+	<li><code>1 &lt;= foods[i].length, cuisines[i].length &lt;= 10</code></li>
+	<li><code>foods[i]</code>, <code>cuisines[i]</code> consist of lowercase English letters.</li>
+	<li><code>1 &lt;= ratings[i] &lt;= 10<sup>8</sup></code></li>
+	<li>All the strings in <code>foods</code> are <strong>distinct</strong>.</li>
+	<li><code>food</code> will be the name of a food item in the system across all calls to <code>changeRating</code>.</li>
+	<li><code>cuisine</code> will be a type of cuisine of <strong>at least one</strong> food item in the system across all calls to <code>highestRated</code>.</li>
+	<li>At most <code>2 * 10<sup>4</sup></code> calls <strong>in total</strong> will be made to <code>changeRating</code> and <code>highestRated</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/2448-count-number-of-bad-pairs/2448-count-number-of-bad-pairs.java b/leetcode/leetcode/2448-count-number-of-bad-pairs/2448-count-number-of-bad-pairs.java
new file mode 100644
index 0000000..c95cb40
--- /dev/null
+++ b/leetcode/leetcode/2448-count-number-of-bad-pairs/2448-count-number-of-bad-pairs.java
@@ -0,0 +1,14 @@
+class Solution {
+    public long countBadPairs(int[] nums) {
+        long ans =(long) (nums.length)*(nums.length-1)/2;
+        HashMap<Integer,Integer> map = new HashMap<>();
+
+        for(int i = 0;i<nums.length;i++){
+            int temp = map.getOrDefault(nums[i]-i,0);
+            ans-= temp;
+            map.put(nums[i]-i,temp+1);
+        }
+        return ans;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2448-count-number-of-bad-pairs/README.md b/leetcode/leetcode/2448-count-number-of-bad-pairs/README.md
new file mode 100644
index 0000000..83d0ed4
--- /dev/null
+++ b/leetcode/leetcode/2448-count-number-of-bad-pairs/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/count-number-of-bad-pairs">2448. Count Number of Bad Pairs</a></h2><h3>Medium</h3><hr><p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>. A pair of indices <code>(i, j)</code> is a <strong>bad pair</strong> if <code>i &lt; j</code> and <code>j - i != nums[j] - nums[i]</code>.</p>
+
+<p>Return<em> the total number of <strong>bad pairs</strong> in </em><code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [4,1,3,3]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The pair (0, 1) is a bad pair since 1 - 0 != 1 - 4.
+The pair (0, 2) is a bad pair since 2 - 0 != 3 - 4, 2 != -1.
+The pair (0, 3) is a bad pair since 3 - 0 != 3 - 4, 3 != -1.
+The pair (1, 2) is a bad pair since 2 - 1 != 3 - 1, 1 != 2.
+The pair (2, 3) is a bad pair since 3 - 2 != 3 - 3, 1 != 0.
+There are a total of 5 bad pairs, so we return 5.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,4,5]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There are no bad pairs.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/2461-amount-of-time-for-binary-tree-to-be-infected/2461-amount-of-time-for-binary-tree-to-be-infected.java b/leetcode/leetcode/2461-amount-of-time-for-binary-tree-to-be-infected/2461-amount-of-time-for-binary-tree-to-be-infected.java
new file mode 100644
index 0000000..c0aedac
--- /dev/null
+++ b/leetcode/leetcode/2461-amount-of-time-for-binary-tree-to-be-infected/2461-amount-of-time-for-binary-tree-to-be-infected.java
@@ -0,0 +1,67 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int amountOfTime(TreeNode root, int start) {
+        if(root == null) return 0;
+        if(root.left == null && root.right == null) return 0;
+        HashMap<TreeNode,TreeNode> parents = new HashMap<>();
+        Queue<TreeNode> q                  = new LinkedList<>();
+        TreeNode mainNode                  = null;
+        q.add(root);
+        while(!q.isEmpty()){
+            for(int i = q.size();i!=0;i--){
+                TreeNode node = q.poll();
+                if(node.val == start) mainNode = node;
+
+                if(node.left != null){
+                    parents.put(node.left,node);
+                    q.add(node.left);
+                }
+
+                if(node.right != null){
+                    parents.put(node.right,node);
+                    q.add(node.right);
+                }
+            }
+
+        }
+        q.add(mainNode);
+        int time = 0;
+        HashSet<TreeNode> visited = new HashSet<>();
+        visited.add(mainNode);
+        while(!q.isEmpty()){
+            for(int i = q.size();i!=0;i--){
+                TreeNode node = q.poll();
+                if(node.left != null && !visited.contains(node.left)){
+                    q.add(node.left);
+                }
+
+                if(node.right!=null && !visited.contains(node.right)){
+                    q.add(node.right);
+
+                }
+
+                if(parents.containsKey(node) && !visited.contains(parents.get(node))){
+                    q.add(parents.get(node));
+                }
+                visited.add(node);
+
+            }
+            time++;
+        }
+        return time-1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2461-amount-of-time-for-binary-tree-to-be-infected/README.md b/leetcode/leetcode/2461-amount-of-time-for-binary-tree-to-be-infected/README.md
new file mode 100644
index 0000000..e3054e3
--- /dev/null
+++ b/leetcode/leetcode/2461-amount-of-time-for-binary-tree-to-be-infected/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/amount-of-time-for-binary-tree-to-be-infected">2461. Amount of Time for Binary Tree to Be Infected</a></h2><h3>Medium</h3><hr><p>You are given the <code>root</code> of a binary tree with <strong>unique</strong> values, and an integer <code>start</code>. At minute <code>0</code>, an <strong>infection</strong> starts from the node with value <code>start</code>.</p>
+
+<p>Each minute, a node becomes infected if:</p>
+
+<ul>
+	<li>The node is currently uninfected.</li>
+	<li>The node is adjacent to an infected node.</li>
+</ul>
+
+<p>Return <em>the number of minutes needed for the entire tree to be infected.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/06/25/image-20220625231744-1.png" style="width: 400px; height: 306px;" />
+<pre>
+<strong>Input:</strong> root = [1,5,3,null,4,10,6,9,2], start = 3
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The following nodes are infected during:
+- Minute 0: Node 3
+- Minute 1: Nodes 1, 10 and 6
+- Minute 2: Node 5
+- Minute 3: Node 4
+- Minute 4: Nodes 9 and 2
+It takes 4 minutes for the whole tree to be infected so we return 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/06/25/image-20220625231812-2.png" style="width: 75px; height: 66px;" />
+<pre>
+<strong>Input:</strong> root = [1], start = 1
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> At minute 0, the only node in the tree is infected so we return 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li>Each node has a <strong>unique</strong> value.</li>
+	<li>A node with a value of <code>start</code> exists in the tree.</li>
+</ul>
diff --git a/leetcode/leetcode/2463-minimum-recolors-to-get-k-consecutive-black-blocks/2463-minimum-recolors-to-get-k-consecutive-black-blocks.java b/leetcode/leetcode/2463-minimum-recolors-to-get-k-consecutive-black-blocks/2463-minimum-recolors-to-get-k-consecutive-black-blocks.java
new file mode 100644
index 0000000..60b57cb
--- /dev/null
+++ b/leetcode/leetcode/2463-minimum-recolors-to-get-k-consecutive-black-blocks/2463-minimum-recolors-to-get-k-consecutive-black-blocks.java
@@ -0,0 +1,27 @@
+class Solution {
+
+    public int minimumRecolors(String blocks, int k) {
+        int left = 0, numWhites = 0, numRecolors = Integer.MAX_VALUE;
+
+        // Move right pointer
+        for (int right = 0; right < blocks.length(); right++) {
+            // Increment numWhites if block at right pointer is white
+            if (blocks.charAt(right) == 'W') {
+                numWhites++;
+            }
+
+            // k consecutive elements are found
+            if (right - left + 1 == k) {
+                // Update minumum
+                numRecolors = Math.min(numRecolors, numWhites);
+
+                // Decrement numWhites if block at left pointer is white
+                if (blocks.charAt(left) == 'W') numWhites--;
+
+                // Move left pointer
+                left++;
+            }
+        }
+        return numRecolors;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2463-minimum-recolors-to-get-k-consecutive-black-blocks/README.md b/leetcode/leetcode/2463-minimum-recolors-to-get-k-consecutive-black-blocks/README.md
new file mode 100644
index 0000000..cb54286
--- /dev/null
+++ b/leetcode/leetcode/2463-minimum-recolors-to-get-k-consecutive-black-blocks/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/minimum-recolors-to-get-k-consecutive-black-blocks">2463. Minimum Recolors to Get K Consecutive Black Blocks</a></h2><h3>Easy</h3><hr><p>You are given a <strong>0-indexed</strong> string <code>blocks</code> of length <code>n</code>, where <code>blocks[i]</code> is either <code>&#39;W&#39;</code> or <code>&#39;B&#39;</code>, representing the color of the <code>i<sup>th</sup></code> block. The characters <code>&#39;W&#39;</code> and <code>&#39;B&#39;</code> denote the colors white and black, respectively.</p>
+
+<p>You are also given an integer <code>k</code>, which is the desired number of <strong>consecutive</strong> black blocks.</p>
+
+<p>In one operation, you can <strong>recolor</strong> a white block such that it becomes a black block.</p>
+
+<p>Return<em> the <strong>minimum</strong> number of operations needed such that there is at least <strong>one</strong> occurrence of </em><code>k</code><em> consecutive black blocks.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> blocks = &quot;WBBWWBBWBW&quot;, k = 7
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+One way to achieve 7 consecutive black blocks is to recolor the 0th, 3rd, and 4th blocks
+so that blocks = &quot;BBBBBBBWBW&quot;. 
+It can be shown that there is no way to achieve 7 consecutive black blocks in less than 3 operations.
+Therefore, we return 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> blocks = &quot;WBWBBBW&quot;, k = 2
+<strong>Output:</strong> 0
+<strong>Explanation:</strong>
+No changes need to be made, since 2 consecutive black blocks already exist.
+Therefore, we return 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == blocks.length</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>blocks[i]</code> is either <code>&#39;W&#39;</code> or <code>&#39;B&#39;</code>.</li>
+	<li><code>1 &lt;= k &lt;= n</code></li>
+</ul>
diff --git a/leetcode/leetcode/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.java b/leetcode/leetcode/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.java
new file mode 100644
index 0000000..c5717d4
--- /dev/null
+++ b/leetcode/leetcode/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.java
@@ -0,0 +1,68 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+
+    public int minimumOperations(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        int totalSwaps = 0;
+
+        // Process tree level by level using BFS
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size();
+            int[] levelValues = new int[levelSize];
+
+            // Store values of current level and add children to queue
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode node = queue.poll();
+                levelValues[i] = node.val;
+
+                if (node.left != null) queue.add(node.left);
+                if (node.right != null) queue.add(node.right);
+            }
+
+            // Add minimum swaps needed for current level
+            totalSwaps += getMinSwaps(levelValues);
+        }
+        return totalSwaps;
+    }
+
+    // Calculate minimum swaps needed to sort an array
+    private int getMinSwaps(int[] original) {
+        int swaps = 0;
+        int[] target = original.clone();
+        Arrays.sort(target);
+
+        // Map to track current positions of values
+        Map<Integer, Integer> pos = new HashMap<>();
+        for (int i = 0; i < original.length; i++) {
+            pos.put(original[i], i);
+        }
+
+        // For each position, swap until correct value is placed
+        for (int i = 0; i < original.length; i++) {
+            if (original[i] != target[i]) {
+                swaps++;
+
+                // Update position of swapped values
+                int curPos = pos.get(target[i]);
+                pos.put(original[i], curPos);
+                original[curPos] = original[i];
+            }
+        }
+        return swaps;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level/README.md b/leetcode/leetcode/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level/README.md
new file mode 100644
index 0000000..bfcc654
--- /dev/null
+++ b/leetcode/leetcode/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/minimum-number-of-operations-to-sort-a-binary-tree-by-level/">2471. Minimum Number of Operations to Sort a Binary Tree by Level</a></h2><h3>Medium</h3><hr><div><p>You are given the <code>root</code> of a binary tree with <strong>unique values</strong>.</p>
+
+<p>In one operation, you can choose any two nodes <strong>at the same level</strong> and swap their values.</p>
+
+<p>Return <em>the minimum number of operations needed to make the values at each level sorted in a <strong>strictly increasing order</strong></em>.</p>
+
+<p>The <strong>level</strong> of a node is the number of edges along the path between it and the root node<em>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2022/09/18/image-20220918174006-2.png" style="width: 500px; height: 324px;">
+<pre><strong>Input:</strong> root = [1,4,3,7,6,8,5,null,null,null,null,9,null,10]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+- Swap 4 and 3. The 2<sup>nd</sup> level becomes [3,4].
+- Swap 7 and 5. The 3<sup>rd</sup> level becomes [5,6,8,7].
+- Swap 8 and 7. The 3<sup>rd</sup> level becomes [5,6,7,8].
+We used 3 operations so return 3.
+It can be proven that 3 is the minimum number of operations needed.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2022/09/18/image-20220918174026-3.png" style="width: 400px; height: 303px;">
+<pre><strong>Input:</strong> root = [1,3,2,7,6,5,4]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+- Swap 3 and 2. The 2<sup>nd</sup> level becomes [2,3].
+- Swap 7 and 4. The 3<sup>rd</sup> level becomes [4,6,5,7].
+- Swap 6 and 5. The 3<sup>rd</sup> level becomes [4,5,6,7].
+We used 3 operations so return 3.
+It can be proven that 3 is the minimum number of operations needed.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2022/09/18/image-20220918174052-4.png" style="width: 400px; height: 274px;">
+<pre><strong>Input:</strong> root = [1,2,3,4,5,6]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> Each level is already sorted in increasing order so return 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li>All the values of the tree are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2478-longest-nice-subarray/2478-longest-nice-subarray.java b/leetcode/leetcode/2478-longest-nice-subarray/2478-longest-nice-subarray.java
new file mode 100644
index 0000000..4d942eb
--- /dev/null
+++ b/leetcode/leetcode/2478-longest-nice-subarray/2478-longest-nice-subarray.java
@@ -0,0 +1,27 @@
+class Solution {
+
+    public int longestNiceSubarray(int[] nums) {
+        int ans   = 0;
+        int start = 0;
+        int end   = 0;
+        int curr  = 0;
+        while(end<nums.length){
+            while(end< nums.length && (curr & nums[end]) == 0 ){
+                curr = curr | nums[end];
+                ans = Math.max(ans,end-start+1);
+                end++;
+
+            }
+            curr = curr ^ nums[start];
+            start++;
+        }
+        return ans;
+    }
+}
+/*
+0 1 1 0 1
+
+
+0 1 0 0 0
+
+*/
\ No newline at end of file
diff --git a/leetcode/leetcode/2478-longest-nice-subarray/README.md b/leetcode/leetcode/2478-longest-nice-subarray/README.md
new file mode 100644
index 0000000..0635d55
--- /dev/null
+++ b/leetcode/leetcode/2478-longest-nice-subarray/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/longest-nice-subarray">2478. Longest Nice Subarray</a></h2><h3>Medium</h3><hr><p>You are given an array <code>nums</code> consisting of <strong>positive</strong> integers.</p>
+
+<p>We call a subarray of <code>nums</code> <strong>nice</strong> if the bitwise <strong>AND</strong> of every pair of elements that are in <strong>different</strong> positions in the subarray is equal to <code>0</code>.</p>
+
+<p>Return <em>the length of the <strong>longest</strong> nice subarray</em>.</p>
+
+<p>A <strong>subarray</strong> is a <strong>contiguous</strong> part of an array.</p>
+
+<p><strong>Note</strong> that subarrays of length <code>1</code> are always considered nice.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,3,8,48,10]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The longest nice subarray is [3,8,48]. This subarray satisfies the conditions:
+- 3 AND 8 = 0.
+- 3 AND 48 = 0.
+- 8 AND 48 = 0.
+It can be proven that no longer nice subarray can be obtained, so we return 3.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,1,5,11,13]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The length of the longest nice subarray is 1. Any subarray of length 1 can be chosen.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/2482-difference-between-ones-and-zeros-in-row-and-column.java b/leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/2482-difference-between-ones-and-zeros-in-row-and-column.java
new file mode 100644
index 0000000..4317d0c
--- /dev/null
+++ b/leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/2482-difference-between-ones-and-zeros-in-row-and-column.java
@@ -0,0 +1,28 @@
+class Solution {
+  public int[][] onesMinusZeros(int[][] grid) {
+    int m = grid.length;
+    int n = grid[0].length;
+
+    int[] onesRow = new int[m];
+    int[] onesCol = new int[n];
+
+    Arrays.fill(onesRow, 0);
+    Arrays.fill(onesCol, 0);
+
+    for (int i = 0; i < m; i++) {
+      for (int j = 0; j < n; j++) {
+        onesRow[i] += grid[i][j];
+        onesCol[j] += grid[i][j];
+      }
+    }
+
+    int[][] diff = new int[m][n];
+    for (int i = 0; i < m; i++) {
+      for (int j = 0; j < n; j++) {
+        diff[i][j] = 2 * onesRow[i] + 2 * onesCol[j] - n - m;
+      }
+    }
+
+    return diff;
+  }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/NOTES.md b/leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/README.md b/leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/README.md
new file mode 100644
index 0000000..3353ff5
--- /dev/null
+++ b/leetcode/leetcode/2482-difference-between-ones-and-zeros-in-row-and-column/README.md
@@ -0,0 +1,55 @@
+<h2><a href="https://leetcode.com/problems/difference-between-ones-and-zeros-in-row-and-column/">2482. Difference Between Ones and Zeros in Row and Column</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p>
+
+<p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p>
+
+<ul>
+	<li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li>
+	<li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li>
+	<li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li>
+	<li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li>
+	<li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li>
+</ul>
+
+<p>Return <em>the difference matrix </em><code>diff</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;">
+<pre><strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]]
+<strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]]
+<strong>Explanation:</strong>
+- diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 
+- diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 
+- diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 
+- diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 
+- diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 
+- diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 
+- diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2
+- diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2
+- diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;">
+<pre><strong>Input:</strong> grid = [[1,1,1],[1,1,1]]
+<strong>Output:</strong> [[5,5,5],[5,5,5]]
+<strong>Explanation:</strong>
+- diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5
+- diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5
+- diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5
+- diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5
+- diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5
+- diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
+	<li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2487-remove-nodes-from-linked-list/2487-remove-nodes-from-linked-list.java b/leetcode/leetcode/2487-remove-nodes-from-linked-list/2487-remove-nodes-from-linked-list.java
new file mode 100644
index 0000000..f82a9c0
--- /dev/null
+++ b/leetcode/leetcode/2487-remove-nodes-from-linked-list/2487-remove-nodes-from-linked-list.java
@@ -0,0 +1,51 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode reverse(ListNode head){
+        if(head == null || head.next == null) return head;
+        ListNode prev = null;
+        ListNode curr = head;
+        ListNode next = head.next;
+        while(next!=null){
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+            next = next.next;
+        }
+        curr.next = prev;
+        return curr;
+    }
+    public ListNode removeNodes(ListNode head) {
+        if(head == null || head.next == null) return head;
+        head = reverse(head);
+        int max = head.val;
+        ListNode prev = null;
+        ListNode temp = head;
+        ListNode next = head.next;
+        while(temp!=null){
+            if(temp.val<max){
+                prev.next = next;
+                temp = next;
+                if(next == null) break;
+                next = next.next;
+                continue;
+            }
+            max = Math.max(max,temp.val);
+            prev = temp;
+            temp = temp.next;
+            if(next == null) break;
+            
+            next = next.next;
+        }
+        return reverse(head);
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2487-remove-nodes-from-linked-list/NOTES.md b/leetcode/leetcode/2487-remove-nodes-from-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2487-remove-nodes-from-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2487-remove-nodes-from-linked-list/README.md b/leetcode/leetcode/2487-remove-nodes-from-linked-list/README.md
new file mode 100644
index 0000000..85da83f
--- /dev/null
+++ b/leetcode/leetcode/2487-remove-nodes-from-linked-list/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/remove-nodes-from-linked-list/">2487. Remove Nodes From Linked List</a></h2><h3>Medium</h3><hr><div><p>You are given the <code>head</code> of a linked list.</p>
+
+<p>Remove every node which has a node with a <strong>strictly greater</strong> value anywhere to the right side of it.</p>
+
+<p>Return <em>the </em><code>head</code><em> of the modified linked list.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/10/02/drawio.png" style="width: 631px; height: 51px;">
+<pre><strong>Input:</strong> head = [5,2,13,3,8]
+<strong>Output:</strong> [13,8]
+<strong>Explanation:</strong> The nodes that should be removed are 5, 2 and 3.
+- Node 13 is to the right of node 5.
+- Node 13 is to the right of node 2.
+- Node 8 is to the right of node 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,1,1,1]
+<strong>Output:</strong> [1,1,1,1]
+<strong>Explanation:</strong> Every node has value 1, so no nodes are removed.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of the nodes in the given list is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2493-reverse-odd-levels-of-binary-tree/2493-reverse-odd-levels-of-binary-tree.java b/leetcode/leetcode/2493-reverse-odd-levels-of-binary-tree/2493-reverse-odd-levels-of-binary-tree.java
new file mode 100644
index 0000000..516f1ef
--- /dev/null
+++ b/leetcode/leetcode/2493-reverse-odd-levels-of-binary-tree/2493-reverse-odd-levels-of-binary-tree.java
@@ -0,0 +1,51 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode reverseOddLevels(TreeNode root) {
+        TreeNode temp = root;
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+        boolean level = false;
+
+        while(!q.isEmpty()){
+            Queue<TreeNode> tempQ = new LinkedList<>();
+            Stack<Integer> tempS = new Stack<>();
+            for(int i = q.size();i!=0;i--){
+                if(level){
+                    tempQ.add(q.peek());
+                    tempS.add(q.poll().val);
+                }else{
+                    root = q.poll();
+                    if(root.left!=null) q.add(root.left);
+                    if(root.right!=null) q.add(root.right);
+                }
+            }
+
+            if(level){
+                while(!tempQ.isEmpty()){
+                    root = tempQ.poll();
+                    if(root.left!=null) q.add(root.left);
+                    if(root.right!=null) q.add(root.right);
+
+                    root.val = tempS.pop();
+                }
+            }
+            level = !level;
+        }
+        return temp;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2493-reverse-odd-levels-of-binary-tree/README.md b/leetcode/leetcode/2493-reverse-odd-levels-of-binary-tree/README.md
new file mode 100644
index 0000000..b5dd3a1
--- /dev/null
+++ b/leetcode/leetcode/2493-reverse-odd-levels-of-binary-tree/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/reverse-odd-levels-of-binary-tree">2493. Reverse Odd Levels of Binary Tree</a></h2><h3>Medium</h3><hr><p>Given the <code>root</code> of a <strong>perfect</strong> binary tree, reverse the node values at each <strong>odd</strong> level of the tree.</p>
+
+<ul>
+	<li>For example, suppose the node values at level 3 are <code>[2,1,3,4,7,11,29,18]</code>, then it should become <code>[18,29,11,7,4,3,1,2]</code>.</li>
+</ul>
+
+<p>Return <em>the root of the reversed tree</em>.</p>
+
+<p>A binary tree is <strong>perfect</strong> if all parent nodes have two children and all leaves are on the same level.</p>
+
+<p>The <strong>level</strong> of a node is the number of edges along the path between it and the root node.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/07/28/first_case1.png" style="width: 626px; height: 191px;" />
+<pre>
+<strong>Input:</strong> root = [2,3,5,8,13,21,34]
+<strong>Output:</strong> [2,5,3,8,13,21,34]
+<strong>Explanation:</strong> 
+The tree has only one odd level.
+The nodes at level 1 are 3, 5 respectively, which are reversed and become 5, 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/07/28/second_case3.png" style="width: 591px; height: 111px;" />
+<pre>
+<strong>Input:</strong> root = [7,13,11]
+<strong>Output:</strong> [7,11,13]
+<strong>Explanation:</strong> 
+The nodes at level 1 are 13, 11, which are reversed and become 11, 13.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> root = [0,1,2,0,0,0,0,1,1,1,1,2,2,2,2]
+<strong>Output:</strong> [0,2,1,0,0,0,0,2,2,2,2,1,1,1,1]
+<strong>Explanation:</strong> 
+The odd levels have non-zero values.
+The nodes at level 1 were 1, 2, and are 2, 1 after the reversal.
+The nodes at level 3 were 1, 1, 1, 1, 2, 2, 2, 2, and are 2, 2, 2, 2, 1, 1, 1, 1 after the reversal.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 2<sup>14</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li><code>root</code> is a <strong>perfect</strong> binary tree.</li>
+</ul>
diff --git a/leetcode/leetcode/2551-apply-operations-to-an-array/2551-apply-operations-to-an-array.java b/leetcode/leetcode/2551-apply-operations-to-an-array/2551-apply-operations-to-an-array.java
new file mode 100644
index 0000000..701d2f6
--- /dev/null
+++ b/leetcode/leetcode/2551-apply-operations-to-an-array/2551-apply-operations-to-an-array.java
@@ -0,0 +1,28 @@
+class Solution {
+    public void swap(int[] arr, int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    } 
+    public int[] applyOperations(int[] nums) {
+        if(nums.length == 1) return nums;
+        for(int i = 0;i<nums.length - 1;i++){
+            if(nums[i] == nums[i+1]){
+                nums[i] = 2*nums[i];
+                nums[i+1] = 0;
+                i++;
+            }
+        }
+        
+        int indexToSwap = 0;
+        for(int i = 0;i<nums.length;i++){
+            if(nums[i] != 0)     {
+                swap(nums,i,indexToSwap);
+                indexToSwap++;
+  
+            }        
+ 
+        }
+        return nums;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2551-apply-operations-to-an-array/README.md b/leetcode/leetcode/2551-apply-operations-to-an-array/README.md
new file mode 100644
index 0000000..db6fe73
--- /dev/null
+++ b/leetcode/leetcode/2551-apply-operations-to-an-array/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/apply-operations-to-an-array">2551. Apply Operations to an Array</a></h2><h3>Easy</h3><hr><p>You are given a <strong>0-indexed</strong> array <code>nums</code> of size <code>n</code> consisting of <strong>non-negative</strong> integers.</p>
+
+<p>You need to apply <code>n - 1</code> operations to this array where, in the <code>i<sup>th</sup></code> operation (<strong>0-indexed</strong>), you will apply the following on the <code>i<sup>th</sup></code> element of <code>nums</code>:</p>
+
+<ul>
+	<li>If <code>nums[i] == nums[i + 1]</code>, then multiply <code>nums[i]</code> by <code>2</code> and set <code>nums[i + 1]</code> to <code>0</code>. Otherwise, you skip this operation.</li>
+</ul>
+
+<p>After performing <strong>all</strong> the operations, <strong>shift</strong> all the <code>0</code>&#39;s to the <strong>end</strong> of the array.</p>
+
+<ul>
+	<li>For example, the array <code>[1,0,2,0,0,1]</code> after shifting all its <code>0</code>&#39;s to the end, is <code>[1,2,1,0,0,0]</code>.</li>
+</ul>
+
+<p>Return <em>the resulting array</em>.</p>
+
+<p><strong>Note</strong> that the operations are applied <strong>sequentially</strong>, not all at once.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,2,1,1,0]
+<strong>Output:</strong> [1,4,2,0,0,0]
+<strong>Explanation:</strong> We do the following operations:
+- i = 0: nums[0] and nums[1] are not equal, so we skip this operation.
+- i = 1: nums[1] and nums[2] are equal, we multiply nums[1] by 2 and change nums[2] to 0. The array becomes [1,<strong><u>4</u></strong>,<strong><u>0</u></strong>,1,1,0].
+- i = 2: nums[2] and nums[3] are not equal, so we skip this operation.
+- i = 3: nums[3] and nums[4] are equal, we multiply nums[3] by 2 and change nums[4] to 0. The array becomes [1,4,0,<strong><u>2</u></strong>,<strong><u>0</u></strong>,0].
+- i = 4: nums[4] and nums[5] are equal, we multiply nums[4] by 2 and change nums[5] to 0. The array becomes [1,4,0,2,<strong><u>0</u></strong>,<strong><u>0</u></strong>].
+After that, we shift the 0&#39;s to the end, which gives the array [1,4,2,0,0,0].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [0,1]
+<strong>Output:</strong> [1,0]
+<strong>Explanation:</strong> No operation can be applied, we just shift the 0 to the end.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 2000</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/2564-most-profitable-path-in-a-tree/2564-most-profitable-path-in-a-tree.java b/leetcode/leetcode/2564-most-profitable-path-in-a-tree/2564-most-profitable-path-in-a-tree.java
new file mode 100644
index 0000000..ab6a686
--- /dev/null
+++ b/leetcode/leetcode/2564-most-profitable-path-in-a-tree/2564-most-profitable-path-in-a-tree.java
@@ -0,0 +1,68 @@
+class Solution {
+
+    public int mostProfitablePath(int[][] edges, int bob, int[] amount) {
+        n = amount.length;
+        tree = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            tree.add(new ArrayList<>());
+        }
+        distanceFromBob = new int[n];
+
+        // Form tree with edges
+        for (int[] edge : edges) {
+            tree.get(edge[0]).add(edge[1]);
+            tree.get(edge[1]).add(edge[0]);
+        }
+
+        return findPaths(0, 0, 0, bob, amount);
+    }
+
+    private List<List<Integer>> tree;
+    private int[] distanceFromBob;
+    private int n;
+
+    // Depth-first Search
+    private int findPaths(
+        int sourceNode,
+        int parentNode,
+        int time,
+        int bob,
+        int[] amount
+    ) {
+        int maxIncome = 0, maxChild = Integer.MIN_VALUE;
+
+        // Find the node distances from Bob
+        if (sourceNode == bob) {
+            distanceFromBob[sourceNode] = 0;
+        } else {
+            distanceFromBob[sourceNode] = n;
+        }
+
+        for (int adjacentNode : tree.get(sourceNode)) {
+            if (adjacentNode != parentNode) {
+                maxChild = Math.max(
+                    maxChild,
+                    findPaths(adjacentNode, sourceNode, time + 1, bob, amount)
+                );
+                distanceFromBob[sourceNode] = Math.min(
+                    distanceFromBob[sourceNode],
+                    distanceFromBob[adjacentNode] + 1
+                );
+            }
+        }
+
+        // Alice reaches the node first
+        if (distanceFromBob[sourceNode] > time) {
+            maxIncome += amount[sourceNode];
+        }
+        // Alice and Bob reach the node at the same time
+        else if (distanceFromBob[sourceNode] == time) {
+            maxIncome += amount[sourceNode] / 2;
+        }
+
+        // Return max income of leaf node
+        return (maxChild == Integer.MIN_VALUE)
+            ? maxIncome
+            : maxIncome + maxChild;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2564-most-profitable-path-in-a-tree/README.md b/leetcode/leetcode/2564-most-profitable-path-in-a-tree/README.md
new file mode 100644
index 0000000..e56db62
--- /dev/null
+++ b/leetcode/leetcode/2564-most-profitable-path-in-a-tree/README.md
@@ -0,0 +1,69 @@
+<h2><a href="https://leetcode.com/problems/most-profitable-path-in-a-tree">2564. Most Profitable Path in a Tree</a></h2><h3>Medium</h3><hr><p>There is an undirected tree with <code>n</code> nodes labeled from <code>0</code> to <code>n - 1</code>, rooted at node <code>0</code>. You are given a 2D integer array <code>edges</code> of length <code>n - 1</code> where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the tree.</p>
+
+<p>At every node <code>i</code>, there is a gate. You are also given an array of even integers <code>amount</code>, where <code>amount[i]</code> represents:</p>
+
+<ul>
+	<li>the price needed to open the gate at node <code>i</code>, if <code>amount[i]</code> is negative, or,</li>
+	<li>the cash reward obtained on opening the gate at node <code>i</code>, otherwise.</li>
+</ul>
+
+<p>The game goes on as follows:</p>
+
+<ul>
+	<li>Initially, Alice is at node <code>0</code> and Bob is at node <code>bob</code>.</li>
+	<li>At every second, Alice and Bob <b>each</b> move to an adjacent node. Alice moves towards some <strong>leaf node</strong>, while Bob moves towards node <code>0</code>.</li>
+	<li>For <strong>every</strong> node along their path, Alice and Bob either spend money to open the gate at that node, or accept the reward. Note that:
+	<ul>
+		<li>If the gate is <strong>already open</strong>, no price will be required, nor will there be any cash reward.</li>
+		<li>If Alice and Bob reach the node <strong>simultaneously</strong>, they share the price/reward for opening the gate there. In other words, if the price to open the gate is <code>c</code>, then both Alice and Bob pay&nbsp;<code>c / 2</code> each. Similarly, if the reward at the gate is <code>c</code>, both of them receive <code>c / 2</code> each.</li>
+	</ul>
+	</li>
+	<li>If Alice reaches a leaf node, she stops moving. Similarly, if Bob reaches node <code>0</code>, he stops moving. Note that these events are <strong>independent</strong> of each other.</li>
+</ul>
+
+<p>Return<em> the <strong>maximum</strong> net income Alice can have if she travels towards the optimal leaf node.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/10/29/eg1.png" style="width: 275px; height: 275px;" />
+<pre>
+<strong>Input:</strong> edges = [[0,1],[1,2],[1,3],[3,4]], bob = 3, amount = [-2,4,2,-4,6]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> 
+The above diagram represents the given tree. The game goes as follows:
+- Alice is initially on node 0, Bob on node 3. They open the gates of their respective nodes.
+  Alice&#39;s net income is now -2.
+- Both Alice and Bob move to node 1. 
+&nbsp; Since they reach here simultaneously, they open the gate together and share the reward.
+&nbsp; Alice&#39;s net income becomes -2 + (4 / 2) = 0.
+- Alice moves on to node 3. Since Bob already opened its gate, Alice&#39;s income remains unchanged.
+&nbsp; Bob moves on to node 0, and stops moving.
+- Alice moves on to node 4 and opens the gate there. Her net income becomes 0 + 6 = 6.
+Now, neither Alice nor Bob can make any further moves, and the game ends.
+It is not possible for Alice to get a higher net income.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/10/29/eg2.png" style="width: 250px; height: 78px;" />
+<pre>
+<strong>Input:</strong> edges = [[0,1]], bob = 1, amount = [-7280,2350]
+<strong>Output:</strong> -7280
+<strong>Explanation:</strong> 
+Alice follows the path 0-&gt;1 whereas Bob follows the path 1-&gt;0.
+Thus, Alice opens the gate at node 0 only. Hence, her net income is -7280. 
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>edges.length == n - 1</code></li>
+	<li><code>edges[i].length == 2</code></li>
+	<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt; n</code></li>
+	<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
+	<li><code>edges</code> represents a valid tree.</li>
+	<li><code>1 &lt;= bob &lt; n</code></li>
+	<li><code>amount.length == n</code></li>
+	<li><code>amount[i]</code> is an <strong>even</strong> integer in the range <code>[-10<sup>4</sup>, 10<sup>4</sup>]</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/258-add-digits/258-add-digits.java b/leetcode/leetcode/258-add-digits/258-add-digits.java
new file mode 100644
index 0000000..7e09845
--- /dev/null
+++ b/leetcode/leetcode/258-add-digits/258-add-digits.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int addDigits(int num) {
+        int sum = 0;
+        while(num!=0){
+            sum += num%10;
+            num = num/10;
+        }
+        if(sum>=10) sum = addDigits(sum);
+        return sum;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/258-add-digits/README.md b/leetcode/leetcode/258-add-digits/README.md
new file mode 100644
index 0000000..4aba281
--- /dev/null
+++ b/leetcode/leetcode/258-add-digits/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/add-digits/">258. Add Digits</a></h2><h3>Easy</h3><hr><div><p>Given an integer <code>num</code>, repeatedly add all its digits until the result has only one digit, and return it.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 38
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The process is
+38 --&gt; 3 + 8 --&gt; 11
+11 --&gt; 1 + 1 --&gt; 2 
+Since 2 has only one digit, return it.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = 0
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= num &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you do it without any loop/recursion in <code>O(1)</code> runtime?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2582-pass-the-pillow/2582-pass-the-pillow.java b/leetcode/leetcode/2582-pass-the-pillow/2582-pass-the-pillow.java
new file mode 100644
index 0000000..e6bf326
--- /dev/null
+++ b/leetcode/leetcode/2582-pass-the-pillow/2582-pass-the-pillow.java
@@ -0,0 +1,8 @@
+class Solution {
+    public int passThePillow(int n, int time) {
+        int val = time/(n-1);
+        int val2 = time%(n-1);
+        if(val%2!=0) return n-val2;
+        return val2+1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2582-pass-the-pillow/NOTES.md b/leetcode/leetcode/2582-pass-the-pillow/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2582-pass-the-pillow/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2582-pass-the-pillow/README.md b/leetcode/leetcode/2582-pass-the-pillow/README.md
new file mode 100644
index 0000000..fcea941
--- /dev/null
+++ b/leetcode/leetcode/2582-pass-the-pillow/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/pass-the-pillow/">2582. Pass the Pillow</a></h2><h3>Easy</h3><hr><div><p>There are <code>n</code> people standing in a line labeled from <code>1</code> to <code>n</code>. The first person in the line is holding a pillow initially. Every second, the person holding the pillow passes it to the next person standing in the line. Once the pillow reaches the end of the line, the direction changes, and people continue passing the pillow in the opposite direction.</p>
+
+<ul>
+	<li>For example, once the pillow reaches the <code>n<sup>th</sup></code> person they pass it to the <code>n - 1<sup>th</sup></code> person, then to the <code>n - 2<sup>th</sup></code> person and so on.</li>
+</ul>
+
+<p>Given the two positive integers <code>n</code> and <code>time</code>, return <em>the index of the person holding the pillow after </em><code>time</code><em> seconds</em>.</p>
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 4, time = 5
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> People pass the pillow in the following way: 1 -&gt; 2 -&gt; 3 -&gt; 4 -&gt; 3 -&gt; 2.
+After five seconds, the 2<sup>nd</sup> person is holding the pillow.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 3, time = 2
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> People pass the pillow in the following way: 1 -&gt; 2 -&gt; 3.
+After two seconds, the 3<sup>r</sup><sup>d</sup> person is holding the pillow.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 1000</code></li>
+	<li><code>1 &lt;= time &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2588-maximum-number-of-points-from-grid-queries/2588-maximum-number-of-points-from-grid-queries.java b/leetcode/leetcode/2588-maximum-number-of-points-from-grid-queries/2588-maximum-number-of-points-from-grid-queries.java
new file mode 100644
index 0000000..da64d57
--- /dev/null
+++ b/leetcode/leetcode/2588-maximum-number-of-points-from-grid-queries/2588-maximum-number-of-points-from-grid-queries.java
@@ -0,0 +1,126 @@
+class Solution {
+
+    // Represents a cell in the grid with row index, column index, and value
+    record Cell(int row, int col, int value) {}
+
+    // Represents a query with its original index and value
+    record Query(int index, int value) {}
+
+    // Right, Left, Down, Up
+    private static final int[] ROW_DIRECTIONS = { 0, 0, 1, -1 };
+    // Corresponding column moves
+    private static final int[] COL_DIRECTIONS = { 1, -1, 0, 0 };
+
+    public int[] maxPoints(int[][] grid, int[] queries) {
+        int rowCount = grid.length, colCount = grid[0].length;
+        int totalCells = rowCount * colCount;
+
+        // Store queries with their original indices to maintain result order
+        Query[] sortedQueries = new Query[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            sortedQueries[i] = new Query(i, queries[i]);
+        }
+        // Sort queries in ascending order
+        Arrays.sort(sortedQueries, (a, b) -> Integer.compare(a.value, b.value));
+
+        // Store all grid cells and sort them by value
+        Cell[] sortedCells = new Cell[totalCells];
+        for (int row = 0; row < rowCount; row++) {
+            for (int col = 0; col < colCount; col++) {
+                sortedCells[row * colCount + col] = new Cell(
+                    row,
+                    col,
+                    grid[row][col]
+                );
+            }
+        }
+        // Sort cells by value
+        Arrays.sort(sortedCells, (a, b) -> Integer.compare(a.value, b.value));
+
+        // Union-Find to track connected components
+        UnionFind uf = new UnionFind(totalCells);
+        int[] result = new int[queries.length];
+        int cellIndex = 0;
+
+        // Process queries in sorted order
+        for (Query query : sortedQueries) {
+            // Process cells whose values are smaller than the current query value
+            while (
+                cellIndex < totalCells &&
+                sortedCells[cellIndex].value < query.value
+            ) {
+                int row = sortedCells[cellIndex].row;
+                int col = sortedCells[cellIndex].col;
+                // Convert 2D position to 1D index
+                int cellId = row * colCount + col;
+
+                // Merge the current cell with its adjacent cells that have already been
+                // processed
+                for (int direction = 0; direction < 4; direction++) {
+                    int newRow = row + ROW_DIRECTIONS[direction];
+                    int newCol = col + COL_DIRECTIONS[direction];
+
+                    // Check if the new cell is within bounds and its value is smaller than the
+                    // query value
+                    if (
+                        newRow >= 0 &&
+                        newRow < rowCount &&
+                        newCol >= 0 &&
+                        newCol < colCount &&
+                        grid[newRow][newCol] < query.value
+                    ) {
+                        uf.union(cellId, newRow * colCount + newCol);
+                    }
+                }
+                cellIndex++;
+            }
+            // Get the size of the connected component containing the top-left cell (0,0)
+            result[query.index] = query.value > grid[0][0] ? uf.getSize(0) : 0;
+        }
+        return result;
+    }
+}
+
+class UnionFind {
+
+    private final int[] parent;
+    private final int[] size;
+
+    public UnionFind(int n) {
+        parent = new int[n];
+        size = new int[n];
+        // Initialize all parents to -1 (disjoint sets)
+        Arrays.fill(parent, -1);
+        // Each component starts with size 1
+        Arrays.fill(size, 1);
+    }
+
+    // Find with path compression
+    public int find(int node) {
+        // If negative, it's the root
+        if (parent[node] < 0) return node;
+        // Path compression
+        return parent[node] = find(parent[node]);
+    }
+
+    // Union by size (merge smaller tree into larger tree)
+    public boolean union(int nodeA, int nodeB) {
+        int rootA = find(nodeA), rootB = find(nodeB);
+        // Already connected
+        if (rootA == rootB) return false;
+
+        if (size[rootA] > size[rootB]) {
+            parent[rootB] = rootA;
+            size[rootA] += size[rootB];
+        } else {
+            parent[rootA] = rootB;
+            size[rootB] += size[rootA];
+        }
+        return true;
+    }
+
+    // Get the size of the component containing a given node
+    public int getSize(int node) {
+        return size[find(node)];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2588-maximum-number-of-points-from-grid-queries/README.md b/leetcode/leetcode/2588-maximum-number-of-points-from-grid-queries/README.md
new file mode 100644
index 0000000..9630fb6
--- /dev/null
+++ b/leetcode/leetcode/2588-maximum-number-of-points-from-grid-queries/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/maximum-number-of-points-from-grid-queries/description/?envType=daily-question&envId=2025-03-28">2588. Maximum Number of Points From Grid Queries</a></h2><h3>Hard</h3><hr><p>You are given an <code>m x n</code> integer matrix <code>grid</code> and an array <code>queries</code> of size <code>k</code>.</p>
+
+<p>Find an array <code>answer</code> of size <code>k</code> such that for each integer <code>queries[i]</code> you start in the <strong>top left</strong> cell of the matrix and repeat the following process:</p>
+
+<ul>
+	<li>If <code>queries[i]</code> is <strong>strictly</strong> greater than the value of the current cell that you are in, then you get one point if it is your first time visiting this cell, and you can move to any <strong>adjacent</strong> cell in all <code>4</code> directions: up, down, left, and right.</li>
+	<li>Otherwise, you do not get any points, and you end this process.</li>
+</ul>
+
+<p>After the process, <code>answer[i]</code> is the <strong>maximum</strong> number of points you can get. <strong>Note</strong> that for each query you are allowed to visit the same cell <strong>multiple</strong> times.</p>
+
+<p>Return <em>the resulting array</em> <code>answer</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2025/03/15/image1.png" style="width: 571px; height: 152px;" />
+<pre>
+<strong>Input:</strong> grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2]
+<strong>Output:</strong> [5,8,1]
+<strong>Explanation:</strong> The diagrams above show which cells we visit to get points for each query.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/10/20/yetgriddrawio-2.png" />
+<pre>
+<strong>Input:</strong> grid = [[5,2,1],[1,1,2]], queries = [3]
+<strong>Output:</strong> [0]
+<strong>Explanation:</strong> We can not get any points because the value of the top left cell is already greater than or equal to 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>2 &lt;= m, n &lt;= 1000</code></li>
+	<li><code>4 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
+	<li><code>k == queries.length</code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= grid[i][j], queries[i] &lt;= 10<sup>6</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/2610-closest-prime-numbers-in-range/2610-closest-prime-numbers-in-range.java b/leetcode/leetcode/2610-closest-prime-numbers-in-range/2610-closest-prime-numbers-in-range.java
new file mode 100644
index 0000000..00dda8c
--- /dev/null
+++ b/leetcode/leetcode/2610-closest-prime-numbers-in-range/2610-closest-prime-numbers-in-range.java
@@ -0,0 +1,40 @@
+class Solution {
+
+    public int[] closestPrimes(int left, int right) {
+        int prevPrime = -1, closestA = -1, closestB = -1;
+        int minDifference = (int) 1e6;
+        // Find all prime numbers in the given range
+        for (int candidate = left; candidate <= right; candidate++) {
+            if (isPrime(candidate)) {
+                if (prevPrime != -1) {
+                    int difference = candidate - prevPrime;
+                    if (difference < minDifference) {
+                        minDifference = difference;
+                        closestA = prevPrime;
+                        closestB = candidate;
+                    }
+                    // Twin prime optimization
+                    if (difference == 2 || difference == 1) return new int[] {
+                        prevPrime,
+                        candidate,
+                    };
+                }
+                prevPrime = candidate;
+            }
+        }
+
+        return (closestA == -1)
+            ? new int[] { -1, -1 }
+            : new int[] { closestA, closestB };
+    }
+
+    private boolean isPrime(int number) {
+        if (number < 2) return false;
+        if (number == 2 || number == 3) return true;
+        if (number % 2 == 0) return false;
+        for (int divisor = 3; divisor * divisor <= number; divisor += 2) {
+            if (number % divisor == 0) return false;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2610-closest-prime-numbers-in-range/README.md b/leetcode/leetcode/2610-closest-prime-numbers-in-range/README.md
new file mode 100644
index 0000000..bbd585a
--- /dev/null
+++ b/leetcode/leetcode/2610-closest-prime-numbers-in-range/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/closest-prime-numbers-in-range">2610. Closest Prime Numbers in Range</a></h2><h3>Medium</h3><hr><p>Given two positive integers <code>left</code> and <code>right</code>, find the two integers <code>num1</code> and <code>num2</code> such that:</p>
+
+<ul>
+	<li><code>left &lt;= num1 &lt; num2 &lt;= right </code>.</li>
+	<li>Both <code>num1</code> and <code>num2</code> are <span data-keyword="prime-number">prime numbers</span>.</li>
+	<li><code>num2 - num1</code> is the <strong>minimum</strong> amongst all other pairs satisfying the above conditions.</li>
+</ul>
+
+<p>Return the positive integer array <code>ans = [num1, num2]</code>. If there are multiple pairs satisfying these conditions, return the one with the <strong>smallest</strong> <code>num1</code> value. If no such numbers exist, return <code>[-1, -1]</code><em>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> left = 10, right = 19
+<strong>Output:</strong> [11,13]
+<strong>Explanation:</strong> The prime numbers between 10 and 19 are 11, 13, 17, and 19.
+The closest gap between any pair is 2, which can be achieved by [11,13] or [17,19].
+Since 11 is smaller than 17, we return the first pair.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> left = 4, right = 6
+<strong>Output:</strong> [-1,-1]
+<strong>Explanation:</strong> There exists only one prime number in the given range, so the conditions cannot be satisfied.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= left &lt;= right &lt;= 10<sup>6</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<style type="text/css">.spoilerbutton {display:block; border:dashed; padding: 0px 0px; margin:10px 0px; font-size:150%; font-weight: bold; color:#000000; background-color:cyan; outline:0; 
+}
+.spoiler {overflow:hidden;}
+.spoiler > div {-webkit-transition: all 0s ease;-moz-transition: margin 0s ease;-o-transition: all 0s ease;transition: margin 0s ease;}
+.spoilerbutton[value="Show Message"] + .spoiler > div {margin-top:-500%;}
+.spoilerbutton[value="Hide Message"] + .spoiler {padding:5px;}
+</style>
diff --git a/leetcode/leetcode/2614-maximum-count-of-positive-integer-and-negative-integer/2614-maximum-count-of-positive-integer-and-negative-integer.java b/leetcode/leetcode/2614-maximum-count-of-positive-integer-and-negative-integer/2614-maximum-count-of-positive-integer-and-negative-integer.java
new file mode 100644
index 0000000..8810444
--- /dev/null
+++ b/leetcode/leetcode/2614-maximum-count-of-positive-integer-and-negative-integer/2614-maximum-count-of-positive-integer-and-negative-integer.java
@@ -0,0 +1,40 @@
+class Solution {
+    public int lowerBound(int[] arr){
+        int low = 0;
+        int high = arr.length - 1;
+        int index = arr.length;
+        while(low<=high){
+            int mid = low+(high-low)/2;
+            if(arr[mid]<0){
+                low = mid+1;
+            }else{
+                index = mid;
+                high = mid-1;
+            }
+        }
+        return index;
+    }
+    public int upperBound(int[] arr){
+        int low = 0;
+        int high = arr.length - 1;
+        int index = arr.length;
+        while(low<=high){
+            int mid = low+(high-low)/2;
+            if(arr[mid]<=0){
+                low = mid+1;
+            }else{
+                index = mid;
+                high = mid-1;
+            }
+        }
+        return index;
+    }
+    public int maximumCount(int[] nums) {
+        int positiveCount = nums.length - upperBound(nums);
+        // All integers from the index 0 to index before the first zero index
+        // will be negative.
+        int negativeCount = lowerBound(nums);
+
+        return Math.max(positiveCount, negativeCount);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2614-maximum-count-of-positive-integer-and-negative-integer/README.md b/leetcode/leetcode/2614-maximum-count-of-positive-integer-and-negative-integer/README.md
new file mode 100644
index 0000000..58eaeae
--- /dev/null
+++ b/leetcode/leetcode/2614-maximum-count-of-positive-integer-and-negative-integer/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/maximum-count-of-positive-integer-and-negative-integer">2614. Maximum Count of Positive Integer and Negative Integer</a></h2><h3>Easy</h3><hr><p>Given an array <code>nums</code> sorted in <strong>non-decreasing</strong> order, return <em>the maximum between the number of positive integers and the number of negative integers.</em></p>
+
+<ul>
+	<li>In other words, if the number of positive integers in <code>nums</code> is <code>pos</code> and the number of negative integers is <code>neg</code>, then return the maximum of <code>pos</code> and <code>neg</code>.</li>
+</ul>
+
+<p><strong>Note</strong> that <code>0</code> is neither positive nor negative.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [-2,-1,-1,1,2,3]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> There are 3 positive integers and 3 negative integers. The maximum count among them is 3.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [-3,-2,-1,0,0,1,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> There are 2 positive integers and 3 negative integers. The maximum count among them is 3.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [5,20,66,1314]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> There are 4 positive integers and 0 negative integers. The maximum count among them is 4.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2000</code></li>
+	<li><code>-2000 &lt;= nums[i] &lt;= 2000</code></li>
+	<li><code>nums</code> is sorted in a <strong>non-decreasing order</strong>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Can you solve the problem in <code>O(log(n))</code> time complexity?</p>
diff --git a/leetcode/leetcode/263-ugly-number/263-ugly-number.java b/leetcode/leetcode/263-ugly-number/263-ugly-number.java
new file mode 100644
index 0000000..91e46b4
--- /dev/null
+++ b/leetcode/leetcode/263-ugly-number/263-ugly-number.java
@@ -0,0 +1,9 @@
+class Solution {
+    public boolean isUgly(int n) {
+        if(n<=0) return false;
+        while(n%5 == 0) n = n/5;
+        while(n%3 == 0) n = n/3;
+        while(n%2 == 0) n = n/2;
+        return n == 1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/263-ugly-number/NOTES.md b/leetcode/leetcode/263-ugly-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/263-ugly-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/263-ugly-number/README.md b/leetcode/leetcode/263-ugly-number/README.md
new file mode 100644
index 0000000..3c0f8fa
--- /dev/null
+++ b/leetcode/leetcode/263-ugly-number/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/ugly-number/">263. Ugly Number</a></h2><h3>Easy</h3><hr><div><p>An <strong>ugly number</strong> is a positive integer whose prime factors are limited to <code>2</code>, <code>3</code>, and <code>5</code>.</p>
+
+<p>Given an integer <code>n</code>, return <code>true</code> <em>if</em> <code>n</code> <em>is an <strong>ugly number</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 6
+<strong>Output:</strong> true
+<strong>Explanation:</strong> 6 = 2 × 3
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> true
+<strong>Explanation:</strong> 1 has no prime factors, therefore all of its prime factors are limited to 2, 3, and 5.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 14
+<strong>Output:</strong> false
+<strong>Explanation:</strong> 14 is not ugly since it includes the prime factor 7.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2649-count-total-number-of-colored-cells/2649-count-total-number-of-colored-cells.java b/leetcode/leetcode/2649-count-total-number-of-colored-cells/2649-count-total-number-of-colored-cells.java
new file mode 100644
index 0000000..4ea975d
--- /dev/null
+++ b/leetcode/leetcode/2649-count-total-number-of-colored-cells/2649-count-total-number-of-colored-cells.java
@@ -0,0 +1,19 @@
+class Solution {
+    public long coloredCells(int n) {
+
+        // Approach 2: 1 + (4×1) + (4×2) +...+ (4×(n−1)) = 1 + 2 × (n−1) × n
+        return 1 + (long) n * (n - 1) * 2;
+
+
+
+
+        // // Approach 1:  1, 1+4, 1+4+8, 1+4+8+12 ...
+        // long ans = 1;
+        // long last = 4;
+        // while(n--!=1){
+        //     ans +=  last;
+        //     last +=4;
+        // } 
+        // return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2649-count-total-number-of-colored-cells/README.md b/leetcode/leetcode/2649-count-total-number-of-colored-cells/README.md
new file mode 100644
index 0000000..269e253
--- /dev/null
+++ b/leetcode/leetcode/2649-count-total-number-of-colored-cells/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/count-total-number-of-colored-cells">2649. Count Total Number of Colored Cells</a></h2><h3>Medium</h3><hr><p>There exists an infinitely large two-dimensional grid of uncolored unit cells. You are given a positive integer <code>n</code>, indicating that you must do the following routine for <code>n</code> minutes:</p>
+
+<ul>
+	<li>At the first minute, color <strong>any</strong> arbitrary unit cell blue.</li>
+	<li>Every minute thereafter, color blue <strong>every</strong> uncolored cell that touches a blue cell.</li>
+</ul>
+
+<p>Below is a pictorial representation of the state of the grid after minutes 1, 2, and 3.</p>
+<img alt="" src="https://assets.leetcode.com/uploads/2023/01/10/example-copy-2.png" style="width: 500px; height: 279px;" />
+<p>Return <em>the number of <strong>colored cells</strong> at the end of </em><code>n</code> <em>minutes</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 1
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> After 1 minute, there is only 1 blue cell, so we return 1.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 2
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> After 2 minutes, there are 4 colored cells on the boundary and 1 in the center, so we return 5. 
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/2665-minimum-time-to-repair-cars/2665-minimum-time-to-repair-cars.java b/leetcode/leetcode/2665-minimum-time-to-repair-cars/2665-minimum-time-to-repair-cars.java
new file mode 100644
index 0000000..04d8ce0
--- /dev/null
+++ b/leetcode/leetcode/2665-minimum-time-to-repair-cars/2665-minimum-time-to-repair-cars.java
@@ -0,0 +1,42 @@
+class Solution {
+
+    public long repairCars(int[] ranks, int cars) {
+        int minRank = ranks[0], maxRank = ranks[0];
+
+        // Find min and max rank dynamically
+        for (int rank : ranks) {
+            minRank = Math.min(minRank, rank);
+            maxRank = Math.max(maxRank, rank);
+        }
+        // Frequency array to count mechanics with each rank
+        int[] freq = new int[maxRank + 1];
+        for (int rank : ranks) {
+            minRank = Math.min(minRank, rank);
+            freq[rank]++;
+        }
+
+        // Minimum possible time, Maximum possible time
+        long low = 1, high = 1L * minRank * cars * cars;
+
+        // Perform binary search to find the minimum time required
+        while (low < high) {
+            long mid = (low + high) / 2;
+            long carsRepaired = 0;
+
+            // Calculate the total number of cars that can be repaired in 'mid' time
+            for (int rank = 1; rank <= maxRank; rank++) {
+                carsRepaired +=
+                    freq[rank] * (long) Math.sqrt(mid / (long) rank);
+            }
+
+            // Adjust the search boundaries based on the number of cars repaired
+            if (carsRepaired >= cars) {
+                high = mid; // Try to find a smaller time
+            } else {
+                low = mid + 1; // Need more time
+            }
+        }
+
+        return low;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2665-minimum-time-to-repair-cars/README.md b/leetcode/leetcode/2665-minimum-time-to-repair-cars/README.md
new file mode 100644
index 0000000..35ff34a
--- /dev/null
+++ b/leetcode/leetcode/2665-minimum-time-to-repair-cars/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/minimum-time-to-repair-cars">2665. Minimum Time to Repair Cars</a></h2><h3>Medium</h3><hr><p>You are given an integer array <code>ranks</code> representing the <strong>ranks</strong> of some mechanics. <font face="monospace">ranks<sub>i</sub></font> is the rank of the <font face="monospace">i<sup>th</sup></font> mechanic<font face="monospace">.</font> A mechanic with a rank <code>r</code> can repair <font face="monospace">n</font> cars in <code>r * n<sup>2</sup></code> minutes.</p>
+
+<p>You are also given an integer <code>cars</code> representing the total number of cars waiting in the garage to be repaired.</p>
+
+<p>Return <em>the <strong>minimum</strong> time taken to repair all the cars.</em></p>
+
+<p><strong>Note:</strong> All the mechanics can repair the cars simultaneously.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> ranks = [4,2,3,1], cars = 10
+<strong>Output:</strong> 16
+<strong>Explanation:</strong> 
+- The first mechanic will repair two cars. The time required is 4 * 2 * 2 = 16 minutes.
+- The second mechanic will repair two cars. The time required is 2 * 2 * 2 = 8 minutes.
+- The third mechanic will repair two cars. The time required is 3 * 2 * 2 = 12 minutes.
+- The fourth mechanic will repair four cars. The time required is 1 * 4 * 4 = 16 minutes.
+It can be proved that the cars cannot be repaired in less than 16 minutes.​​​​​
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> ranks = [5,1,8], cars = 6
+<strong>Output:</strong> 16
+<strong>Explanation:</strong> 
+- The first mechanic will repair one car. The time required is 5 * 1 * 1 = 5 minutes.
+- The second mechanic will repair four cars. The time required is 1 * 4 * 4 = 16 minutes.
+- The third mechanic will repair one car. The time required is 8 * 1 * 1 = 8 minutes.
+It can be proved that the cars cannot be repaired in less than 16 minutes.​​​​​
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= ranks.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= ranks[i] &lt;= 100</code></li>
+	<li><code>1 &lt;= cars &lt;= 10<sup>6</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/2681-put-marbles-in-bags/2681-put-marbles-in-bags.java b/leetcode/leetcode/2681-put-marbles-in-bags/2681-put-marbles-in-bags.java
new file mode 100644
index 0000000..8485e8a
--- /dev/null
+++ b/leetcode/leetcode/2681-put-marbles-in-bags/2681-put-marbles-in-bags.java
@@ -0,0 +1,16 @@
+class Solution {
+    public long putMarbles(int[] weights, int k) {
+        ArrayList<Integer> pairs = new ArrayList<>();
+        for(int i =1;i<weights.length;i++){
+            pairs.add(weights[i]+weights[i-1]);
+        }
+        Collections.sort(pairs);
+        long maxPairs = 0;
+        long minPairs = 0;
+        for(int i = 0;i<k-1;i++){
+            minPairs+=pairs.get(i);
+            maxPairs+=pairs.get(pairs.size() - 1 - i);
+        }
+        return maxPairs - minPairs;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2681-put-marbles-in-bags/README.md b/leetcode/leetcode/2681-put-marbles-in-bags/README.md
new file mode 100644
index 0000000..078e38b
--- /dev/null
+++ b/leetcode/leetcode/2681-put-marbles-in-bags/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/put-marbles-in-bags">2681. Put Marbles in Bags</a></h2><h3>Hard</h3><hr><p>You have <code>k</code> bags. You are given a <strong>0-indexed</strong> integer array <code>weights</code> where <code>weights[i]</code> is the weight of the <code>i<sup>th</sup></code> marble. You are also given the integer <code>k.</code></p>
+
+<p>Divide the marbles into the <code>k</code> bags according to the following rules:</p>
+
+<ul>
+	<li>No bag is empty.</li>
+	<li>If the <code>i<sup>th</sup></code> marble and <code>j<sup>th</sup></code> marble are in a bag, then all marbles with an index between the <code>i<sup>th</sup></code> and <code>j<sup>th</sup></code> indices should also be in that same bag.</li>
+	<li>If a bag consists of all the marbles with an index from <code>i</code> to <code>j</code> inclusively, then the cost of the bag is <code>weights[i] + weights[j]</code>.</li>
+</ul>
+
+<p>The <strong>score</strong> after distributing the marbles is the sum of the costs of all the <code>k</code> bags.</p>
+
+<p>Return <em>the <strong>difference</strong> between the <strong>maximum</strong> and <strong>minimum</strong> scores among marble distributions</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> weights = [1,3,5,1], k = 2
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> 
+The distribution [1],[3,5,1] results in the minimal score of (1+1) + (3+1) = 6. 
+The distribution [1,3],[5,1], results in the maximal score of (1+3) + (5+1) = 10. 
+Thus, we return their difference 10 - 6 = 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> weights = [1, 3], k = 2
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The only distribution possible is [1],[3]. 
+Since both the maximal and minimal score are the same, we return 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= weights.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= weights[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/2690-house-robber-iv/2690-house-robber-iv.java b/leetcode/leetcode/2690-house-robber-iv/2690-house-robber-iv.java
new file mode 100644
index 0000000..0ee5d03
--- /dev/null
+++ b/leetcode/leetcode/2690-house-robber-iv/2690-house-robber-iv.java
@@ -0,0 +1,28 @@
+class Solution {
+
+    public int minCapability(int[] nums, int k) {
+        // Store the maximum nums value in maxReward.
+        int minReward = 1;
+        int maxReward = Arrays.stream(nums).max().getAsInt();
+        int totalHouses = nums.length;
+
+        // Use binary search to find the minimum reward possible.
+        while (minReward < maxReward) {
+            int midReward = (minReward + maxReward) / 2;
+            int possibleThefts = 0;
+
+            for (int index = 0; index < totalHouses; ++index) {
+                if (nums[index] <= midReward) {
+                    possibleThefts += 1;
+                    index++; // Skip the next house to maintain the
+                    // non-adjacent condition
+                }
+            }
+
+            if (possibleThefts >= k) maxReward = midReward;
+            else minReward = midReward + 1;
+        }
+
+        return minReward;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2690-house-robber-iv/README.md b/leetcode/leetcode/2690-house-robber-iv/README.md
new file mode 100644
index 0000000..b0f5ad1
--- /dev/null
+++ b/leetcode/leetcode/2690-house-robber-iv/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/house-robber-iv">2690. House Robber IV</a></h2><h3>Medium</h3><hr><p>There are several consecutive houses along a street, each of which has some money inside. There is also a robber, who wants to steal money from the homes, but he <strong>refuses to steal from adjacent homes</strong>.</p>
+
+<p>The <strong>capability</strong> of the robber is the maximum amount of money he steals from one house of all the houses he robbed.</p>
+
+<p>You are given an integer array <code>nums</code> representing how much money is stashed in each house. More formally, the <code>i<sup>th</sup></code> house from the left has <code>nums[i]</code> dollars.</p>
+
+<p>You are also given an integer <code>k</code>, representing the <strong>minimum</strong> number of houses the robber will steal from. It is always possible to steal at least <code>k</code> houses.</p>
+
+<p>Return <em>the <strong>minimum</strong> capability of the robber out of all the possible ways to steal at least </em><code>k</code><em> houses</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,3,5,9], k = 2
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> 
+There are three ways to rob at least 2 houses:
+- Rob the houses at indices 0 and 2. Capability is max(nums[0], nums[2]) = 5.
+- Rob the houses at indices 0 and 3. Capability is max(nums[0], nums[3]) = 9.
+- Rob the houses at indices 1 and 3. Capability is max(nums[1], nums[3]) = 9.
+Therefore, we return min(5, 9, 9) = 5.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,7,9,3,1], k = 2
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There are 7 ways to rob the houses. The way which leads to minimum capability is to rob the house at index 0 and 4. Return max(nums[0], nums[4]) = 2.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= k &lt;= (nums.length + 1)/2</code></li>
+</ul>
diff --git a/leetcode/leetcode/2707-extra-characters-in-a-string/2707-extra-characters-in-a-string.java b/leetcode/leetcode/2707-extra-characters-in-a-string/2707-extra-characters-in-a-string.java
new file mode 100644
index 0000000..87ae39f
--- /dev/null
+++ b/leetcode/leetcode/2707-extra-characters-in-a-string/2707-extra-characters-in-a-string.java
@@ -0,0 +1,29 @@
+class Solution {
+    Integer[] memo;
+    HashSet<String> dictionarySet;
+    public int minExtraChar(String s, String[] dictionary) {
+        int n = s.length();
+        memo = new Integer[n];
+        dictionarySet = new HashSet<>(Arrays.asList(dictionary));
+        return dp(0, n, s);
+    }
+    private int dp(int start, int n, String s) {
+        if (start == n) {
+            return 0;
+        }
+        if (memo[start] != null) {
+            return memo[start];
+        }
+        // To count this character as a left over character 
+        // move to index 'start + 1'
+        int ans = dp(start + 1, n, s) + 1;
+        for (int end = start; end < n; end++) {
+            var curr = s.substring(start, end + 1);
+            if (dictionarySet.contains(curr)) {
+                ans = Math.min(ans, dp(end + 1, n, s));
+            }
+        }
+
+        return memo[start] = ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2707-extra-characters-in-a-string/README.md b/leetcode/leetcode/2707-extra-characters-in-a-string/README.md
new file mode 100644
index 0000000..1f148b7
--- /dev/null
+++ b/leetcode/leetcode/2707-extra-characters-in-a-string/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/extra-characters-in-a-string/">2707. Extra Characters in a String</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> string <code>s</code> and a dictionary of words <code>dictionary</code>. You have to break <code>s</code> into one or more <strong>non-overlapping</strong> substrings such that each substring is present in <code>dictionary</code>. There may be some <strong>extra characters</strong> in <code>s</code> which are not present in any of the substrings.</p>
+
+<p>Return <em>the <strong>minimum</strong> number of extra characters left over if you break up </em><code>s</code><em> optimally.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "leetscode", dictionary = ["leet","code","leetcode"]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> We can break s in two substrings: "leet" from index 0 to 3 and "code" from index 5 to 8. There is only 1 unused character (at index 4), so we return 1.
+
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "sayhelloworld", dictionary = ["hello","world"]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> We can break s in two substrings: "hello" from index 3 to 7 and "world" from index 8 to 12. The characters at indices 0, 1, 2 are not used in any substring and thus are considered as extra characters. Hence, we return 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 50</code></li>
+	<li><code>1 &lt;= dictionary.length &lt;= 50</code></li>
+	<li><code>1 &lt;= dictionary[i].length &lt;= 50</code></li>
+	<li><code>dictionary[i]</code>&nbsp;and <code>s</code> consists of only lowercase English letters</li>
+	<li><code>dictionary</code> contains distinct words</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2707-merge-two-2d-arrays-by-summing-values/2707-merge-two-2d-arrays-by-summing-values.java b/leetcode/leetcode/2707-merge-two-2d-arrays-by-summing-values/2707-merge-two-2d-arrays-by-summing-values.java
new file mode 100644
index 0000000..1dce1f3
--- /dev/null
+++ b/leetcode/leetcode/2707-merge-two-2d-arrays-by-summing-values/2707-merge-two-2d-arrays-by-summing-values.java
@@ -0,0 +1,43 @@
+class Solution {
+    public int[][] mergeArrays(int[][] nums1, int[][] nums2) {
+        ArrayList<int[]> result = new ArrayList<>();
+        int index1 = 0;
+        int index2 = 0;
+
+        while(index1 < nums1.length || index2 < nums2.length){
+            int[] temp = new int[2];
+            if(index1 == nums1.length){
+                
+                temp[0] = nums2[index2][0];
+                temp[1] = nums2[index2][1];
+                index2++;
+
+            }else if(index2 == nums2.length){
+                temp[0] = nums1[index1][0];
+                temp[1] = nums1[index1][1];
+                index1++;
+                
+            }else if(nums1[index1][0] == nums2[index2][0]){
+                temp[0] = nums1[index1][0];
+                temp[1] = nums1[index1][1] + nums2[index2][1];
+                index1++;
+                index2++;
+            }else if(nums1[index1][0] > nums2[index2][0]){
+                temp[0] = nums2[index2][0];
+                temp[1] = nums2[index2][1];
+                index2++;
+            }else{
+                temp[0] = nums1[index1][0];
+                temp[1] = nums1[index1][1];
+                index1++;
+            }
+            result.add(temp);
+        }
+        int[][] ans = new int[result.size()][2];
+        for(int i = 0;i<ans.length;i++){
+            ans[i][0] = result.get(i)[0];
+            ans[i][1] = result.get(i)[1];
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2707-merge-two-2d-arrays-by-summing-values/README.md b/leetcode/leetcode/2707-merge-two-2d-arrays-by-summing-values/README.md
new file mode 100644
index 0000000..126f179
--- /dev/null
+++ b/leetcode/leetcode/2707-merge-two-2d-arrays-by-summing-values/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/merge-two-2d-arrays-by-summing-values">2707. Merge Two 2D Arrays by Summing Values</a></h2><h3>Easy</h3><hr><p>You are given two <strong>2D</strong> integer arrays <code>nums1</code> and <code>nums2.</code></p>
+
+<ul>
+	<li><code>nums1[i] = [id<sub>i</sub>, val<sub>i</sub>]</code>&nbsp;indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.</li>
+	<li><code>nums2[i] = [id<sub>i</sub>, val<sub>i</sub>]</code>&nbsp;indicate that the number with the id <code>id<sub>i</sub></code> has a value equal to <code>val<sub>i</sub></code>.</li>
+</ul>
+
+<p>Each array contains <strong>unique</strong> ids and is sorted in <strong>ascending</strong> order by id.</p>
+
+<p>Merge the two arrays into one array that is sorted in ascending order by id, respecting the following conditions:</p>
+
+<ul>
+	<li>Only ids that appear in at least one of the two arrays should be included in the resulting array.</li>
+	<li>Each id should be included <strong>only once</strong> and its value should be the sum of the values of this id in the two arrays. If the id does not exist in one of the two arrays, then assume its value in that array to be <code>0</code>.</li>
+</ul>
+
+<p>Return <em>the resulting array</em>. The returned array must be sorted in ascending order by id.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [[1,2],[2,3],[4,5]], nums2 = [[1,4],[3,2],[4,1]]
+<strong>Output:</strong> [[1,6],[2,3],[3,2],[4,6]]
+<strong>Explanation:</strong> The resulting array contains the following:
+- id = 1, the value of this id is 2 + 4 = 6.
+- id = 2, the value of this id is 3.
+- id = 3, the value of this id is 2.
+- id = 4, the value of this id is 5 + 1 = 6.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [[2,4],[3,6],[5,5]], nums2 = [[1,3],[4,3]]
+<strong>Output:</strong> [[1,3],[2,4],[3,6],[4,3],[5,5]]
+<strong>Explanation:</strong> There are no common ids, so we just include each id with its value in the resulting list.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums1.length, nums2.length &lt;= 200</code></li>
+	<li><code>nums1[i].length == nums2[j].length == 2</code></li>
+	<li><code>1 &lt;= id<sub>i</sub>, val<sub>i</sub> &lt;= 1000</code></li>
+	<li>Both arrays contain unique ids.</li>
+	<li>Both arrays are in&nbsp;strictly ascending order by id.</li>
+</ul>
diff --git a/leetcode/leetcode/2751-robot-collisions/2751-robot-collisions.java b/leetcode/leetcode/2751-robot-collisions/2751-robot-collisions.java
new file mode 100644
index 0000000..6dabe24
--- /dev/null
+++ b/leetcode/leetcode/2751-robot-collisions/2751-robot-collisions.java
@@ -0,0 +1,55 @@
+class Solution {
+    public class Robot implements Comparable<Robot>{
+        int position;
+        int health;
+        char direction;
+        int index;
+        public Robot(int p, int h, char d, int realIndex){
+            position = p;
+            health = h;
+            direction = d;
+            index = realIndex;
+        }
+        @Override
+        public int compareTo(Robot r){
+            return this.position - r.position ;
+        }
+    }
+    public List<Integer> survivedRobotsHealths(int[] positions, int[] healths, String directions) {
+        List<Integer> list = new ArrayList<>();
+        for(int i =0;i<positions.length;i++){
+            list.add(-1);
+        }
+        Robot[] r = new Robot[positions.length];
+        for(int i = 0;i<positions.length;i++){
+            r[i] = new Robot(positions[i],healths[i],directions.charAt(i),i);
+        }
+        Arrays.sort(r);
+        Stack<Robot> answer = new Stack<>();
+        int index = 0;
+        while(index<r.length){
+            if(answer.isEmpty()){ answer.push(r[index++]); continue;}
+            if(answer.peek().direction =='R' && r[index].direction=='L'){
+                if(answer.peek().health>r[index].health){
+                    answer.peek().health-=1;
+                    index++;
+                }else if(answer.peek().health==r[index].health){
+                    answer.pop();
+                    index++;
+                }else{
+                    answer.pop();
+                    r[index].health-=1;
+                }
+            }else{
+                answer.push(r[index++]);
+            }            
+        }
+        while(!answer.isEmpty()){
+            list.set(answer.peek().index,answer.pop().health);
+        }
+        list.removeIf(element -> element == -1);
+        // list.add(r[0].position);
+        return list;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2751-robot-collisions/NOTES.md b/leetcode/leetcode/2751-robot-collisions/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2751-robot-collisions/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/279-perfect-squares/279-perfect-squares.java b/leetcode/leetcode/279-perfect-squares/279-perfect-squares.java
new file mode 100644
index 0000000..67a9e99
--- /dev/null
+++ b/leetcode/leetcode/279-perfect-squares/279-perfect-squares.java
@@ -0,0 +1,34 @@
+class Solution {
+    // Memoization
+    private int helper(int n, int[] dp){
+        if(n<2) return n;
+        int ans = n;
+        for(int i = 1;i*i<=n;i++){
+            if(dp[n - i*i] !=-1){
+                ans = Math.min(ans,dp[n - i*i]);
+            }else{
+                ans = Math.min(ans,helper(n - i*i,dp));
+            }
+        }
+        dp[n] = ans+1;
+        return dp[n];
+    }
+    // Dynamic Programming
+    private int helper(int n){
+        int[] dp = new int[n+1];
+        for(int i = 0;i<=n;i++) dp[i] = -1;
+        dp[0] = 0;
+        dp[1] = 1;
+        for(int i = 1;i<=n;i++){
+            int ans = i;
+            for(int j = 1;j*j<=i;j++){
+                ans = Math.min(ans,dp[i - j*j] +1);
+            }
+            dp[i] = ans;
+        }
+        return dp[n];
+    }
+    public int numSquares(int n) {
+        return helper(n);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/279-perfect-squares/NOTES.md b/leetcode/leetcode/279-perfect-squares/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/279-perfect-squares/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2793-count-the-number-of-complete-components/2793-count-the-number-of-complete-components.java b/leetcode/leetcode/2793-count-the-number-of-complete-components/2793-count-the-number-of-complete-components.java
new file mode 100644
index 0000000..cb71bf4
--- /dev/null
+++ b/leetcode/leetcode/2793-count-the-number-of-complete-components/2793-count-the-number-of-complete-components.java
@@ -0,0 +1,53 @@
+class Solution {
+    public int countCompleteComponents(int n, int[][] edges) {
+        boolean[] visited = new boolean[n];
+        HashMap<Integer, List<Integer>> graph = new HashMap<>();
+        for(int i = 0;i<edges.length;i++){
+            if(!graph.containsKey(edges[i][0])){
+                List<Integer> list = new ArrayList<>();
+                graph.put(edges[i][0], list);
+            }
+            if(!graph.containsKey(edges[i][1])){
+                List<Integer> list = new ArrayList<>();
+                graph.put(edges[i][1], list);
+            }
+            graph.get(edges[i][0]).add(edges[i][1]);
+            graph.get(edges[i][1]).add(edges[i][0]);
+        }
+        int ans = 0;
+        for(int i = 0;i<n;i++){
+            if(!graph.containsKey(i)){
+                List<Integer> list = new ArrayList<>();
+                graph.put(i,list);
+            }
+        }
+        Queue<Integer> q = new LinkedList<>();
+        for(int i = 0;i<n;i++){
+            if(!visited[i]){
+                int nodes = 1;
+                int edge = 0;
+                q.add(i);
+                visited[i] = true;
+                while(!q.isEmpty()){
+                    List<Integer> list = graph.get(q.remove());
+                    
+                    for(int j = 0;j<list.size();j++){
+                        edge++;
+                        if(!visited[list.get(j)]){
+                            nodes++;
+                            visited[list.get(j)] = true;
+                            q.add(list.get(j));
+                            
+                        }
+                    }
+                }
+                edge = edge/2;
+                System.out.println("Edges: "+ edge+" Nodes: "+ nodes);
+                if(edge == (nodes*(nodes-1))/2) ans++;
+            }
+        } 
+        return ans;
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2793-count-the-number-of-complete-components/README.md b/leetcode/leetcode/2793-count-the-number-of-complete-components/README.md
new file mode 100644
index 0000000..c90c5ad
--- /dev/null
+++ b/leetcode/leetcode/2793-count-the-number-of-complete-components/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/count-the-number-of-complete-components">2793. Count the Number of Complete Components</a></h2><h3>Medium</h3><hr><p>You are given an integer <code>n</code>. There is an <strong>undirected</strong> graph with <code>n</code> vertices, numbered from <code>0</code> to <code>n - 1</code>. You are given a 2D integer array <code>edges</code> where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> denotes that there exists an <strong>undirected</strong> edge connecting vertices <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>.</p>
+
+<p>Return <em>the number of <strong>complete connected components</strong> of the graph</em>.</p>
+
+<p>A <strong>connected component</strong> is a subgraph of a graph in which there exists a path between any two vertices, and no vertex of the subgraph shares an edge with a vertex outside of the subgraph.</p>
+
+<p>A connected component is said to be <b>complete</b> if there exists an edge between every pair of its vertices.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2023/04/11/screenshot-from-2023-04-11-23-31-23.png" style="width: 671px; height: 270px;" /></strong></p>
+
+<pre>
+<strong>Input:</strong> n = 6, edges = [[0,1],[0,2],[1,2],[3,4]]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> From the picture above, one can see that all of the components of this graph are complete.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2023/04/11/screenshot-from-2023-04-11-23-32-00.png" style="width: 671px; height: 270px;" /></strong></p>
+
+<pre>
+<strong>Input:</strong> n = 6, edges = [[0,1],[0,2],[1,2],[3,4],[3,5]]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The component containing vertices 0, 1, and 2 is complete since there is an edge between every pair of two vertices. On the other hand, the component containing vertices 3, 4, and 5 is not complete since there is no edge between vertices 4 and 5. Thus, the number of complete components in this graph is 1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 50</code></li>
+	<li><code>0 &lt;= edges.length &lt;= n * (n - 1) / 2</code></li>
+	<li><code>edges[i].length == 2</code></li>
+	<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt;= n - 1</code></li>
+	<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
+	<li>There are no repeated edges.</li>
+</ul>
diff --git a/leetcode/leetcode/2807-insert-greatest-common-divisors-in-linked-list/2807-insert-greatest-common-divisors-in-linked-list.java b/leetcode/leetcode/2807-insert-greatest-common-divisors-in-linked-list/2807-insert-greatest-common-divisors-in-linked-list.java
new file mode 100644
index 0000000..2858bf8
--- /dev/null
+++ b/leetcode/leetcode/2807-insert-greatest-common-divisors-in-linked-list/2807-insert-greatest-common-divisors-in-linked-list.java
@@ -0,0 +1,35 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public int gcd(int a, int b)
+    {
+        // if b=0, a is the GCD
+        if (b == 0)
+            return a;
+ 
+        // call the gcd() method recursively by
+        // replacing a with b and b with
+        // modulus(a,b) as long as b != 0
+        else
+            return gcd(b, a % b);
+    }
+    public ListNode insertGreatestCommonDivisors(ListNode head) {
+        if(head==null || head.next == null) return head;
+        
+        int val1 = head.val;
+        int val2 = head.next.val;
+        int gcd = gcd(val1,val2);
+        ListNode next = insertGreatestCommonDivisors(head.next);
+        head.next = new ListNode(gcd,next);
+        return head;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2807-insert-greatest-common-divisors-in-linked-list/README.md b/leetcode/leetcode/2807-insert-greatest-common-divisors-in-linked-list/README.md
new file mode 100644
index 0000000..7ff29ad
--- /dev/null
+++ b/leetcode/leetcode/2807-insert-greatest-common-divisors-in-linked-list/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/insert-greatest-common-divisors-in-linked-list/">2807. Insert Greatest Common Divisors in Linked List</a></h2><h3>Medium</h3><hr><div><p>Given the head of a linked list <code>head</code>, in which each node contains an integer value.</p>
+
+<p>Between every pair of adjacent nodes, insert a new node with a value equal to the <strong>greatest common divisor</strong> of them.</p>
+
+<p>Return <em>the linked list after insertion</em>.</p>
+
+<p>The <strong>greatest common divisor</strong> of two numbers is the largest positive integer that evenly divides both numbers.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2023/07/18/ex1_copy.png" style="width: 641px; height: 181px;">
+<pre><strong>Input:</strong> head = [18,6,10,3]
+<strong>Output:</strong> [18,6,6,2,10,1,3]
+<strong>Explanation:</strong> The 1<sup>st</sup> diagram denotes the initial linked list and the 2<sup>nd</sup> diagram denotes the linked list after inserting the new nodes (nodes in blue are the inserted nodes).
+- We insert the greatest common divisor of 18 and 6 = 6 between the 1<sup>st</sup> and the 2<sup>nd</sup> nodes.
+- We insert the greatest common divisor of 6 and 10 = 2 between the 2<sup>nd</sup> and the 3<sup>rd</sup> nodes.
+- We insert the greatest common divisor of 10 and 3 = 1 between the 3<sup>rd</sup> and the 4<sup>th</sup> nodes.
+There are no more adjacent nodes, so we return the linked list.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2023/07/18/ex2_copy1.png" style="width: 51px; height: 191px;">
+<pre><strong>Input:</strong> head = [7]
+<strong>Output:</strong> [7]
+<strong>Explanation:</strong> The 1<sup>st</sup> diagram denotes the initial linked list and the 2<sup>nd</sup> diagram denotes the linked list after inserting the new nodes.
+There are no pairs of adjacent nodes, so we return the initial linked list.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 5000]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/284-peeking-iterator/284-peeking-iterator.java b/leetcode/leetcode/284-peeking-iterator/284-peeking-iterator.java
new file mode 100644
index 0000000..c338f5a
--- /dev/null
+++ b/leetcode/leetcode/284-peeking-iterator/284-peeking-iterator.java
@@ -0,0 +1,29 @@
+// Java Iterator interface reference:
+// https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html
+
+class PeekingIterator implements Iterator<Integer> {
+    Queue<Integer> q;
+	public PeekingIterator(Iterator<Integer> iterator) {
+	    // initialize any member here.
+	    q= new LinkedList<>();
+        while(iterator.hasNext())
+          q.add(iterator.next());  
+	}
+	
+    // Returns the next element in the iteration without advancing the iterator.
+	public Integer peek() {
+        return q.peek();
+	}
+	
+	// hasNext() and next() should behave the same as in the Iterator interface.
+	// Override them if needed.
+	@Override
+	public Integer next() {
+	    return q.remove();
+	}
+	
+	@Override
+	public boolean hasNext() {
+	    return q.size()!=0;
+	}
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/284-peeking-iterator/NOTES.md b/leetcode/leetcode/284-peeking-iterator/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/284-peeking-iterator/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/284-peeking-iterator/README.md b/leetcode/leetcode/284-peeking-iterator/README.md
new file mode 100644
index 0000000..037b8fd
--- /dev/null
+++ b/leetcode/leetcode/284-peeking-iterator/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/peeking-iterator/">284. Peeking Iterator</a></h2><h3>Medium</h3><hr><div><p>Design an iterator that supports the <code>peek</code> operation on an existing iterator in addition to the <code>hasNext</code> and the <code>next</code> operations.</p>
+
+<p>Implement the <code>PeekingIterator</code> class:</p>
+
+<ul>
+	<li><code>PeekingIterator(Iterator&lt;int&gt; nums)</code> Initializes the object with the given integer iterator <code>iterator</code>.</li>
+	<li><code>int next()</code> Returns the next element in the array and moves the pointer to the next element.</li>
+	<li><code>boolean hasNext()</code> Returns <code>true</code> if there are still elements in the array.</li>
+	<li><code>int peek()</code> Returns the next element in the array <strong>without</strong> moving the pointer.</li>
+</ul>
+
+<p><strong>Note:</strong> Each language may have a different implementation of the constructor and <code>Iterator</code>, but they all support the <code>int next()</code> and <code>boolean hasNext()</code> functions.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["PeekingIterator", "next", "peek", "next", "next", "hasNext"]
+[[[1, 2, 3]], [], [], [], [], []]
+<strong>Output</strong>
+[null, 1, 2, 2, 3, false]
+
+<strong>Explanation</strong>
+PeekingIterator peekingIterator = new PeekingIterator([1, 2, 3]); // [<u><strong>1</strong></u>,2,3]
+peekingIterator.next();    // return 1, the pointer moves to the next element [1,<u><strong>2</strong></u>,3].
+peekingIterator.peek();    // return 2, the pointer does not move [1,<u><strong>2</strong></u>,3].
+peekingIterator.next();    // return 2, the pointer moves to the next element [1,2,<u><strong>3</strong></u>]
+peekingIterator.next();    // return 3, the pointer moves to the next element [1,2,3]
+peekingIterator.hasNext(); // return False
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 1000</code></li>
+	<li>All the calls to <code>next</code> and <code>peek</code> are valid.</li>
+	<li>At most <code>1000</code> calls will be made to <code>next</code>, <code>hasNext</code>, and <code>peek</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> How would you extend your design to be generic and work with all types, not just integer?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2869-minimum-operations-to-collect-elements/2869-minimum-operations-to-collect-elements.java b/leetcode/leetcode/2869-minimum-operations-to-collect-elements/2869-minimum-operations-to-collect-elements.java
new file mode 100644
index 0000000..3ab77b4
--- /dev/null
+++ b/leetcode/leetcode/2869-minimum-operations-to-collect-elements/2869-minimum-operations-to-collect-elements.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int minOperations(List<Integer> nums, int k) {
+        HashSet<Integer> set = new HashSet<>();
+        int ans = 0;
+        for(int i = nums.size()-1;i!=-1;i--){
+            if(set.size()==k) return ans; 
+            if(nums.get(i) <= k){
+                set.add(nums.get(i));
+               
+            }
+             ans++;
+        }
+        return ans; 
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2869-minimum-operations-to-collect-elements/NOTES.md b/leetcode/leetcode/2869-minimum-operations-to-collect-elements/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/2869-minimum-operations-to-collect-elements/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/2869-minimum-operations-to-collect-elements/README.md b/leetcode/leetcode/2869-minimum-operations-to-collect-elements/README.md
new file mode 100644
index 0000000..b943591
--- /dev/null
+++ b/leetcode/leetcode/2869-minimum-operations-to-collect-elements/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/minimum-operations-to-collect-elements/">2869. Minimum Operations to Collect Elements</a></h2><h3>Easy</h3><hr><div><p>You are given an array <code>nums</code> of positive integers and an integer <code>k</code>.</p>
+
+<p>In one operation, you can remove the last element of the array and add it to your collection.</p>
+
+<p>Return <em>the <strong>minimum number of operations</strong> needed to collect elements</em> <code>1, 2, ..., k</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,1,5,4,2], k = 2
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> After 4 operations, we collect elements 2, 4, 5, and 1, in this order. Our collection contains elements 1 and 2. Hence, the answer is 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,1,5,4,2], k = 5
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> After 5 operations, we collect elements 2, 4, 5, 1, and 3, in this order. Our collection contains elements 1 through 5. Hence, the answer is 5.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,2,5,3,1], k = 3
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> After 4 operations, we collect elements 1, 3, 5, and 2, in this order. Our collection contains elements 1 through 3. Hence, the answer is 4.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 50</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= nums.length</code></li>
+	<li><code>1 &lt;= k &lt;= nums.length</code></li>
+	<li>The input is generated such that you can collect elements <code>1, 2, ..., k</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/287-find-the-duplicate-number/287-find-the-duplicate-number.java b/leetcode/leetcode/287-find-the-duplicate-number/287-find-the-duplicate-number.java
new file mode 100644
index 0000000..0dfaa3d
--- /dev/null
+++ b/leetcode/leetcode/287-find-the-duplicate-number/287-find-the-duplicate-number.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int findDuplicate(int[] arr) {
+        for(int i = 0;i<arr.length;i++){
+            int index = Math.abs(arr[i]) - 1;
+            if(arr[index]<0) return index+1;
+            arr[index] = -arr[index];
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/287-find-the-duplicate-number/NOTES.md b/leetcode/leetcode/287-find-the-duplicate-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/287-find-the-duplicate-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/287-find-the-duplicate-number/README.md b/leetcode/leetcode/287-find-the-duplicate-number/README.md
new file mode 100644
index 0000000..7e26c34
--- /dev/null
+++ b/leetcode/leetcode/287-find-the-duplicate-number/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/find-the-duplicate-number/">287. Find the Duplicate Number</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>nums</code> containing&nbsp;<code>n + 1</code> integers where each integer is in the range <code>[1, n]</code> inclusive.</p>
+
+<p>There is only <strong>one repeated number</strong> in <code>nums</code>, return <em>this&nbsp;repeated&nbsp;number</em>.</p>
+
+<p>You must solve the problem <strong>without</strong> modifying the array <code>nums</code>&nbsp;and uses only constant extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3,4,2,2]
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,1,3,4,2]
+<strong>Output:</strong> 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums.length == n + 1</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= n</code></li>
+	<li>All the integers in <code>nums</code> appear only <strong>once</strong> except for <strong>precisely one integer</strong> which appears <strong>two or more</strong> times.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><b>Follow up:</b></p>
+
+<ul>
+	<li>How can we prove that at least one duplicate number must exist in <code>nums</code>?</li>
+	<li>Can you solve the problem in linear runtime complexity?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/2887-sort-vowels-in-a-string/2887-sort-vowels-in-a-string.py b/leetcode/leetcode/2887-sort-vowels-in-a-string/2887-sort-vowels-in-a-string.py
new file mode 100644
index 0000000..fc902e3
--- /dev/null
+++ b/leetcode/leetcode/2887-sort-vowels-in-a-string/2887-sort-vowels-in-a-string.py
@@ -0,0 +1,15 @@
+class Solution:
+    def sortVowels(self, s: str) -> str:
+        vowel = ['A','E','I','O','U','a','e','i','o','u']
+        myV = []
+        for char in s:
+            if(char in vowel):
+                myV.append(char)
+        myV = sorted(myV)
+        ans = "" 
+        for char in s:
+            if(char in vowel):
+                ans = ans+myV.pop(0)
+            else:
+                ans = ans+char
+        return ans            
\ No newline at end of file
diff --git a/leetcode/leetcode/2887-sort-vowels-in-a-string/README.md b/leetcode/leetcode/2887-sort-vowels-in-a-string/README.md
new file mode 100644
index 0000000..74a440d
--- /dev/null
+++ b/leetcode/leetcode/2887-sort-vowels-in-a-string/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/sort-vowels-in-a-string">2887. Sort Vowels in a String</a></h2><h3>Medium</h3><hr><p>Given a <strong>0-indexed</strong> string <code>s</code>, <strong>permute</strong> <code>s</code> to get a new string <code>t</code> such that:</p>
+
+<ul>
+	<li>All consonants remain in their original places. More formally, if there is an index <code>i</code> with <code>0 &lt;= i &lt; s.length</code> such that <code>s[i]</code> is a consonant, then <code>t[i] = s[i]</code>.</li>
+	<li>The vowels must be sorted in the <strong>nondecreasing</strong> order of their <strong>ASCII</strong> values. More formally, for pairs of indices <code>i</code>, <code>j</code> with <code>0 &lt;= i &lt; j &lt; s.length</code> such that <code>s[i]</code> and <code>s[j]</code> are vowels, then <code>t[i]</code> must not have a higher ASCII value than <code>t[j]</code>.</li>
+</ul>
+
+<p>Return <em>the resulting string</em>.</p>
+
+<p>The vowels are <code>&#39;a&#39;</code>, <code>&#39;e&#39;</code>, <code>&#39;i&#39;</code>, <code>&#39;o&#39;</code>, and <code>&#39;u&#39;</code>, and they can appear in lowercase or uppercase. Consonants comprise all letters that are not vowels.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;lEetcOde&quot;
+<strong>Output:</strong> &quot;lEOtcede&quot;
+<strong>Explanation:</strong> &#39;E&#39;, &#39;O&#39;, and &#39;e&#39; are the vowels in s; &#39;l&#39;, &#39;t&#39;, &#39;c&#39;, and &#39;d&#39; are all consonants. The vowels are sorted according to their ASCII values, and the consonants remain in the same places.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;lYmpH&quot;
+<strong>Output:</strong> &quot;lYmpH&quot;
+<strong>Explanation:</strong> There are no vowels in s (all characters in s are consonants), so we return &quot;lYmpH&quot;.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> consists only of letters of the&nbsp;English alphabet&nbsp;in <strong>uppercase and lowercase</strong>.</li>
+</ul>
diff --git a/leetcode/leetcode/2888-minimum-index-of-a-valid-split/2888-minimum-index-of-a-valid-split.java b/leetcode/leetcode/2888-minimum-index-of-a-valid-split/2888-minimum-index-of-a-valid-split.java
new file mode 100644
index 0000000..4c64ea5
--- /dev/null
+++ b/leetcode/leetcode/2888-minimum-index-of-a-valid-split/2888-minimum-index-of-a-valid-split.java
@@ -0,0 +1,41 @@
+class Solution {
+
+    public int minimumIndex(List<Integer> nums) {
+        // Find the majority element
+        int x = nums.get(0), count = 0, xCount = 0, n = nums.size();
+
+        for (int num : nums) {
+            if (num == x) {
+                count++;
+            } else {
+                count--;
+            }
+            if (count == 0) {
+                x = num;
+                count = 1;
+            }
+        }
+
+        // Count frequency of majority element
+        for (int num : nums) {
+            if (num == x) {
+                xCount++;
+            }
+        }
+
+        // Check if valid split is possible
+        count = 0;
+        for (int index = 0; index < n; index++) {
+            if (nums.get(index) == x) {
+                count++;
+            }
+            int remainingCount = xCount - count;
+            // Check if both left and right partitions satisfy the condition
+            if (count * 2 > index + 1 && remainingCount * 2 > n - index - 1) {
+                return index;
+            }
+        }
+
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/2888-minimum-index-of-a-valid-split/README.md b/leetcode/leetcode/2888-minimum-index-of-a-valid-split/README.md
new file mode 100644
index 0000000..3499d62
--- /dev/null
+++ b/leetcode/leetcode/2888-minimum-index-of-a-valid-split/README.md
@@ -0,0 +1,54 @@
+<h2><a href="https://leetcode.com/problems/minimum-index-of-a-valid-split">2888. Minimum Index of a Valid Split</a></h2><h3>Medium</h3><hr><p>An element <code>x</code> of an integer array <code>arr</code> of length <code>m</code> is <strong>dominant</strong> if <strong>more than half</strong> the elements of <code>arr</code> have a value of <code>x</code>.</p>
+
+<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> of length <code>n</code> with one <strong>dominant</strong> element.</p>
+
+<p>You can split <code>nums</code> at an index <code>i</code> into two arrays <code>nums[0, ..., i]</code> and <code>nums[i + 1, ..., n - 1]</code>, but the split is only <strong>valid</strong> if:</p>
+
+<ul>
+	<li><code>0 &lt;= i &lt; n - 1</code></li>
+	<li><code>nums[0, ..., i]</code>, and <code>nums[i + 1, ..., n - 1]</code> have the same dominant element.</li>
+</ul>
+
+<p>Here, <code>nums[i, ..., j]</code> denotes the subarray of <code>nums</code> starting at index <code>i</code> and ending at index <code>j</code>, both ends being inclusive. Particularly, if <code>j &lt; i</code> then <code>nums[i, ..., j]</code> denotes an empty subarray.</p>
+
+<p>Return <em>the <strong>minimum</strong> index of a <strong>valid split</strong></em>. If no valid split exists, return <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,2,2]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> We can split the array at index 2 to obtain arrays [1,2,2] and [2]. 
+In array [1,2,2], element 2 is dominant since it occurs twice in the array and 2 * 2 &gt; 3. 
+In array [2], element 2 is dominant since it occurs once in the array and 1 * 2 &gt; 1.
+Both [1,2,2] and [2] have the same dominant element as nums, so this is a valid split. 
+It can be shown that index 2 is the minimum index of a valid split. </pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [2,1,3,1,1,1,7,1,2,1]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> We can split the array at index 4 to obtain arrays [2,1,3,1,1] and [1,7,1,2,1].
+In array [2,1,3,1,1], element 1 is dominant since it occurs thrice in the array and 3 * 2 &gt; 5.
+In array [1,7,1,2,1], element 1 is dominant since it occurs thrice in the array and 3 * 2 &gt; 5.
+Both [2,1,3,1,1] and [1,7,1,2,1] have the same dominant element as nums, so this is a valid split.
+It can be shown that index 4 is the minimum index of a valid split.</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [3,3,3,3,7,2,2]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> It can be shown that there is no valid split.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>nums</code> has exactly one dominant element.</li>
+</ul>
diff --git a/leetcode/leetcode/290-word-pattern/290-word-pattern.java b/leetcode/leetcode/290-word-pattern/290-word-pattern.java
new file mode 100644
index 0000000..09c7468
--- /dev/null
+++ b/leetcode/leetcode/290-word-pattern/290-word-pattern.java
@@ -0,0 +1,19 @@
+class Solution {
+    public boolean wordPattern(String pattern, String s) {
+        HashMap<Character,String> map = new HashMap<>();
+        String[] list = s.split(" ");
+        if(list.length!=pattern.length()) return false;
+        for(int i = 0;i<pattern.length();i++){
+            if(map.containsKey(pattern.charAt(i))){
+                if(!(map.get(pattern.charAt(i)).equals(list[i]))) return false;
+            }else map.put(pattern.charAt(i),list[i]);
+        }
+        map.clear();
+        HashMap<String,Character> map1 = new HashMap<>();
+        for(int i = 0;i<list.length;i++){
+            if(map1.containsKey(list[i]) && map1.get(list[i]) != pattern.charAt(i)) return false;
+            else map1.put(list[i],pattern.charAt(i));
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/290-word-pattern/NOTES.md b/leetcode/leetcode/290-word-pattern/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/290-word-pattern/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/290-word-pattern/README.md b/leetcode/leetcode/290-word-pattern/README.md
new file mode 100644
index 0000000..b7dfaaf
--- /dev/null
+++ b/leetcode/leetcode/290-word-pattern/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/word-pattern/">290. Word Pattern</a></h2><h3>Easy</h3><hr><div><p>Given a <code>pattern</code> and a string <code>s</code>, find if <code>s</code>&nbsp;follows the same pattern.</p>
+
+<p>Here <b>follow</b> means a full match, such that there is a bijection between a letter in <code>pattern</code> and a <b>non-empty</b> word in <code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> pattern = "abba", s = "dog cat cat dog"
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> pattern = "abba", s = "dog cat cat fish"
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> pattern = "aaaa", s = "dog cat cat dog"
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= pattern.length &lt;= 300</code></li>
+	<li><code>pattern</code> contains only lower-case English letters.</li>
+	<li><code>1 &lt;= s.length &lt;= 3000</code></li>
+	<li><code>s</code> contains only lowercase English letters and spaces <code>' '</code>.</li>
+	<li><code>s</code> <strong>does not contain</strong> any leading or trailing spaces.</li>
+	<li>All the words in <code>s</code> are separated by a <strong>single space</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/295-find-median-from-data-stream/295-find-median-from-data-stream.java b/leetcode/leetcode/295-find-median-from-data-stream/295-find-median-from-data-stream.java
new file mode 100644
index 0000000..7367da1
--- /dev/null
+++ b/leetcode/leetcode/295-find-median-from-data-stream/295-find-median-from-data-stream.java
@@ -0,0 +1,37 @@
+class MedianFinder {
+    PriorityQueue<Integer> large;
+    private PriorityQueue<Integer> small;
+    boolean even;
+
+    public MedianFinder() {
+        large = new PriorityQueue<>();
+        small = new PriorityQueue<>(Collections.reverseOrder());
+        even = true;
+    }
+    
+    public void addNum(int num) {
+        if(even){
+            large.offer(num);
+            small.offer(large.poll());
+        }else{
+            small.offer(num);
+            large.offer(small.poll());
+        }
+        even = !even;
+    }
+    
+    public double findMedian() {
+        if(even){
+            return (small.peek()+large.peek())/2.0;
+        }else{
+            return small.peek();
+        }
+    }
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder obj = new MedianFinder();
+ * obj.addNum(num);
+ * double param_2 = obj.findMedian();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/295-find-median-from-data-stream/NOTES.md b/leetcode/leetcode/295-find-median-from-data-stream/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/295-find-median-from-data-stream/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/297-serialize-and-deserialize-binary-tree/297-serialize-and-deserialize-binary-tree.java b/leetcode/leetcode/297-serialize-and-deserialize-binary-tree/297-serialize-and-deserialize-binary-tree.java
new file mode 100644
index 0000000..c4ac3fc
--- /dev/null
+++ b/leetcode/leetcode/297-serialize-and-deserialize-binary-tree/297-serialize-and-deserialize-binary-tree.java
@@ -0,0 +1,54 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Codec {
+    public class pair{
+        TreeNode root;
+        int index;
+        pair(TreeNode root, int index){
+            this.root = root;
+            this.index = index;
+        }
+    }
+    public String serialize(TreeNode root){
+        if(root == null){
+            String s = "N";
+            return s;
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append(Integer.toString(root.val));
+        sb.append(",");
+        sb.append(serialize(root.left));
+        sb.append(",");
+        sb.append(serialize(root.right));
+        return sb.toString();
+    }
+    // Decodes your encoded data to tree.
+    private pair helper(String[] s, int index){
+        if(index >= s.length) return new pair(null, index);
+        if(s[index].equals("N")) return new pair(null, index+1);
+        int val = Integer.parseInt(s[index++]);
+        TreeNode root = new TreeNode(val);
+        pair left = helper(s, index);
+        pair right = helper(s, left.index);
+        root.left = left.root;
+        root.right = right.root;
+        return new pair(root, right.index);
+    }
+    public TreeNode deserialize(String s) {
+        if(s.equals("N")) return null;
+        String[] res = s.split(",");
+        return helper(res,0).root;
+    }
+}
+
+// Your Codec object will be instantiated and called as such:
+// Codec ser = new Codec();
+// Codec deser = new Codec();
+// TreeNode ans = deser.deserialize(ser.serialize(root));
\ No newline at end of file
diff --git a/leetcode/leetcode/297-serialize-and-deserialize-binary-tree/NOTES.md b/leetcode/leetcode/297-serialize-and-deserialize-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/297-serialize-and-deserialize-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/297-serialize-and-deserialize-binary-tree/README.md b/leetcode/leetcode/297-serialize-and-deserialize-binary-tree/README.md
new file mode 100644
index 0000000..cd71894
--- /dev/null
+++ b/leetcode/leetcode/297-serialize-and-deserialize-binary-tree/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/serialize-and-deserialize-binary-tree/">297. Serialize and Deserialize Binary Tree</a></h2><h3>Hard</h3><hr><div><p>Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.</p>
+
+<p>Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.</p>
+
+<p><strong>Clarification:</strong> The input/output format is the same as <a href="/faq/#binary-tree" target="_blank">how LeetCode serializes a binary tree</a>. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/serdeser.jpg" style="width: 442px; height: 324px;">
+<pre><strong>Input:</strong> root = [1,2,3,null,null,4,5]
+<strong>Output:</strong> [1,2,3,null,null,4,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/300-longest-increasing-subsequence/300-longest-increasing-subsequence.java b/leetcode/leetcode/300-longest-increasing-subsequence/300-longest-increasing-subsequence.java
new file mode 100644
index 0000000..f2bc14e
--- /dev/null
+++ b/leetcode/leetcode/300-longest-increasing-subsequence/300-longest-increasing-subsequence.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        int[] res = new int[nums.length];
+        int ans = 1;
+        for(int i = nums.length - 1;i!=-1;i--){
+            int j = i+1;
+            int val = 1;
+            while(j<nums.length){
+                if(nums[i]<nums[j]) val = Math.max(val,res[j]+1);
+                j++;
+            }
+            res[i] = val;
+            ans = Math.max(ans,res[i]);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/300-longest-increasing-subsequence/NOTES.md b/leetcode/leetcode/300-longest-increasing-subsequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/300-longest-increasing-subsequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/300-longest-increasing-subsequence/README.md b/leetcode/leetcode/300-longest-increasing-subsequence/README.md
new file mode 100644
index 0000000..9a2c8d6
--- /dev/null
+++ b/leetcode/leetcode/300-longest-increasing-subsequence/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/longest-increasing-subsequence/">300. Longest Increasing Subsequence</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, return the length of the longest strictly increasing subsequence.</p>
+
+<p>A <strong>subsequence</strong> is a sequence that can be derived from an array by deleting some or no elements without changing the order of the remaining elements. For example, <code>[3,6,2,7]</code> is a subsequence of the array <code>[0,3,1,6,2,2,7]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [10,9,2,5,3,7,101,18]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The longest increasing subsequence is [2,3,7,101], therefore the length is 4.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1,0,3,2,3]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [7,7,7,7,7,7,7]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2500</code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><b>Follow up:</b>&nbsp;Can you come up with an algorithm that runs in&nbsp;<code>O(n log(n))</code> time complexity?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/3001-apply-operations-to-maximize-score/3001-apply-operations-to-maximize-score.java b/leetcode/leetcode/3001-apply-operations-to-maximize-score/3001-apply-operations-to-maximize-score.java
new file mode 100644
index 0000000..4a5b281
--- /dev/null
+++ b/leetcode/leetcode/3001-apply-operations-to-maximize-score/3001-apply-operations-to-maximize-score.java
@@ -0,0 +1,133 @@
+class Solution {
+
+    private static final int MOD = 1_000_000_007;
+
+    public int maximumScore(List<Integer> nums, int k) {
+        int n = nums.size();
+        int[] primeScores = new int[n];
+
+        // Find the maximum element in nums to determine the range for prime generation
+        int maxElement = Collections.max(nums);
+
+        // Get all prime numbers up to maxElement using the Sieve of Eratosthenes
+        List<Integer> primes = getPrimes(maxElement);
+
+        // Calculate the prime score for each number in nums
+        for (int index = 0; index < n; index++) {
+            int num = nums.get(index);
+
+            // Iterate over the generated primes to count unique prime factors
+            for (int prime : primes) {
+                if (prime * prime > num) break; // Stop early if prime^2 exceeds num
+                if (num % prime != 0) continue; // Skip if the prime is not a factor
+
+                primeScores[index]++; // Increment prime score for the factor
+                while (num % prime == 0) num /= prime; // Remove all occurrences of this factor
+            }
+
+            // If num is still greater than 1, it is a prime number itself
+            if (num > 1) primeScores[index]++;
+        }
+
+        // Initialize next and previous dominant index arrays
+        int[] nextDominant = new int[n];
+        int[] prevDominant = new int[n];
+        Arrays.fill(nextDominant, n);
+        Arrays.fill(prevDominant, -1);
+
+        // Stack to store indices for a monotonic decreasing prime score
+        Stack<Integer> decreasingPrimeScoreStack = new Stack<>();
+
+        // Calculate the next and previous dominant indices for each number
+        for (int index = 0; index < n; index++) {
+            while (
+                !decreasingPrimeScoreStack.isEmpty() &&
+                primeScores[decreasingPrimeScoreStack.peek()] <
+                primeScores[index]
+            ) {
+                int topIndex = decreasingPrimeScoreStack.pop();
+                nextDominant[topIndex] = index;
+            }
+
+            if (!decreasingPrimeScoreStack.isEmpty()) {
+                prevDominant[index] = decreasingPrimeScoreStack.peek();
+            }
+
+            decreasingPrimeScoreStack.push(index);
+        }
+
+        // Calculate the number of subarrays in which each element is dominant
+        long[] numOfSubarrays = new long[n];
+        for (int index = 0; index < n; index++) {
+            numOfSubarrays[index] =
+                (long) (nextDominant[index] - index) *
+                (index - prevDominant[index]);
+        }
+
+        // Sort elements in decreasing order based on their values
+        List<int[]> sortedArray = new ArrayList<>();
+        for (int index = 0; index < n; index++) {
+            sortedArray.add(new int[] { nums.get(index), index });
+        }
+        sortedArray.sort((a, b) -> Integer.compare(b[0], a[0])); // Sort in descending order
+
+        long score = 1;
+        int processingIndex = 0;
+
+        // Process elements while there are operations left
+        while (k > 0) {
+            int[] element = sortedArray.get(processingIndex++);
+            int num = element[0];
+            int index = element[1];
+
+            // Calculate the number of operations to apply on the current element
+            long operations = Math.min(k, numOfSubarrays[index]);
+
+            // Update the score by raising the element to the power of operations
+            score = (score * power(num, operations)) % MOD;
+
+            // Reduce the remaining operations count
+            k -= operations;
+        }
+
+        return (int) score;
+    }
+
+    // Helper function to compute the power of a number modulo MOD
+    private long power(long base, long exponent) {
+        long res = 1;
+
+        while (exponent > 0) {
+            if (exponent % 2 == 1) {
+                res = (res * base) % MOD;
+            }
+            base = (base * base) % MOD;
+            exponent /= 2;
+        }
+
+        return res;
+    }
+
+    // Function to generate prime numbers up to a given limit using the Sieve of Eratosthenes
+    private List<Integer> getPrimes(int limit) {
+        boolean[] isPrime = new boolean[limit + 1];
+        Arrays.fill(isPrime, true);
+        List<Integer> primes = new ArrayList<>();
+
+        for (int number = 2; number <= limit; number++) {
+            if (!isPrime[number]) continue;
+
+            primes.add(number);
+
+            for (
+                long multiple = (long) number * number;
+                multiple <= limit;
+                multiple += number
+            ) {
+                isPrime[(int) multiple] = false;
+            }
+        }
+
+        return primes;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3001-apply-operations-to-maximize-score/README.md b/leetcode/leetcode/3001-apply-operations-to-maximize-score/README.md
new file mode 100644
index 0000000..435c8b3
--- /dev/null
+++ b/leetcode/leetcode/3001-apply-operations-to-maximize-score/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/apply-operations-to-maximize-score">3001. Apply Operations to Maximize Score</a></h2><h3>Hard</h3><hr><p>You are given an array <code>nums</code> of <code>n</code> positive integers and an integer <code>k</code>.</p>
+
+<p>Initially, you start with a score of <code>1</code>. You have to maximize your score by applying the following operation at most <code>k</code> times:</p>
+
+<ul>
+	<li>Choose any <strong>non-empty</strong> subarray <code>nums[l, ..., r]</code> that you haven&#39;t chosen previously.</li>
+	<li>Choose an element <code>x</code> of <code>nums[l, ..., r]</code> with the highest <strong>prime score</strong>. If multiple such elements exist, choose the one with the smallest index.</li>
+	<li>Multiply your score by <code>x</code>.</li>
+</ul>
+
+<p>Here, <code>nums[l, ..., r]</code> denotes the subarray of <code>nums</code> starting at index <code>l</code> and ending at the index <code>r</code>, both ends being inclusive.</p>
+
+<p>The <strong>prime score</strong> of an integer <code>x</code> is equal to the number of distinct prime factors of <code>x</code>. For example, the prime score of <code>300</code> is <code>3</code> since <code>300 = 2 * 2 * 3 * 5 * 5</code>.</p>
+
+<p>Return <em>the <strong>maximum possible score</strong> after applying at most </em><code>k</code><em> operations</em>.</p>
+
+<p>Since the answer may be large, return it modulo <code>10<sup>9 </sup>+ 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [8,3,9,3,8], k = 2
+<strong>Output:</strong> 81
+<strong>Explanation:</strong> To get a score of 81, we can apply the following operations:
+- Choose subarray nums[2, ..., 2]. nums[2] is the only element in this subarray. Hence, we multiply the score by nums[2]. The score becomes 1 * 9 = 9.
+- Choose subarray nums[2, ..., 3]. Both nums[2] and nums[3] have a prime score of 1, but nums[2] has the smaller index. Hence, we multiply the score by nums[2]. The score becomes 9 * 9 = 81.
+It can be proven that 81 is the highest score one can obtain.</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [19,12,14,6,10,18], k = 3
+<strong>Output:</strong> 4788
+<strong>Explanation:</strong> To get a score of 4788, we can apply the following operations: 
+- Choose subarray nums[0, ..., 0]. nums[0] is the only element in this subarray. Hence, we multiply the score by nums[0]. The score becomes 1 * 19 = 19.
+- Choose subarray nums[5, ..., 5]. nums[5] is the only element in this subarray. Hence, we multiply the score by nums[5]. The score becomes 19 * 18 = 342.
+- Choose subarray nums[2, ..., 3]. Both nums[2] and nums[3] have a prime score of 2, but nums[2] has the smaller index. Hence, we multipy the score by nums[2]. The score becomes 342 * 14 = 4788.
+It can be proven that 4788 is the highest score one can obtain.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length == n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= k &lt;= min(n * (n + 1) / 2, 10<sup>9</sup>)</code></li>
+</ul>
diff --git a/leetcode/leetcode/3075-maximize-happiness-of-selected-children/3075-maximize-happiness-of-selected-children.java b/leetcode/leetcode/3075-maximize-happiness-of-selected-children/3075-maximize-happiness-of-selected-children.java
new file mode 100644
index 0000000..2495e0a
--- /dev/null
+++ b/leetcode/leetcode/3075-maximize-happiness-of-selected-children/3075-maximize-happiness-of-selected-children.java
@@ -0,0 +1,13 @@
+class Solution {
+    public long maximumHappinessSum(int[] happiness, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder());
+        for(int ele: happiness){
+            pq.add(ele);
+        }
+        long ans = 0;
+        for(int i = 0;i<k;i++){
+           ans+=Math.max(pq.poll()-i,0); 
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3075-maximize-happiness-of-selected-children/NOTES.md b/leetcode/leetcode/3075-maximize-happiness-of-selected-children/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/3075-maximize-happiness-of-selected-children/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/3075-maximize-happiness-of-selected-children/README.md b/leetcode/leetcode/3075-maximize-happiness-of-selected-children/README.md
new file mode 100644
index 0000000..16567a7
--- /dev/null
+++ b/leetcode/leetcode/3075-maximize-happiness-of-selected-children/README.md
@@ -0,0 +1,47 @@
+<h2><a href="https://leetcode.com/problems/maximize-happiness-of-selected-children/">3075. Maximize Happiness of Selected Children</a></h2><h3>Medium</h3><hr><div><p>You are given an array <code>happiness</code> of length <code>n</code>, and a <strong>positive</strong> integer <code>k</code>.</p>
+
+<p>There are <code>n</code> children standing in a queue, where the <code>i<sup>th</sup></code> child has <strong>happiness value</strong> <code>happiness[i]</code>. You want to select <code>k</code> children from these <code>n</code> children in <code>k</code> turns.</p>
+
+<p>In each turn, when you select a child, the <strong>happiness value</strong> of all the children that have <strong>not</strong> been selected till now decreases by <code>1</code>. Note that the happiness value <strong>cannot</strong> become negative and gets decremented <strong>only</strong> if it is positive.</p>
+
+<p>Return <em>the <strong>maximum</strong> sum of the happiness values of the selected children you can achieve by selecting </em><code>k</code> <em>children</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre><strong>Input:</strong> happiness = [1,2,3], k = 2
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> We can pick 2 children in the following way:
+- Pick the child with the happiness value == 3. The happiness value of the remaining children becomes [0,1].
+- Pick the child with the happiness value == 1. The happiness value of the remaining child becomes [0]. Note that the happiness value cannot become less than 0.
+The sum of the happiness values of the selected children is 3 + 1 = 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre><strong>Input:</strong> happiness = [1,1,1,1], k = 2
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> We can pick 2 children in the following way:
+- Pick any child with the happiness value == 1. The happiness value of the remaining children becomes [0,0,0].
+- Pick the child with the happiness value == 0. The happiness value of the remaining child becomes [0,0].
+The sum of the happiness values of the selected children is 1 + 0 = 1.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre><strong>Input:</strong> happiness = [2,3,4,5], k = 1
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> We can pick 1 child in the following way:
+- Pick the child with the happiness value == 5. The happiness value of the remaining children becomes [1,2,3].
+The sum of the happiness values of the selected children is 5.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n == happiness.length &lt;= 2 * 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= happiness[i] &lt;= 10<sup>8</sup></code></li>
+	<li><code>1 &lt;= k &lt;= n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/316-remove-duplicate-letters/316-remove-duplicate-letters.java b/leetcode/leetcode/316-remove-duplicate-letters/316-remove-duplicate-letters.java
new file mode 100644
index 0000000..afcb3fc
--- /dev/null
+++ b/leetcode/leetcode/316-remove-duplicate-letters/316-remove-duplicate-letters.java
@@ -0,0 +1,51 @@
+class Solution {
+    public String removeDuplicateLetters(String s) {
+        if(s.length()<2) return s;
+        boolean[] exist = new boolean[26];
+        StringBuilder sb = new StringBuilder();
+        int[] freq = new int[26];
+        for(int i = 0;i<s.length();i++){
+            freq[s.charAt(i) - 'a']++;
+        }
+        int size = 0;
+        int i = 0;
+        while(i<s.length()){
+            if(size == 0){
+                sb.append(s.charAt(i));
+                exist[s.charAt(i) - 'a'] = true;
+                freq[s.charAt(i) - 'a']--;
+                size++;
+                i++;
+                continue;
+            }
+            if(!exist[s.charAt(i) - 'a']){
+                if(sb.charAt(size-1)<s.charAt(i)){
+                    sb.append(s.charAt(i));
+                    size++;
+                    freq[s.charAt(i) - 'a']--;
+                    exist[s.charAt(i) - 'a'] = true;
+                }else{
+                    if(freq[sb.charAt(size - 1)-'a']>=1){
+                        exist[sb.charAt(size-1) - 'a'] = false;
+                        sb.deleteCharAt(size - 1);
+                        size--;
+                        continue;
+                        
+                    }else{
+                        sb.append(s.charAt(i));
+                        size++;
+                        freq[s.charAt(i) - 'a']--;
+                        exist[s.charAt(i) - 'a'] = true;
+
+                    }
+                }
+            }else {
+                freq[s.charAt(i) - 'a']--;
+                
+            }
+            i++;
+                
+        }
+        return sb.toString();
+    } 
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/316-remove-duplicate-letters/NOTES.md b/leetcode/leetcode/316-remove-duplicate-letters/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/316-remove-duplicate-letters/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/316-remove-duplicate-letters/README.md b/leetcode/leetcode/316-remove-duplicate-letters/README.md
new file mode 100644
index 0000000..52507ca
--- /dev/null
+++ b/leetcode/leetcode/316-remove-duplicate-letters/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/remove-duplicate-letters/">316. Remove Duplicate Letters</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code>, remove duplicate letters so that every letter appears once and only once. You must make sure your result is <strong>the smallest in lexicographical order</strong> among all possible results.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "bcabc"
+<strong>Output:</strong> "abc"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "cbacdcbc"
+<strong>Output:</strong> "acdb"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as 1081: <a href="https://leetcode.com/problems/smallest-subsequence-of-distinct-characters/" target="_blank">https://leetcode.com/problems/smallest-subsequence-of-distinct-characters/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/3172-divisible-and-non-divisible-sums-difference/3172-divisible-and-non-divisible-sums-difference.java b/leetcode/leetcode/3172-divisible-and-non-divisible-sums-difference/3172-divisible-and-non-divisible-sums-difference.java
new file mode 100644
index 0000000..3bbd6d0
--- /dev/null
+++ b/leetcode/leetcode/3172-divisible-and-non-divisible-sums-difference/3172-divisible-and-non-divisible-sums-difference.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int differenceOfSums(int n, int m) {
+        int sum = 0;
+        int current = m;
+        int count = 2;
+        while(current<=n){
+            sum += current;
+            current = count*m;
+            count++;
+        }
+        return n*(n+1)/2 - 2*sum;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3172-divisible-and-non-divisible-sums-difference/README.md b/leetcode/leetcode/3172-divisible-and-non-divisible-sums-difference/README.md
new file mode 100644
index 0000000..6ad2ed6
--- /dev/null
+++ b/leetcode/leetcode/3172-divisible-and-non-divisible-sums-difference/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/divisible-and-non-divisible-sums-difference">3172. Divisible and Non-divisible Sums Difference</a></h2><h3>Easy</h3><hr><p>You are given positive integers <code>n</code> and <code>m</code>.</p>
+
+<p>Define two integers as follows:</p>
+
+<ul>
+	<li><code>num1</code>: The sum of all integers in the range <code>[1, n]</code> (both <strong>inclusive</strong>) that are <strong>not divisible</strong> by <code>m</code>.</li>
+	<li><code>num2</code>: The sum of all integers in the range <code>[1, n]</code> (both <strong>inclusive</strong>) that are <strong>divisible</strong> by <code>m</code>.</li>
+</ul>
+
+<p>Return <em>the integer</em> <code>num1 - num2</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 10, m = 3
+<strong>Output:</strong> 19
+<strong>Explanation:</strong> In the given example:
+- Integers in the range [1, 10] that are not divisible by 3 are [1,2,4,5,7,8,10], num1 is the sum of those integers = 37.
+- Integers in the range [1, 10] that are divisible by 3 are [3,6,9], num2 is the sum of those integers = 18.
+We return 37 - 18 = 19 as the answer.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 5, m = 6
+<strong>Output:</strong> 15
+<strong>Explanation:</strong> In the given example:
+- Integers in the range [1, 5] that are not divisible by 6 are [1,2,3,4,5], num1 is the sum of those integers = 15.
+- Integers in the range [1, 5] that are divisible by 6 are [], num2 is the sum of those integers = 0.
+We return 15 - 0 = 15 as the answer.
+</pre>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 5, m = 1
+<strong>Output:</strong> -15
+<strong>Explanation:</strong> In the given example:
+- Integers in the range [1, 5] that are not divisible by 1 are [], num1 is the sum of those integers = 0.
+- Integers in the range [1, 5] that are divisible by 1 are [1,2,3,4,5], num2 is the sum of those integers = 15.
+We return 0 - 15 = -15 as the answer.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n, m &lt;= 1000</code></li>
+</ul>
diff --git a/leetcode/leetcode/3201-distribute-candies-among-children-ii/3201-distribute-candies-among-children-ii.java b/leetcode/leetcode/3201-distribute-candies-among-children-ii/3201-distribute-candies-among-children-ii.java
new file mode 100644
index 0000000..f36fe46
--- /dev/null
+++ b/leetcode/leetcode/3201-distribute-candies-among-children-ii/3201-distribute-candies-among-children-ii.java
@@ -0,0 +1,18 @@
+class Solution {
+
+    public long distributeCandies(int n, int limit) {
+        return (
+            cal(n + 2) -
+            3 * cal(n - limit + 1) +
+            3 * cal(n - (limit + 1) * 2 + 2) -
+            cal(n - 3 * (limit + 1) + 2)
+        );
+    }
+
+    public long cal(int x) {
+        if (x < 0) {
+            return 0;
+        }
+        return ((long) x * (x - 1)) / 2;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3201-distribute-candies-among-children-ii/README.md b/leetcode/leetcode/3201-distribute-candies-among-children-ii/README.md
new file mode 100644
index 0000000..adfce05
--- /dev/null
+++ b/leetcode/leetcode/3201-distribute-candies-among-children-ii/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/distribute-candies-among-children-ii">3201. Distribute Candies Among Children II</a></h2><h3>Medium</h3><hr><p>You are given two positive integers <code>n</code> and <code>limit</code>.</p>
+
+<p>Return <em>the <strong>total number</strong> of ways to distribute </em><code>n</code> <em>candies among </em><code>3</code><em> children such that no child gets more than </em><code>limit</code><em> candies.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 5, limit = 2
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> There are 3 ways to distribute 5 candies such that no child gets more than 2 candies: (1, 2, 2), (2, 1, 2) and (2, 2, 1).
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> n = 3, limit = 3
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> There are 10 ways to distribute 3 candies such that no child gets more than 3 candies: (0, 0, 3), (0, 1, 2), (0, 2, 1), (0, 3, 0), (1, 0, 2), (1, 1, 1), (1, 2, 0), (2, 0, 1), (2, 1, 0) and (3, 0, 0).
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>6</sup></code></li>
+	<li><code>1 &lt;= limit &lt;= 10<sup>6</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/3213-count-subarrays-where-max-element-appears-at-least-k-times/3213-count-subarrays-where-max-element-appears-at-least-k-times.java b/leetcode/leetcode/3213-count-subarrays-where-max-element-appears-at-least-k-times/3213-count-subarrays-where-max-element-appears-at-least-k-times.java
new file mode 100644
index 0000000..556b158
--- /dev/null
+++ b/leetcode/leetcode/3213-count-subarrays-where-max-element-appears-at-least-k-times/3213-count-subarrays-where-max-element-appears-at-least-k-times.java
@@ -0,0 +1,19 @@
+class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int max = Integer.MIN_VALUE;
+        for(int num: nums) max = Math.max(max,num);
+        int start,end,freq = 0;
+        long ans = 0;
+        for(start = 0,end = 0;end<nums.length;end++){
+            if(nums[end] == max) freq++;
+            while(freq==k){
+                if(nums[start] == max) freq--;
+                start++;
+            }
+            ans+=start;
+            
+
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3213-count-subarrays-where-max-element-appears-at-least-k-times/README.md b/leetcode/leetcode/3213-count-subarrays-where-max-element-appears-at-least-k-times/README.md
new file mode 100644
index 0000000..a2edb33
--- /dev/null
+++ b/leetcode/leetcode/3213-count-subarrays-where-max-element-appears-at-least-k-times/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/count-subarrays-where-max-element-appears-at-least-k-times">3213. Count Subarrays Where Max Element Appears at Least K Times</a></h2><h3>Medium</h3><hr><p>You are given an integer array <code>nums</code> and a <strong>positive</strong> integer <code>k</code>.</p>
+
+<p>Return <em>the number of subarrays where the <strong>maximum</strong> element of </em><code>nums</code><em> appears <strong>at least</strong> </em><code>k</code><em> times in that subarray.</em></p>
+
+<p>A <strong>subarray</strong> is a contiguous sequence of elements within an array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,3,2,3,3], k = 2
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The subarrays that contain the element 3 at least 2 times are: [1,3,2,3], [1,3,2,3,3], [3,2,3], [3,2,3,3], [2,3,3] and [3,3].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,4,2,1], k = 3
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> No subarray contains the element 4 at least 3 times.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>5</sup></code></li>
+</ul>
diff --git a/leetcode/leetcode/3227-find-missing-and-repeated-values/3227-find-missing-and-repeated-values.java b/leetcode/leetcode/3227-find-missing-and-repeated-values/3227-find-missing-and-repeated-values.java
new file mode 100644
index 0000000..68c2862
--- /dev/null
+++ b/leetcode/leetcode/3227-find-missing-and-repeated-values/3227-find-missing-and-repeated-values.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int[] findMissingAndRepeatedValues(int[][] grid) {
+        int[] ans = {-1,-1};
+        int n = grid.length;
+        boolean[] visited = new boolean[n*n];
+        for(int i = 0;i<grid.length;i++){
+            for(int j = 0;j<grid[i].length;j++){
+                int val = grid[i][j];
+                if(visited[val - 1] == true){
+                    ans[0] = val;
+                }
+                visited[val - 1] = true;
+            }
+        }
+        for(int i = 0;i<visited.length;i++){
+            if(visited[i] == false){
+                ans[1] = i+1;
+                break;
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3227-find-missing-and-repeated-values/README.md b/leetcode/leetcode/3227-find-missing-and-repeated-values/README.md
new file mode 100644
index 0000000..c25efda
--- /dev/null
+++ b/leetcode/leetcode/3227-find-missing-and-repeated-values/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/find-missing-and-repeated-values">3227. Find Missing and Repeated Values</a></h2><h3>Easy</h3><hr><p>You are given a <strong>0-indexed</strong> 2D integer matrix <code><font face="monospace">grid</font></code> of size <code>n * n</code> with values in the range <code>[1, n<sup>2</sup>]</code>. Each integer appears <strong>exactly once</strong> except <code>a</code> which appears <strong>twice</strong> and <code>b</code> which is <strong>missing</strong>. The task is to find the repeating and missing numbers <code>a</code> and <code>b</code>.</p>
+
+<p>Return <em>a <strong>0-indexed </strong>integer array </em><code>ans</code><em> of size </em><code>2</code><em> where </em><code>ans[0]</code><em> equals to </em><code>a</code><em> and </em><code>ans[1]</code><em> equals to </em><code>b</code><em>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[1,3],[2,2]]
+<strong>Output:</strong> [2,4]
+<strong>Explanation:</strong> Number 2 is repeated and number 4 is missing so the answer is [2,4].
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> grid = [[9,1,7],[8,9,2],[3,4,6]]
+<strong>Output:</strong> [9,5]
+<strong>Explanation:</strong> Number 9 is repeated and number 5 is missing so the answer is [9,5].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n == grid.length == grid[i].length &lt;= 50</code></li>
+	<li><code>1 &lt;= grid[i][j] &lt;= n * n</code></li>
+	<li>For all <code>x</code> that <code>1 &lt;= x &lt;= n * n</code> there is exactly one <code>x</code> that is not equal to any of the grid members.</li>
+	<li>For all <code>x</code> that <code>1 &lt;= x &lt;= n * n</code> there is exactly one <code>x</code> that is equal to exactly two of the grid members.</li>
+	<li>For all <code>x</code> that <code>1 &lt;= x &lt;= n * n</code> except two of them there is exatly one pair of <code>i, j</code> that <code>0 &lt;= i, j &lt;= n - 1</code> and <code>grid[i][j] == x</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/3242-count-elements-with-maximum-frequency/3242-count-elements-with-maximum-frequency.java b/leetcode/leetcode/3242-count-elements-with-maximum-frequency/3242-count-elements-with-maximum-frequency.java
new file mode 100644
index 0000000..5616c08
--- /dev/null
+++ b/leetcode/leetcode/3242-count-elements-with-maximum-frequency/3242-count-elements-with-maximum-frequency.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxFrequencyElements(int[] nums) {
+        Map<Integer,Integer> map  = new HashMap<>();
+        int maxFreq = 0;
+        for(int num: nums){
+            map.put(num,map.getOrDefault(num,0)+1);
+            maxFreq = Math.max(maxFreq,map.get(num));
+        }
+        int ans = 0;
+        for(int key: map.keySet()){
+            if(map.get(key)  == maxFreq){
+                ans+=maxFreq;
+            }
+        }
+        return ans;
+
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3242-count-elements-with-maximum-frequency/README.md b/leetcode/leetcode/3242-count-elements-with-maximum-frequency/README.md
new file mode 100644
index 0000000..830c97a
--- /dev/null
+++ b/leetcode/leetcode/3242-count-elements-with-maximum-frequency/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/count-elements-with-maximum-frequency">3242. Count Elements With Maximum Frequency</a></h2><h3>Easy</h3><hr><p>You are given an array <code>nums</code> consisting of <strong>positive</strong> integers.</p>
+
+<p>Return <em>the <strong>total frequencies</strong> of elements in</em><em> </em><code>nums</code>&nbsp;<em>such that those elements all have the <strong>maximum</strong> frequency</em>.</p>
+
+<p>The <strong>frequency</strong> of an element is the number of occurrences of that element in the array.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,2,3,1,4]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The elements 1 and 2 have a frequency of 2 which is the maximum frequency in the array.
+So the number of elements in the array with maximum frequency is 4.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums = [1,2,3,4,5]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> All elements of the array have a frequency of 1 which is the maximum.
+So the number of elements in the array with maximum frequency is 5.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
+</ul>
diff --git a/leetcode/leetcode/328-odd-even-linked-list/328-odd-even-linked-list.java b/leetcode/leetcode/328-odd-even-linked-list/328-odd-even-linked-list.java
new file mode 100644
index 0000000..c9c3635
--- /dev/null
+++ b/leetcode/leetcode/328-odd-even-linked-list/328-odd-even-linked-list.java
@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode oddEvenList(ListNode head) {
+        if(head == null || head.next == null) return head;
+        ListNode temp = head;
+        ListNode head2 = head.next;
+        ListNode temp2 = head2;
+        while(temp!=null && temp2!=null && temp2.next!=null){
+            temp.next = temp2.next;
+            temp2.next = temp2.next.next;
+            temp = temp.next;
+            temp2 = temp2.next;
+        }
+        temp.next = head2;
+        return head;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/328-odd-even-linked-list/NOTES.md b/leetcode/leetcode/328-odd-even-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/328-odd-even-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/33-search-in-rotated-sorted-array/33-search-in-rotated-sorted-array.java b/leetcode/leetcode/33-search-in-rotated-sorted-array/33-search-in-rotated-sorted-array.java
new file mode 100644
index 0000000..138728e
--- /dev/null
+++ b/leetcode/leetcode/33-search-in-rotated-sorted-array/33-search-in-rotated-sorted-array.java
@@ -0,0 +1,43 @@
+class Solution {
+    public int search(int[] arr, int target) {
+        if(arr.length  == 0) return arr[0] == target ? 0 : -1;
+        int ans = 0;
+        int left = 0;
+        int right = arr.length-1;
+        if(arr[left]<arr[right]) ans = 0;
+        else{
+            while(left<right){
+                int mid = (left+right)/2;
+                if(arr[mid]>arr[mid+1]){
+                    ans = mid+1;
+                    break;
+                }else if(arr[mid]<arr[mid-1]){
+                    ans = mid;
+                    break;
+                }else if(arr[left]<arr[mid]){
+                    left = mid+1;
+                }else{
+                    right = mid-1;
+                }
+            }
+        }
+        int low = 0;
+        int high = ans - 1;
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(arr[mid] > target) high = mid -1;
+            else if(arr[mid]<target) low = mid+1;
+            else return mid;
+        }
+        low = ans;
+        high = arr.length - 1;
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(arr[mid] > target) high = mid -1;
+            else if(arr[mid]<target) low = mid+1;
+            else return mid;
+        }
+            
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3332-minimum-operations-to-exceed-threshold-value-ii/3332-minimum-operations-to-exceed-threshold-value-ii.java b/leetcode/leetcode/3332-minimum-operations-to-exceed-threshold-value-ii/3332-minimum-operations-to-exceed-threshold-value-ii.java
new file mode 100644
index 0000000..c8b32f2
--- /dev/null
+++ b/leetcode/leetcode/3332-minimum-operations-to-exceed-threshold-value-ii/3332-minimum-operations-to-exceed-threshold-value-ii.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int minOperations(int[] nums, int k) {
+        PriorityQueue<Long> minHeap = new PriorityQueue<>();
+        for(int num: nums){
+            minHeap.add((long) num);
+        }
+        int numOperations = 0;
+        while(minHeap.peek()<k){
+            long num1 = minHeap.remove();
+            long num2 = minHeap.remove(); 
+            minHeap.add(Math.min(num1, num2) * 2 + Math.max(num1, num2));
+            numOperations++;
+        }
+        return numOperations;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3332-minimum-operations-to-exceed-threshold-value-ii/README.md b/leetcode/leetcode/3332-minimum-operations-to-exceed-threshold-value-ii/README.md
new file mode 100644
index 0000000..7c223db
--- /dev/null
+++ b/leetcode/leetcode/3332-minimum-operations-to-exceed-threshold-value-ii/README.md
@@ -0,0 +1,64 @@
+<h2><a href="https://leetcode.com/problems/minimum-operations-to-exceed-threshold-value-ii">3332. Minimum Operations to Exceed Threshold Value II</a></h2><h3>Medium</h3><hr><p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>, and an integer <code>k</code>.</p>
+
+<p>You are allowed to perform some operations on <code>nums</code>, where in a single operation, you can:</p>
+
+<ul>
+	<li>Select the two <strong>smallest</strong> integers <code>x</code> and <code>y</code> from <code>nums</code>.</li>
+	<li>Remove <code>x</code> and <code>y</code> from <code>nums</code>.</li>
+	<li>Insert <code>(min(x, y) * 2 + max(x, y))</code> at any position in the array.</li>
+</ul>
+
+<p><strong>Note</strong> that you can only apply the described operation if <code>nums</code> contains <strong>at least</strong> two elements.</p>
+
+<p>Return the <strong>minimum</strong> number of operations needed so that all elements of the array are <strong>greater than or equal to</strong> <code>k</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [2,11,10,1,3], k = 10</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">2</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<ol>
+	<li>In the first operation, we remove elements 1 and 2, then add <code>1 * 2 + 2</code> to <code>nums</code>. <code>nums</code> becomes equal to <code>[4, 11, 10, 3]</code>.</li>
+	<li>In the second operation, we remove elements 3 and 4, then add <code>3 * 2 + 4</code> to <code>nums</code>. <code>nums</code> becomes equal to <code>[10, 11, 10]</code>.</li>
+</ol>
+
+<p>At this stage, all the elements of nums are greater than or equal to 10 so we can stop.&nbsp;</p>
+
+<p>It can be shown that 2 is the minimum number of operations needed so that all elements of the array are greater than or equal to 10.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [1,1,2,4,9], k = 20</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">4</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<ol>
+	<li>After one operation, <code>nums</code> becomes equal to <code>[2, 4, 9, 3]</code>.&nbsp;</li>
+	<li>After two operations, <code>nums</code> becomes equal to <code>[7, 4, 9]</code>.&nbsp;</li>
+	<li>After three operations, <code>nums</code> becomes equal to <code>[15, 9]</code>.&nbsp;</li>
+	<li>After four operations, <code>nums</code> becomes equal to <code>[33]</code>.</li>
+</ol>
+
+<p>At this stage, all the elements of <code>nums</code> are greater than 20 so we can stop.&nbsp;</p>
+
+<p>It can be shown that 4 is the minimum number of operations needed so that all elements of the array are greater than or equal to 20.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 2 * 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>9</sup></code></li>
+	<li>The input is generated such that an answer always exists. That is, there exists some sequence of operations after which all elements of the array are greater than or equal to <code>k</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/3348-minimum-cost-walk-in-weighted-graph/3348-minimum-cost-walk-in-weighted-graph.java b/leetcode/leetcode/3348-minimum-cost-walk-in-weighted-graph/3348-minimum-cost-walk-in-weighted-graph.java
new file mode 100644
index 0000000..6cb8765
--- /dev/null
+++ b/leetcode/leetcode/3348-minimum-cost-walk-in-weighted-graph/3348-minimum-cost-walk-in-weighted-graph.java
@@ -0,0 +1,97 @@
+class Solution {
+
+    public int[] minimumCost(int n, int[][] edges, int[][] queries) {
+        // Create the adjacency list of the graph
+        List<List<int[]>> adjList = new ArrayList<>(n);
+        for (int i = 0; i < n; i++) {
+            adjList.add(new ArrayList<>(2));
+        }
+        for (int[] edge : edges) {
+            adjList.get(edge[0]).add(new int[] { edge[1], edge[2] });
+            adjList.get(edge[1]).add(new int[] { edge[0], edge[2] });
+        }
+
+        boolean[] visited = new boolean[n];
+
+        // Array to store the component ID of each node
+        int[] components = new int[n];
+        List<Integer> componentCost = new ArrayList<>(n);
+
+        int componentId = 0;
+
+        // Perform DFS for each unvisited node to identify components and calculate their costs
+        for (int node = 0; node < n; node++) {
+            // If the node hasn't been visited, it's a new component
+            if (!visited[node]) {
+                // Get the component cost and mark all nodes in the component
+                componentCost.add(
+                    getComponentCost(
+                        node,
+                        adjList,
+                        visited,
+                        components,
+                        componentId
+                    )
+                );
+                // Increment the component ID for the next component
+                componentId++;
+            }
+        }
+
+        int[] answer = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            int start = queries[i][0];
+            int end = queries[i][1];
+
+            if (components[start] == components[end]) {
+                // If they are in the same component, return the precomputed cost for the component
+                answer[i] = componentCost.get(components[start]);
+            } else {
+                // If they are in different components, return -1
+                answer[i] = -1;
+            }
+        }
+
+        return answer;
+    }
+
+    // Helper function to calculate the cost of a component using BFS
+    private int getComponentCost(
+        int node,
+        List<List<int[]>> adjList,
+        boolean[] visited,
+        int[] components,
+        int componentId
+    ) {
+        // Initialize the cost to the number that has only 1s in its
+        // binary representation
+        int currentCost = Integer.MAX_VALUE;
+
+        // Mark the node as part of the current component
+        components[node] = componentId;
+        visited[node] = true;
+
+        // Explore all neighbors of the current node
+        for (int[] neighbor : adjList.get(node)) {
+            int weight = neighbor[1];
+
+            // Update the cost by performing a bitwise AND of the edge
+            // weights
+            currentCost &= weight;
+
+            if (!visited[neighbor[0]]) {
+                // Recursively calculate the cost of the rest of the component
+                // and accumulate it into currentCost
+                currentCost &= getComponentCost(
+                    neighbor[0],
+                    adjList,
+                    visited,
+                    components,
+                    componentId
+                );
+            }
+        }
+
+        return currentCost;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3348-minimum-cost-walk-in-weighted-graph/README.md b/leetcode/leetcode/3348-minimum-cost-walk-in-weighted-graph/README.md
new file mode 100644
index 0000000..21a647d
--- /dev/null
+++ b/leetcode/leetcode/3348-minimum-cost-walk-in-weighted-graph/README.md
@@ -0,0 +1,54 @@
+<h2><a href="https://leetcode.com/problems/minimum-cost-walk-in-weighted-graph">3348. Minimum Cost Walk in Weighted Graph</a></h2><h3>Hard</h3><hr><p>There is an undirected weighted graph with <code>n</code> vertices labeled from <code>0</code> to <code>n - 1</code>.</p>
+
+<p>You are given the integer <code>n</code> and an array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> indicates that there is an edge between vertices <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> with a weight of <code>w<sub>i</sub></code>.</p>
+
+<p>A walk on a graph is a sequence of vertices and edges. The walk starts and ends with a vertex, and each edge connects the vertex that comes before it and the vertex that comes after it. It&#39;s important to note that a walk may visit the same edge or vertex more than once.</p>
+
+<p>The <strong>cost</strong> of a walk starting at node <code>u</code> and ending at node <code>v</code> is defined as the bitwise <code>AND</code> of the weights of the edges traversed during the walk. In other words, if the sequence of edge weights encountered during the walk is <code>w<sub>0</sub>, w<sub>1</sub>, w<sub>2</sub>, ..., w<sub>k</sub></code>, then the cost is calculated as <code>w<sub>0</sub> &amp; w<sub>1</sub> &amp; w<sub>2</sub> &amp; ... &amp; w<sub>k</sub></code>, where <code>&amp;</code> denotes the bitwise <code>AND</code> operator.</p>
+
+<p>You are also given a 2D array <code>query</code>, where <code>query[i] = [s<sub>i</sub>, t<sub>i</sub>]</code>. For each query, you need to find the minimum cost of the walk starting at vertex <code>s<sub>i</sub></code> and ending at vertex <code>t<sub>i</sub></code>. If there exists no such walk, the answer is <code>-1</code>.</p>
+
+<p>Return <em>the array </em><code>answer</code><em>, where </em><code>answer[i]</code><em> denotes the <strong>minimum</strong> cost of a walk for query </em><code>i</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 5, edges = [[0,1,7],[1,3,7],[1,2,1]], query = [[0,3],[3,4]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1,-1]</span></p>
+
+<p><strong>Explanation:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2024/01/31/q4_example1-1.png" style="padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; width: 351px; height: 141px;" />
+<p>To achieve the cost of 1 in the first query, we need to move on the following edges: <code>0-&gt;1</code> (weight 7), <code>1-&gt;2</code> (weight 1), <code>2-&gt;1</code> (weight 1), <code>1-&gt;3</code> (weight 7).</p>
+
+<p>In the second query, there is no walk between nodes 3 and 4, so the answer is -1.</p>
+
+<p><strong class="example">Example 2:</strong></p>
+</div>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 3, edges = [[0,2,7],[0,1,15],[1,2,6],[1,2,1]], query = [[1,2]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[0]</span></p>
+
+<p><strong>Explanation:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2024/01/31/q4_example2e.png" style="padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; width: 211px; height: 181px;" />
+<p>To achieve the cost of 0 in the first query, we need to move on the following edges: <code>1-&gt;2</code> (weight 1), <code>2-&gt;1</code> (weight 6), <code>1-&gt;2</code> (weight 1).</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= edges.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>edges[i].length == 3</code></li>
+	<li><code>0 &lt;= u<sub>i</sub>, v<sub>i</sub> &lt;= n - 1</code></li>
+	<li><code>u<sub>i</sub> != v<sub>i</sub></code></li>
+	<li><code>0 &lt;= w<sub>i</sub> &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= query.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>query[i].length == 2</code></li>
+	<li><code>0 &lt;= s<sub>i</sub>, t<sub>i</sub> &lt;= n - 1</code></li>
+	<li><code>s<sub>i</sub> !=&nbsp;t<sub>i</sub></code></li>
+</ul>
diff --git a/leetcode/leetcode/3372-longest-strictly-increasing-or-strictly-decreasing-subarray/3372-longest-strictly-increasing-or-strictly-decreasing-subarray.java b/leetcode/leetcode/3372-longest-strictly-increasing-or-strictly-decreasing-subarray/3372-longest-strictly-increasing-or-strictly-decreasing-subarray.java
new file mode 100644
index 0000000..17b46b5
--- /dev/null
+++ b/leetcode/leetcode/3372-longest-strictly-increasing-or-strictly-decreasing-subarray/3372-longest-strictly-increasing-or-strictly-decreasing-subarray.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int longestMonotonicSubarray(int[] arr) {
+        int min_till_now = 1;
+        int max_till_now = 1;
+        int curr_min_streak = 1;
+        int curr_max_streak = 1;
+        for(int i = 0;i<arr.length-1;i++){
+            if(arr[i]>arr[i+1]){
+                curr_min_streak++;
+                max_till_now = Math.max(curr_max_streak,max_till_now);
+                curr_max_streak = 1;
+            }else if(arr[i]<arr[i+1]){
+                curr_max_streak++;
+                min_till_now = Math.max(curr_min_streak,min_till_now);
+                curr_min_streak = 1;
+
+            }   
+            else{
+                max_till_now = Math.max(curr_max_streak,max_till_now);
+                min_till_now = Math.max(curr_min_streak,min_till_now);
+                curr_max_streak = 1;
+                curr_min_streak = 1;
+            }
+        }
+        max_till_now = Math.max(curr_max_streak,max_till_now);
+        min_till_now = Math.max(curr_min_streak,min_till_now);
+        return Math.max(max_till_now,min_till_now);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3372-longest-strictly-increasing-or-strictly-decreasing-subarray/README.md b/leetcode/leetcode/3372-longest-strictly-increasing-or-strictly-decreasing-subarray/README.md
new file mode 100644
index 0000000..4f38352
--- /dev/null
+++ b/leetcode/leetcode/3372-longest-strictly-increasing-or-strictly-decreasing-subarray/README.md
@@ -0,0 +1,58 @@
+<h2><a href="https://leetcode.com/problems/longest-strictly-increasing-or-strictly-decreasing-subarray">3372. Longest Strictly Increasing or Strictly Decreasing Subarray</a></h2><h3>Easy</h3><hr><p>You are given an array of integers <code>nums</code>. Return <em>the length of the <strong>longest</strong> <span data-keyword="subarray-nonempty">subarray</span> of </em><code>nums</code><em> which is either <strong><span data-keyword="strictly-increasing-array">strictly increasing</span></strong> or <strong><span data-keyword="strictly-decreasing-array">strictly decreasing</span></strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [1,4,3,3,2]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">2</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The strictly increasing subarrays of <code>nums</code> are <code>[1]</code>, <code>[2]</code>, <code>[3]</code>, <code>[3]</code>, <code>[4]</code>, and <code>[1,4]</code>.</p>
+
+<p>The strictly decreasing subarrays of <code>nums</code> are <code>[1]</code>, <code>[2]</code>, <code>[3]</code>, <code>[3]</code>, <code>[4]</code>, <code>[3,2]</code>, and <code>[4,3]</code>.</p>
+
+<p>Hence, we return <code>2</code>.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [3,3,3,3]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">1</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The strictly increasing subarrays of <code>nums</code> are <code>[3]</code>, <code>[3]</code>, <code>[3]</code>, and <code>[3]</code>.</p>
+
+<p>The strictly decreasing subarrays of <code>nums</code> are <code>[3]</code>, <code>[3]</code>, <code>[3]</code>, and <code>[3]</code>.</p>
+
+<p>Hence, we return <code>1</code>.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [3,2,1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">3</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The strictly increasing subarrays of <code>nums</code> are <code>[3]</code>, <code>[2]</code>, and <code>[1]</code>.</p>
+
+<p>The strictly decreasing subarrays of <code>nums</code> are <code>[3]</code>, <code>[2]</code>, <code>[1]</code>, <code>[3,2]</code>, <code>[2,1]</code>, and <code>[3,2,1]</code>.</p>
+
+<p>Hence, we return <code>3</code>.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 50</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 50</code></li>
+</ul>
diff --git a/leetcode/leetcode/338-counting-bits/338-counting-bits.java b/leetcode/leetcode/338-counting-bits/338-counting-bits.java
new file mode 100644
index 0000000..544564a
--- /dev/null
+++ b/leetcode/leetcode/338-counting-bits/338-counting-bits.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int[] countBits(int n) {
+        int[] res = new int[n+1];
+        res[0] = 0;
+        for(int i = 1;i<=n;i++){
+            if(i%2==0) res[i] = res[i/2];
+            else res[i] = res[i-1]+1;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/338-counting-bits/NOTES.md b/leetcode/leetcode/338-counting-bits/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/338-counting-bits/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/338-counting-bits/README.md b/leetcode/leetcode/338-counting-bits/README.md
new file mode 100644
index 0000000..dc7d81d
--- /dev/null
+++ b/leetcode/leetcode/338-counting-bits/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/counting-bits/">338. Counting Bits</a></h2><h3>Easy</h3><hr><div><p>Given an integer <code>n</code>, return <em>an array </em><code>ans</code><em> of length </em><code>n + 1</code><em> such that for each </em><code>i</code><em> </em>(<code>0 &lt;= i &lt;= n</code>)<em>, </em><code>ans[i]</code><em> is the <strong>number of </strong></em><code>1</code><em><strong>'s</strong> in the binary representation of </em><code>i</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> [0,1,1]
+<strong>Explanation:</strong>
+0 --&gt; 0
+1 --&gt; 1
+2 --&gt; 10
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> [0,1,1,2,1,2]
+<strong>Explanation:</strong>
+0 --&gt; 0
+1 --&gt; 1
+2 --&gt; 10
+3 --&gt; 11
+4 --&gt; 100
+5 --&gt; 101
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>It is very easy to come up with a solution with a runtime of <code>O(n log n)</code>. Can you do it in linear time <code>O(n)</code> and possibly in a single pass?</li>
+	<li>Can you do it without using any built-in function (i.e., like <code>__builtin_popcount</code> in C++)?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/3398-make-a-square-with-the-same-color/3398-make-a-square-with-the-same-color.java b/leetcode/leetcode/3398-make-a-square-with-the-same-color/3398-make-a-square-with-the-same-color.java
new file mode 100644
index 0000000..4c9a198
--- /dev/null
+++ b/leetcode/leetcode/3398-make-a-square-with-the-same-color/3398-make-a-square-with-the-same-color.java
@@ -0,0 +1,66 @@
+class Solution {
+    public boolean canMakeSquare(char[][] grid) {
+        byte countB = 0, countW = 0;
+
+        for (int i = 0; i <= 1; i++) {
+            for (int j = 0; j <= 1; j++) {
+                if (grid[i][j] == 'B') {
+                    countB++;
+                }else {
+                    countW++;
+                }
+            }
+            if (countB > 2 || countW > 2) {
+                return true;
+            }
+        }
+
+        countB = 0; countW = 0;
+
+        for (int i = 0; i <= 1; i++) {
+            for (int j = 1; j <= 2; j++) {
+                if (grid[i][j] == 'B') {
+                    countB++;
+                }else {
+                    countW++;
+                }
+            }
+            if (countB > 2 || countW > 2) {
+                return true;
+            }
+        }
+
+        countB = 0; countW = 0;
+
+        for (int i = 1; i <= 2; i++) {
+            for (int j = 0; j <= 1; j++) {
+                if (grid[i][j] == 'B') {
+                    countB++;
+                }else {
+                    countW++;
+                }
+            }
+            if (countB > 2 || countW > 2) {
+                return true;
+            }
+        }
+
+
+        countB = 0; countW = 0;
+
+        for (int i = 1; i <= 2; i++) {
+            for (int j = 1; j <= 2; j++) {
+                if (grid[i][j] == 'B') {
+                    countB++;
+                }else {
+                    countW++;
+                }
+            }
+            if (countB > 2 || countW > 2) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3398-make-a-square-with-the-same-color/README.md b/leetcode/leetcode/3398-make-a-square-with-the-same-color/README.md
new file mode 100644
index 0000000..bf5e00f
--- /dev/null
+++ b/leetcode/leetcode/3398-make-a-square-with-the-same-color/README.md
@@ -0,0 +1,129 @@
+<h2><a href="https://leetcode.com/problems/make-a-square-with-the-same-color">3398. Make a Square with the Same Color</a></h2><h3>Easy</h3><hr><p>You are given a 2D matrix <code>grid</code> of size <code>3 x 3</code> consisting only of characters <code>&#39;B&#39;</code> and <code>&#39;W&#39;</code>. Character <code>&#39;W&#39;</code> represents the white color<!-- notionvc: 06a49cc0-a296-4bd2-9bfe-c8818edeb53a -->, and character <code>&#39;B&#39;</code> represents the black color<!-- notionvc: 06a49cc0-a296-4bd2-9bfe-c8818edeb53a -->.</p>
+
+<p>Your task is to change the color of <strong>at most one</strong> cell<!-- notionvc: c04cb478-8dd5-49b1-80bb-727c6b1e0232 --> so that the matrix has a <code>2 x 2</code> square where all cells are of the same color.<!-- notionvc: adf957e1-fa0f-40e5-9a2e-933b95e276a7 --></p>
+
+<p>Return <code>true</code> if it is possible to create a <code>2 x 2</code> square of the same color, otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<style type="text/css">.grid-container {
+  display: grid;
+  grid-template-columns: 30px 30px 30px;
+  padding: 10px;
+}
+.grid-item {
+  background-color: black;
+  border: 1px solid gray;
+  height: 30px;
+  font-size: 30px;
+  text-align: center;
+}
+.grid-item-white {
+  background-color: white;
+}
+</style>
+<style class="darkreader darkreader--sync" media="screen" type="text/css">
+</style>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="grid-container">
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+</div>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">grid = [[&quot;B&quot;,&quot;W&quot;,&quot;B&quot;],[&quot;B&quot;,&quot;W&quot;,&quot;W&quot;],[&quot;B&quot;,&quot;W&quot;,&quot;B&quot;]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>It can be done by changing the color of the <code>grid[0][2]</code>.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="grid-container">
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+</div>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">grid = [[&quot;B&quot;,&quot;W&quot;,&quot;B&quot;],[&quot;W&quot;,&quot;B&quot;,&quot;W&quot;],[&quot;B&quot;,&quot;W&quot;,&quot;B&quot;]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">false</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>It cannot be done by changing at most one cell.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="grid-container">
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+
+<div class="grid-item grid-item-white">&nbsp;</div>
+</div>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">grid = [[&quot;B&quot;,&quot;W&quot;,&quot;B&quot;],[&quot;B&quot;,&quot;W&quot;,&quot;W&quot;],[&quot;B&quot;,&quot;W&quot;,&quot;W&quot;]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The <code>grid</code> already contains a <code>2 x 2</code> square of the same color.<!-- notionvc: 9a8b2d3d-1e73-457a-abe0-c16af51ad5c2 --></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>grid.length == 3</code></li>
+	<li><code>grid[i].length == 3</code></li>
+	<li><code>grid[i][j]</code> is either <code>&#39;W&#39;</code> or <code>&#39;B&#39;</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/34-find-first-and-last-position-of-element-in-sorted-array.java b/leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/34-find-first-and-last-position-of-element-in-sorted-array.java
new file mode 100644
index 0000000..3da9a28
--- /dev/null
+++ b/leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/34-find-first-and-last-position-of-element-in-sorted-array.java
@@ -0,0 +1,39 @@
+class Solution {
+    public int[] searchRange(int[] arr, int target) {
+        int[] res = {-1,-1};
+        if(arr.length<1) return res;
+        int low = 0;
+        int high = arr.length - 1;
+        int first = -1;
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(arr[mid] == target){
+                first = mid;
+                high = mid - 1;
+            }else if(arr[mid]>target){
+                high = mid - 1;
+            }else{
+                low = mid+1;
+            }
+        }
+        if(first == -1) return res;
+        int last = first;
+        low = first+1;
+        high = arr.length - 1;
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(arr[mid] == target){
+                last = mid;
+                low = mid+1;
+            }
+            else if(arr[mid]>target){
+                high = mid - 1;
+            }else{
+                low = mid+1;
+            }
+        }
+        res[0] = first;
+        res[1] = last;
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/NOTES.md b/leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/README.md b/leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/README.md
new file mode 100644
index 0000000..84af2cc
--- /dev/null
+++ b/leetcode/leetcode/34-find-first-and-last-position-of-element-in-sorted-array/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/">34. Find First and Last Position of Element in Sorted Array</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>nums</code> sorted in non-decreasing order, find the starting and ending position of a given <code>target</code> value.</p>
+
+<p>If <code>target</code> is not found in the array, return <code>[-1, -1]</code>.</p>
+
+<p>You must&nbsp;write an algorithm with&nbsp;<code>O(log n)</code> runtime complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [5,7,7,8,8,10], target = 8
+<strong>Output:</strong> [3,4]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [5,7,7,8,8,10], target = 6
+<strong>Output:</strong> [-1,-1]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [], target = 0
+<strong>Output:</strong> [-1,-1]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup>&nbsp;&lt;= nums[i]&nbsp;&lt;= 10<sup>9</sup></code></li>
+	<li><code>nums</code> is a non-decreasing array.</li>
+	<li><code>-10<sup>9</sup>&nbsp;&lt;= target&nbsp;&lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/3430-count-days-without-meetings/3430-count-days-without-meetings.java b/leetcode/leetcode/3430-count-days-without-meetings/3430-count-days-without-meetings.java
new file mode 100644
index 0000000..67a2ebf
--- /dev/null
+++ b/leetcode/leetcode/3430-count-days-without-meetings/3430-count-days-without-meetings.java
@@ -0,0 +1,18 @@
+class Solution {
+
+    public int countDays(int days, int[][] meetings) {
+        
+        // Sort meetings based on starting times
+        Arrays.sort(meetings, Comparator.comparingInt(a -> a[0]));
+        int lastDay = 0;
+        int totalMeetings = 0;
+        for(int i = 0;i<meetings.length;i++){
+            int temp      = meetings[i][1] - Math.max(meetings[i][0],lastDay) + 1;
+            totalMeetings += temp>0 ? temp: 0;
+            lastDay = Math.max(meetings[i][1]+1,lastDay);
+        }
+        return days-totalMeetings; 
+
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3430-count-days-without-meetings/README.md b/leetcode/leetcode/3430-count-days-without-meetings/README.md
new file mode 100644
index 0000000..b977410
--- /dev/null
+++ b/leetcode/leetcode/3430-count-days-without-meetings/README.md
@@ -0,0 +1,52 @@
+<h2><a href="https://leetcode.com/problems/count-days-without-meetings">3430. Count Days Without Meetings</a></h2><h3>Medium</h3><hr><p>You are given a positive integer <code>days</code> representing the total number of days an employee is available for work (starting from day 1). You are also given a 2D array <code>meetings</code> of size <code>n</code> where, <code>meetings[i] = [start_i, end_i]</code> represents the starting and ending days of meeting <code>i</code> (inclusive).</p>
+
+<p>Return the count of days when the employee is available for work but no meetings are scheduled.</p>
+
+<p><strong>Note: </strong>The meetings may overlap.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">days = 10, meetings = [[5,7],[1,3],[9,10]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">2</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>There is no meeting scheduled on the 4<sup>th</sup> and 8<sup>th</sup> days.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">days = 5, meetings = [[2,4],[1,3]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">1</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>There is no meeting scheduled on the 5<sup>th </sup>day.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">days = 6, meetings = [[1,6]]</span></p>
+
+<p><strong>Output:</strong> 0</p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>Meetings are scheduled for all working days.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= days &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= meetings.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>meetings[i].length == 2</code></li>
+	<li><code><font face="monospace">1 &lt;= meetings[i][0] &lt;= meetings[i][1] &lt;= days</font></code></li>
+</ul>
diff --git a/leetcode/leetcode/344-reverse-string/344-reverse-string.java b/leetcode/leetcode/344-reverse-string/344-reverse-string.java
new file mode 100644
index 0000000..18b720f
--- /dev/null
+++ b/leetcode/leetcode/344-reverse-string/344-reverse-string.java
@@ -0,0 +1,13 @@
+class Solution {
+    public void reverseString(char[] s) {
+        int low = 0;
+        int high = s.length - 1;
+        while(low<high){
+            Character temp = s[low];
+            s[low] = s[high];
+            s[high] = temp;
+            low++;
+            high--;
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/344-reverse-string/README.md b/leetcode/leetcode/344-reverse-string/README.md
new file mode 100644
index 0000000..15ad161
--- /dev/null
+++ b/leetcode/leetcode/344-reverse-string/README.md
@@ -0,0 +1,20 @@
+<h2><a href="https://leetcode.com/problems/reverse-string/">344. Reverse String</a></h2><h3>Easy</h3><hr><div><p>Write a function that reverses a string. The input string is given as an array of characters <code>s</code>.</p>
+
+<p>You must do this by modifying the input array <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> with <code>O(1)</code> extra memory.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = ["h","e","l","l","o"]
+<strong>Output:</strong> ["o","l","l","e","h"]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> s = ["H","a","n","n","a","h"]
+<strong>Output:</strong> ["h","a","n","n","a","H"]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s[i]</code> is a <a href="https://en.wikipedia.org/wiki/ASCII#Printable_characters" target="_blank">printable ascii character</a>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/3447-clear-digits/3447-clear-digits.java b/leetcode/leetcode/3447-clear-digits/3447-clear-digits.java
new file mode 100644
index 0000000..a74c306
--- /dev/null
+++ b/leetcode/leetcode/3447-clear-digits/3447-clear-digits.java
@@ -0,0 +1,13 @@
+class Solution {
+    public String clearDigits(String s) {
+        StringBuilder answer = new StringBuilder();
+        for(char c: s.toCharArray()){
+            if(Character.isDigit(c) && answer.length()!=0){
+                answer.setLength(answer.length()-1);
+            }else{
+                answer.append(c);
+            }
+        }
+        return answer.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3447-clear-digits/README.md b/leetcode/leetcode/3447-clear-digits/README.md
new file mode 100644
index 0000000..8642a98
--- /dev/null
+++ b/leetcode/leetcode/3447-clear-digits/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/clear-digits">3447. Clear Digits</a></h2><h3>Easy</h3><hr><p>You are given a string <code>s</code>.</p>
+
+<p>Your task is to remove <strong>all</strong> digits by doing this operation repeatedly:</p>
+
+<ul>
+	<li>Delete the <em>first</em> digit and the <strong>closest</strong> <b>non-digit</b> character to its <em>left</em>.</li>
+</ul>
+
+<p>Return the resulting string after removing all digits.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s = &quot;abc&quot;</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">&quot;abc&quot;</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>There is no digit in the string.<!-- notionvc: ff07e34f-b1d6-41fb-9f83-5d0ba3c1ecde --></p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">s = &quot;cb34&quot;</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">&quot;&quot;</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>First, we apply the operation on <code>s[2]</code>, and <code>s</code> becomes <code>&quot;c4&quot;</code>.</p>
+
+<p>Then we apply the operation on <code>s[1]</code>, and <code>s</code> becomes <code>&quot;&quot;</code>.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 100</code></li>
+	<li><code>s</code> consists only of lowercase English letters and digits.</li>
+	<li>The input is generated such that it is possible to delete all digits.</li>
+</ul>
diff --git a/leetcode/leetcode/347-top-k-frequent-elements/347-top-k-frequent-elements.java b/leetcode/leetcode/347-top-k-frequent-elements/347-top-k-frequent-elements.java
new file mode 100644
index 0000000..a39988d
--- /dev/null
+++ b/leetcode/leetcode/347-top-k-frequent-elements/347-top-k-frequent-elements.java
@@ -0,0 +1,27 @@
+class Solution {
+    class pair implements Comparable<pair>{
+        int value;
+        int count;
+        pair(int value, int count){
+            this.value = value;
+            this.count = count;
+        }
+        public int compareTo(pair p){
+            return this.count - p.count;
+        }
+    }
+    public int[] topKFrequent(int[] nums, int k) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: nums) map.put(num,map.getOrDefault(num,0)+1);
+        PriorityQueue<pair> pq = new PriorityQueue<>();
+        for (Map.Entry mapElement : map.entrySet()) {
+            pq.add(new pair((int) mapElement.getKey(),(int) mapElement.getValue()));
+            if(pq.size()>k) pq.remove();
+        }
+        int[] res = new int[k];
+        for(int i =0;i<k;i++){
+            res[i] = pq.remove().value;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/347-top-k-frequent-elements/NOTES.md b/leetcode/leetcode/347-top-k-frequent-elements/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/347-top-k-frequent-elements/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/347-top-k-frequent-elements/README.md b/leetcode/leetcode/347-top-k-frequent-elements/README.md
new file mode 100644
index 0000000..8ae3d88
--- /dev/null
+++ b/leetcode/leetcode/347-top-k-frequent-elements/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/top-k-frequent-elements/">347. Top K Frequent Elements</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <em>the</em> <code>k</code> <em>most frequent elements</em>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,1,2,2,3], k = 2
+<strong>Output:</strong> [1,2]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1], k = 1
+<strong>Output:</strong> [1]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>k</code> is in the range <code>[1, the number of unique elements in the array]</code>.</li>
+	<li>It is <strong>guaranteed</strong> that the answer is <strong>unique</strong>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Your algorithm's time complexity must be better than <code>O(n log n)</code>, where n is the array's size.</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i.java b/leetcode/leetcode/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i.java
new file mode 100644
index 0000000..adc7c8b
--- /dev/null
+++ b/leetcode/leetcode/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i.java
@@ -0,0 +1,18 @@
+class Solution {
+
+    public int minOperations(int[] nums) {
+        int count = 0;
+        for (int i = 2; i < nums.length; i++) {
+            if (nums[i - 2] == 0) {
+                count++;
+                nums[i - 2] = nums[i - 2] ^ 1;
+                nums[i - 1] = nums[i - 1] ^ 1;
+                nums[i] = nums[i] ^ 1;
+            }
+        }
+        int sum = 0;
+        for (int num : nums) sum += num;
+        if (sum == nums.length) return count;
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i/README.md b/leetcode/leetcode/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i/README.md
new file mode 100644
index 0000000..739142b
--- /dev/null
+++ b/leetcode/leetcode/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/minimum-operations-to-make-binary-array-elements-equal-to-one-i">3475. Minimum Operations to Make Binary Array Elements Equal to One I</a></h2><h3>Medium</h3><hr><p>You are given a <span data-keyword="binary-array">binary array</span> <code>nums</code>.</p>
+
+<p>You can do the following operation on the array <strong>any</strong> number of times (possibly zero):</p>
+
+<ul>
+	<li>Choose <strong>any</strong> 3 <strong>consecutive</strong> elements from the array and <strong>flip</strong> <strong>all</strong> of them.</li>
+</ul>
+
+<p><strong>Flipping</strong> an element means changing its value from 0 to 1, and from 1 to 0.</p>
+
+<p>Return the <strong>minimum</strong> number of operations required to make all elements in <code>nums</code> equal to 1. If it is impossible, return -1.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [0,1,1,1,0,0]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">3</span></p>
+
+<p><strong>Explanation:</strong><br />
+We can do the following operations:</p>
+
+<ul>
+	<li>Choose the elements at indices 0, 1 and 2. The resulting array is <code>nums = [<u><strong>1</strong></u>,<u><strong>0</strong></u>,<u><strong>0</strong></u>,1,0,0]</code>.</li>
+	<li>Choose the elements at indices 1, 2 and 3. The resulting array is <code>nums = [1,<u><strong>1</strong></u>,<u><strong>1</strong></u>,<strong><u>0</u></strong>,0,0]</code>.</li>
+	<li>Choose the elements at indices 3, 4 and 5. The resulting array is <code>nums = [1,1,1,<strong><u>1</u></strong>,<u><strong>1</strong></u>,<u><strong>1</strong></u>]</code>.</li>
+</ul>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [0,1,1,1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">-1</span></p>
+
+<p><strong>Explanation:</strong><br />
+It is impossible to make all elements equal to 1.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 1</code></li>
+</ul>
diff --git a/leetcode/leetcode/3483-alternating-groups-ii/3483-alternating-groups-ii.java b/leetcode/leetcode/3483-alternating-groups-ii/3483-alternating-groups-ii.java
new file mode 100644
index 0000000..5797077
--- /dev/null
+++ b/leetcode/leetcode/3483-alternating-groups-ii/3483-alternating-groups-ii.java
@@ -0,0 +1,35 @@
+class Solution {
+
+    public int numberOfAlternatingGroups(int[] colors, int k) {
+        int length = colors.length;
+        int result = 0;
+        // Length of current alternating sequence
+        int alternatingElementsCount = 1;
+        int lastColor = colors[0];
+
+        // Loop through array with circular traversal
+        for (int i = 1; i < length + k - 1; i++) {
+            int index = i % length; // Wrap around using modulo
+
+            // Check if current color is the same as last color
+            if (colors[index] == lastColor) {
+                // Pattern breaks, reset sequence length
+                alternatingElementsCount = 1;
+                lastColor = colors[index];
+                continue;
+            }
+
+            // Extend alternating sequence
+            alternatingElementsCount += 1;
+
+            // If sequence length reaches at least k, count it
+            if (alternatingElementsCount >= k) {
+                result++;
+            }
+
+            lastColor = colors[index];
+        }
+
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3483-alternating-groups-ii/README.md b/leetcode/leetcode/3483-alternating-groups-ii/README.md
new file mode 100644
index 0000000..cbc5260
--- /dev/null
+++ b/leetcode/leetcode/3483-alternating-groups-ii/README.md
@@ -0,0 +1,66 @@
+<h2><a href="https://leetcode.com/problems/alternating-groups-ii">3483. Alternating Groups II</a></h2><h3>Medium</h3><hr><p>There is a circle of red and blue tiles. You are given an array of integers <code>colors</code> and an integer <code>k</code>. The color of tile <code>i</code> is represented by <code>colors[i]</code>:</p>
+
+<ul>
+	<li><code>colors[i] == 0</code> means that tile <code>i</code> is <strong>red</strong>.</li>
+	<li><code>colors[i] == 1</code> means that tile <code>i</code> is <strong>blue</strong>.</li>
+</ul>
+
+<p>An <strong>alternating</strong> group is every <code>k</code> contiguous tiles in the circle with <strong>alternating</strong> colors (each tile in the group except the first and last one has a different color from its <strong>left</strong> and <strong>right</strong> tiles).</p>
+
+<p>Return the number of <strong>alternating</strong> groups.</p>
+
+<p><strong>Note</strong> that since <code>colors</code> represents a <strong>circle</strong>, the <strong>first</strong> and the <strong>last</strong> tiles are considered to be next to each other.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">colors = [0,1,0,1,0], k = 3</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">3</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><strong><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-183519.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /></strong></p>
+
+<p>Alternating groups:</p>
+
+<p><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/05/28/screenshot-2024-05-28-182448.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/05/28/screenshot-2024-05-28-182844.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/05/28/screenshot-2024-05-28-183057.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /></p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">colors = [0,1,0,0,1,0,1], k = 6</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">2</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><strong><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-183907.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /></strong></p>
+
+<p>Alternating groups:</p>
+
+<p><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-184128.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-184240.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /></p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">colors = [1,1,0,1], k = 4</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">0</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-184516.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /></p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= colors.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= colors[i] &lt;= 1</code></li>
+	<li><code>3 &lt;= k &lt;= colors.length</code></li>
+</ul>
diff --git a/leetcode/leetcode/350-intersection-of-two-arrays-ii/350-intersection-of-two-arrays-ii.java b/leetcode/leetcode/350-intersection-of-two-arrays-ii/350-intersection-of-two-arrays-ii.java
new file mode 100644
index 0000000..e2f5890
--- /dev/null
+++ b/leetcode/leetcode/350-intersection-of-two-arrays-ii/350-intersection-of-two-arrays-ii.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int[] intersect(int[] nums1, int[] nums2) {
+        int[] freq = new int[1001];
+        for(int num: nums1){
+            freq[num]++;
+        }
+        List<Integer> list = new ArrayList<>();
+        for(int num: nums2){
+            if(freq[num]!=0){
+                list.add(num);
+                freq[num]--;
+            }
+        }
+        int[] result =new int[list.size()];
+        for(int i = 0;i<list.size();i++) result[i] = list.get(i);
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/350-intersection-of-two-arrays-ii/NOTES.md b/leetcode/leetcode/350-intersection-of-two-arrays-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/350-intersection-of-two-arrays-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/350-intersection-of-two-arrays-ii/README.md b/leetcode/leetcode/350-intersection-of-two-arrays-ii/README.md
new file mode 100644
index 0000000..a7bf437
--- /dev/null
+++ b/leetcode/leetcode/350-intersection-of-two-arrays-ii/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/intersection-of-two-arrays-ii/">350. Intersection of Two Arrays II</a></h2><h3>Easy</h3><hr><div><p>Given two integer arrays <code>nums1</code> and <code>nums2</code>, return <em>an array of their intersection</em>. Each element in the result must appear as many times as it shows in both arrays and you may return the result in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2,2,1], nums2 = [2,2]
+<strong>Output:</strong> [2,2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+<strong>Output:</strong> [4,9]
+<strong>Explanation:</strong> [9,4] is also accepted.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums1.length, nums2.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums1[i], nums2[i] &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>What if the given array is already sorted? How would you optimize your algorithm?</li>
+	<li>What if <code>nums1</code>'s size is small compared to <code>nums2</code>'s size? Which algorithm is better?</li>
+	<li>What if elements of <code>nums2</code> are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/3501-delete-nodes-from-linked-list-present-in-array/3501-delete-nodes-from-linked-list-present-in-array.java b/leetcode/leetcode/3501-delete-nodes-from-linked-list-present-in-array/3501-delete-nodes-from-linked-list-present-in-array.java
new file mode 100644
index 0000000..7d23401
--- /dev/null
+++ b/leetcode/leetcode/3501-delete-nodes-from-linked-list-present-in-array/3501-delete-nodes-from-linked-list-present-in-array.java
@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode helper(boolean[] freq, ListNode head){
+        if(head == null) return head;
+        if(head.val<freq.length && freq[head.val]) return helper(freq, head.next);
+        head.next = helper(freq, head.next);
+        return head;
+    }
+    public ListNode modifiedList(int[] nums, ListNode head) {
+        HashSet<Integer> set = new HashSet<>();
+        int max = -1;
+        for (int num : nums) {
+            max = Math.max(max, num);
+        }
+
+        // Create a boolean lookup table
+        boolean[] freq = new boolean[max + 1];
+        for (int num : nums) freq[num] = true;
+        return helper(freq, head);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3501-delete-nodes-from-linked-list-present-in-array/README.md b/leetcode/leetcode/3501-delete-nodes-from-linked-list-present-in-array/README.md
new file mode 100644
index 0000000..666c4fd
--- /dev/null
+++ b/leetcode/leetcode/3501-delete-nodes-from-linked-list-present-in-array/README.md
@@ -0,0 +1,56 @@
+<h2><a href="https://leetcode.com/problems/delete-nodes-from-linked-list-present-in-array">3501. Delete Nodes From Linked List Present in Array</a></h2><h3>Medium</h3><hr><p>You are given an array of integers <code>nums</code> and the <code>head</code> of a linked list. Return the <code>head</code> of the modified linked list after <strong>removing</strong> all nodes from the linked list that have a value that exists in <code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [1,2,3], head = [1,2,3,4,5]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[4,5]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2024/06/11/linkedlistexample0.png" style="width: 400px; height: 66px;" /></strong></p>
+
+<p>Remove the nodes with values 1, 2, and 3.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [1], head = [1,2,1,2,1,2]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[2,2,2]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/11/linkedlistexample1.png" style="height: 62px; width: 450px;" /></p>
+
+<p>Remove the nodes with value 1.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [5], head = [1,2,3,4]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">[1,2,3,4]</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2024/06/11/linkedlistexample2.png" style="width: 400px; height: 83px;" /></strong></p>
+
+<p>No node has value 5.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+	<li>All elements in <code>nums</code> are unique.</li>
+	<li>The number of nodes in the given list is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li>The input is generated such that there is at least one node in the linked list that has a value not present in <code>nums</code>.</li>
+</ul>
diff --git a/leetcode/leetcode/3541-report-spam-message/3541-report-spam-message.java b/leetcode/leetcode/3541-report-spam-message/3541-report-spam-message.java
new file mode 100644
index 0000000..4959f12
--- /dev/null
+++ b/leetcode/leetcode/3541-report-spam-message/3541-report-spam-message.java
@@ -0,0 +1,13 @@
+class Solution {
+    public boolean reportSpam(String[] message, String[] bannedWords) {
+        HashSet<String> set = new HashSet<>();
+        for(String word: bannedWords) set.add(word);
+
+        int count = 0;
+        for(String word: message){
+            if(count == 2) break;
+            else if(set.contains(word)) count++;
+        }
+        return count == 2;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3541-report-spam-message/README.md b/leetcode/leetcode/3541-report-spam-message/README.md
new file mode 100644
index 0000000..a7b30cb
--- /dev/null
+++ b/leetcode/leetcode/3541-report-spam-message/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/report-spam-message">3541. Report Spam Message</a></h2><h3>Medium</h3><hr><p>You are given an array of strings <code>message</code> and an array of strings <code>bannedWords</code>.</p>
+
+<p>An array of words is considered <strong>spam</strong> if there are <strong>at least</strong> two words in it that <b>exactly</b> match any word in <code>bannedWords</code>.</p>
+
+<p>Return <code>true</code> if the array <code>message</code> is spam, and <code>false</code> otherwise.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">message = [&quot;hello&quot;,&quot;world&quot;,&quot;leetcode&quot;], bannedWords = [&quot;world&quot;,&quot;hello&quot;]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The words <code>&quot;hello&quot;</code> and <code>&quot;world&quot;</code> from the <code>message</code> array both appear in the <code>bannedWords</code> array.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">message = [&quot;hello&quot;,&quot;programming&quot;,&quot;fun&quot;], bannedWords = [&quot;world&quot;,&quot;programming&quot;,&quot;leetcode&quot;]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">false</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>Only one word from the <code>message</code> array (<code>&quot;programming&quot;</code>) appears in the <code>bannedWords</code> array.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= message.length, bannedWords.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= message[i].length, bannedWords[i].length &lt;= 15</code></li>
+	<li><code>message[i]</code> and <code>bannedWords[i]</code> consist only of lowercase English letters.</li>
+</ul>
diff --git a/leetcode/leetcode/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii.java b/leetcode/leetcode/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii.java
new file mode 100644
index 0000000..9fef354
--- /dev/null
+++ b/leetcode/leetcode/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii.java
@@ -0,0 +1,57 @@
+class Solution {
+
+    public long countOfSubstrings(String word, int k) {
+        return atLeastK(word, k) - atLeastK(word, k + 1);
+    }
+
+    private long atLeastK(String word, int k) {
+        long numValidSubstrings = 0;
+        int start = 0;
+        int end = 0;
+        // keep track of counts of vowels and consonants
+        HashMap<Character, Integer> vowelCount = new HashMap<>();
+        int consonantCount = 0;
+
+        // start sliding window
+        while (end < word.length()) {
+            // insert new letter
+            char newLetter = word.charAt(end);
+
+            // update counts
+            if (isVowel(newLetter)) {
+                vowelCount.put(
+                    newLetter,
+                    vowelCount.getOrDefault(newLetter, 0) + 1
+                );
+            } else {
+                consonantCount++;
+            }
+
+            // shrink window while we have a valid substring
+            while (vowelCount.size() == 5 && consonantCount >= k) {
+                numValidSubstrings += word.length() - end;
+                char startLetter = word.charAt(start);
+                if (isVowel(startLetter)) {
+                    vowelCount.put(
+                        startLetter,
+                        vowelCount.get(startLetter) - 1
+                    );
+                    if (vowelCount.get(startLetter) == 0) {
+                        vowelCount.remove(startLetter);
+                    }
+                } else {
+                    consonantCount--;
+                }
+                start++;
+            }
+
+            end++;
+        }
+
+        return numValidSubstrings;
+    }
+
+    private boolean isVowel(char c) {
+        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii/README.md b/leetcode/leetcode/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii/README.md
new file mode 100644
index 0000000..02c591a
--- /dev/null
+++ b/leetcode/leetcode/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii/README.md
@@ -0,0 +1,55 @@
+<h2><a href="https://leetcode.com/problems/count-of-substrings-containing-every-vowel-and-k-consonants-ii">3569. Count of Substrings Containing Every Vowel and K Consonants II</a></h2><h3>Medium</h3><hr><p>You are given a string <code>word</code> and a <strong>non-negative</strong> integer <code>k</code>.</p>
+
+<p>Return the total number of <span data-keyword="substring-nonempty">substrings</span> of <code>word</code> that contain every vowel (<code>&#39;a&#39;</code>, <code>&#39;e&#39;</code>, <code>&#39;i&#39;</code>, <code>&#39;o&#39;</code>, and <code>&#39;u&#39;</code>) <strong>at least</strong> once and <strong>exactly</strong> <code>k</code> consonants.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">word = &quot;aeioqq&quot;, k = 1</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">0</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>There is no substring with every vowel.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">word = &quot;aeiou&quot;, k = 0</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">1</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The only substring with every vowel and zero consonants is <code>word[0..4]</code>, which is <code>&quot;aeiou&quot;</code>.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">word = &quot;</span>ieaouqqieaouqq<span class="example-io">&quot;, k = 1</span></p>
+
+<p><strong>Output:</strong> 3</p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The substrings with every vowel and one consonant are:</p>
+
+<ul>
+	<li><code>word[0..5]</code>, which is <code>&quot;ieaouq&quot;</code>.</li>
+	<li><code>word[6..11]</code>, which is <code>&quot;qieaou&quot;</code>.</li>
+	<li><code>word[7..12]</code>, which is <code>&quot;ieaouq&quot;</code>.</li>
+</ul>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>5 &lt;= word.length &lt;= 2 * 10<sup>5</sup></code></li>
+	<li><code>word</code> consists only of lowercase English letters.</li>
+	<li><code>0 &lt;= k &lt;= word.length - 5</code></li>
+</ul>
diff --git a/leetcode/leetcode/36-valid-sudoku/36-valid-sudoku.java b/leetcode/leetcode/36-valid-sudoku/36-valid-sudoku.java
new file mode 100644
index 0000000..a17617a
--- /dev/null
+++ b/leetcode/leetcode/36-valid-sudoku/36-valid-sudoku.java
@@ -0,0 +1,14 @@
+class Solution {
+    public boolean isValidSudoku(char[][] board) {
+        HashSet<String> s = new HashSet<>();
+        for(int row = 0;row<9;row++){
+            for(int col = 0;col<9;col++){
+                if(board[row][col]!='.'){
+                    if(!s.add("R" + row + board[row][col]) || !s.add("C" + col + board[row][col])) return false;
+                    if(!s.add("B" + ((row/3)*3 + (col/3)) +board[row][col])) return false;
+                }
+            }
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/36-valid-sudoku/NOTES.md b/leetcode/leetcode/36-valid-sudoku/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/36-valid-sudoku/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/36-valid-sudoku/README.md b/leetcode/leetcode/36-valid-sudoku/README.md
new file mode 100644
index 0000000..0a925bb
--- /dev/null
+++ b/leetcode/leetcode/36-valid-sudoku/README.md
@@ -0,0 +1,56 @@
+<h2><a href="https://leetcode.com/problems/valid-sudoku/">36. Valid Sudoku</a></h2><h3>Medium</h3><hr><div><p>Determine if a&nbsp;<code>9 x 9</code> Sudoku board&nbsp;is valid.&nbsp;Only the filled cells need to be validated&nbsp;<strong>according to the following rules</strong>:</p>
+
+<ol>
+	<li>Each row&nbsp;must contain the&nbsp;digits&nbsp;<code>1-9</code> without repetition.</li>
+	<li>Each column must contain the digits&nbsp;<code>1-9</code>&nbsp;without repetition.</li>
+	<li>Each of the nine&nbsp;<code>3 x 3</code> sub-boxes of the grid must contain the digits&nbsp;<code>1-9</code>&nbsp;without repetition.</li>
+</ol>
+
+<p><strong>Note:</strong></p>
+
+<ul>
+	<li>A Sudoku board (partially filled) could be valid but is not necessarily solvable.</li>
+	<li>Only the filled cells need to be validated according to the mentioned&nbsp;rules.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Sudoku-by-L2G-20050714.svg/250px-Sudoku-by-L2G-20050714.svg.png" style="height:250px; width:250px">
+<pre><strong>Input:</strong> 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"]]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> board = 
+[["8","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"]]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Same as Example 1, except with the <strong>5</strong> in the top left corner being modified to <strong>8</strong>. Since there are two 8's in the top left 3x3 sub-box, it is invalid.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>board.length == 9</code></li>
+	<li><code>board[i].length == 9</code></li>
+	<li><code>board[i][j]</code> is a digit <code>1-9</code> or <code>'.'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/3643-zero-array-transformation-ii/3643-zero-array-transformation-ii.java b/leetcode/leetcode/3643-zero-array-transformation-ii/3643-zero-array-transformation-ii.java
new file mode 100644
index 0000000..302f7e3
--- /dev/null
+++ b/leetcode/leetcode/3643-zero-array-transformation-ii/3643-zero-array-transformation-ii.java
@@ -0,0 +1,31 @@
+class Solution {
+
+    public int minZeroArray(int[] nums, int[][] queries) {
+        int n = nums.length, sum = 0, k = 0;
+        int[] differenceArray = new int[n + 1];
+
+        // Iterate through nums
+        for (int index = 0; index < n; index++) {
+            // Iterate through queries while current index of nums cannot equal zero
+            while (sum + differenceArray[index] < nums[index]) {
+                k++;
+
+                // Zero array isn't formed after all queries are processed
+                if (k > queries.length) {
+                    return -1;
+                }
+                int left = queries[k - 1][0], right = queries[k - 1][1], val =
+                    queries[k - 1][2];
+
+                // Process start and end of range
+                if (right >= index) {
+                    differenceArray[Math.max(left, index)] += val;
+                    differenceArray[right + 1] -= val;
+                }
+            }
+            // Update prefix sum at current index
+            sum += differenceArray[index];
+        }
+        return k;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3643-zero-array-transformation-ii/README.md b/leetcode/leetcode/3643-zero-array-transformation-ii/README.md
new file mode 100644
index 0000000..fd36c49
--- /dev/null
+++ b/leetcode/leetcode/3643-zero-array-transformation-ii/README.md
@@ -0,0 +1,77 @@
+<h2><a href="https://leetcode.com/problems/zero-array-transformation-ii">3643. Zero Array Transformation II</a></h2><h3>Medium</h3><hr><p>You are given an integer array <code>nums</code> of length <code>n</code> and a 2D array <code>queries</code> where <code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>, val<sub>i</sub>]</code>.</p>
+
+<p>Each <code>queries[i]</code> represents the following action on <code>nums</code>:</p>
+
+<ul>
+	<li>Decrement the value at each index in the range <code>[l<sub>i</sub>, r<sub>i</sub>]</code> in <code>nums</code> by <strong>at most</strong> <code>val<sub>i</sub></code>.</li>
+	<li>The amount by which each value is decremented<!-- notionvc: b232c9d9-a32d-448c-85b8-b637de593c11 --> can be chosen <strong>independently</strong> for each index.</li>
+</ul>
+
+<p>A <strong>Zero Array</strong> is an array with all its elements equal to 0.</p>
+
+<p>Return the <strong>minimum</strong> possible <strong>non-negative</strong> value of <code>k</code>, such that after processing the first <code>k</code> queries in <strong>sequence</strong>, <code>nums</code> becomes a <strong>Zero Array</strong>. If no such <code>k</code> exists, return -1.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [2,0,2], queries = [[0,2,1],[0,2,1],[1,1,3]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">2</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<ul>
+	<li><strong>For i = 0 (l = 0, r = 2, val = 1):</strong>
+
+	<ul>
+		<li>Decrement values at indices <code>[0, 1, 2]</code> by <code>[1, 0, 1]</code> respectively.</li>
+		<li>The array will become <code>[1, 0, 1]</code>.</li>
+	</ul>
+	</li>
+	<li><strong>For i = 1 (l = 0, r = 2, val = 1):</strong>
+	<ul>
+		<li>Decrement values at indices <code>[0, 1, 2]</code> by <code>[1, 0, 1]</code> respectively.</li>
+		<li>The array will become <code>[0, 0, 0]</code>, which is a Zero Array. Therefore, the minimum value of <code>k</code> is 2.</li>
+	</ul>
+	</li>
+</ul>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [4,3,2,1], queries = [[1,3,2],[0,2,1]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">-1</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<ul>
+	<li><strong>For i = 0 (l = 1, r = 3, val = 2):</strong>
+
+	<ul>
+		<li>Decrement values at indices <code>[1, 2, 3]</code> by <code>[2, 2, 1]</code> respectively.</li>
+		<li>The array will become <code>[4, 1, 0, 0]</code>.</li>
+	</ul>
+	</li>
+	<li><strong>For i = 1 (l = 0, r = 2, val<span style="font-size: 13.3333px;"> </span>= 1):</strong>
+	<ul>
+		<li>Decrement values at indices <code>[0, 1, 2]</code> by <code>[1, 1, 0]</code> respectively.</li>
+		<li>The array will become <code>[3, 0, 0, 0]</code>, which is not a Zero Array.</li>
+	</ul>
+	</li>
+</ul>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 5 * 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= queries.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>queries[i].length == 3</code></li>
+	<li><code>0 &lt;= l<sub>i</sub> &lt;= r<sub>i</sub> &lt; nums.length</code></li>
+	<li><code>1 &lt;= val<sub>i</sub> &lt;= 5</code></li>
+</ul>
diff --git a/leetcode/leetcode/3657-check-if-grid-can-be-cut-into-sections/3657-check-if-grid-can-be-cut-into-sections.java b/leetcode/leetcode/3657-check-if-grid-can-be-cut-into-sections/3657-check-if-grid-can-be-cut-into-sections.java
new file mode 100644
index 0000000..36229e4
--- /dev/null
+++ b/leetcode/leetcode/3657-check-if-grid-can-be-cut-into-sections/3657-check-if-grid-can-be-cut-into-sections.java
@@ -0,0 +1,34 @@
+class Solution {
+
+    public boolean checkValidCuts(int n, int[][] rectangles) {
+        // Try both horizontal and vertical cuts
+        return checkCuts(rectangles, 0) || checkCuts(rectangles, 1);
+    }
+
+    // Check if valid cuts can be made in a specific dimension
+    private boolean checkCuts(int[][] rectangles, int dim) {
+        int gapCount = 0;
+
+        // Sort rectangles by their starting coordinate in the given dimension
+        Arrays.sort(rectangles, (a, b) -> Integer.compare(a[dim], b[dim]));
+
+        // Track the furthest ending coordinate seen so far
+        int furthestEnd = rectangles[0][dim + 2];
+
+        for (int i = 1; i < rectangles.length; i++) {
+            int[] rect = rectangles[i];
+
+            // If current rectangle starts after the furthest end we've seen,
+            // we found a gap where a cut can be made
+            if (furthestEnd <= rect[dim]) {
+                gapCount++;
+            }
+
+            // Update the furthest ending coordinate
+            furthestEnd = Math.max(furthestEnd, rect[dim + 2]);
+        }
+
+        // We need at least 2 gaps to create 3 sections
+        return gapCount >= 2;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/3657-check-if-grid-can-be-cut-into-sections/README.md b/leetcode/leetcode/3657-check-if-grid-can-be-cut-into-sections/README.md
new file mode 100644
index 0000000..c14d99f
--- /dev/null
+++ b/leetcode/leetcode/3657-check-if-grid-can-be-cut-into-sections/README.md
@@ -0,0 +1,67 @@
+<h2><a href="https://leetcode.com/problems/check-if-grid-can-be-cut-into-sections">3657. Check if Grid can be Cut into Sections</a></h2><h3>Medium</h3><hr><p>You are given an integer <code>n</code> representing the dimensions of an <code>n x n</code><!-- notionvc: fa9fe4ed-dff8-4410-8196-346f2d430795 --> grid, with the origin at the bottom-left corner of the grid. You are also given a 2D array of coordinates <code>rectangles</code>, where <code>rectangles[i]</code> is in the form <code>[start<sub>x</sub>, start<sub>y</sub>, end<sub>x</sub>, end<sub>y</sub>]</code>, representing a rectangle on the grid. Each rectangle is defined as follows:</p>
+
+<ul>
+	<li><code>(start<sub>x</sub>, start<sub>y</sub>)</code>: The bottom-left corner of the rectangle.</li>
+	<li><code>(end<sub>x</sub>, end<sub>y</sub>)</code>: The top-right corner of the rectangle.</li>
+</ul>
+
+<p><strong>Note </strong>that the rectangles do not overlap. Your task is to determine if it is possible to make <strong>either two horizontal or two vertical cuts</strong> on the grid such that:</p>
+
+<ul>
+	<li>Each of the three resulting sections formed by the cuts contains <strong>at least</strong> one rectangle.</li>
+	<li>Every rectangle belongs to <strong>exactly</strong> one section.</li>
+</ul>
+
+<p>Return <code>true</code> if such cuts can be made; otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 5, rectangles = [[1,0,5,2],[0,2,2,4],[3,2,5,3],[0,4,4,5]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/10/23/tt1drawio.png" style="width: 285px; height: 280px;" /></p>
+
+<p>The grid is shown in the diagram. We can make horizontal cuts at <code>y = 2</code> and <code>y = 4</code>. Hence, output is true.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 4, rectangles = [[0,0,1,1],[2,0,3,4],[0,2,2,3],[3,0,4,3]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">true</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2024/10/23/tc2drawio.png" style="width: 240px; height: 240px;" /></p>
+
+<p>We can make vertical cuts at <code>x = 2</code> and <code>x = 3</code>. Hence, output is true.</p>
+</div>
+
+<p><strong class="example">Example 3:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 4, rectangles = [[0,2,2,4],[1,0,3,2],[2,2,3,4],[3,0,4,2],[3,2,4,4]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">false</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>We cannot make two horizontal or two vertical cuts that satisfy the conditions. Hence, output is false.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= n &lt;= 10<sup>9</sup></code></li>
+	<li><code>3 &lt;= rectangles.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= rectangles[i][0] &lt; rectangles[i][2] &lt;= n</code></li>
+	<li><code>0 &lt;= rectangles[i][1] &lt; rectangles[i][3] &lt;= n</code></li>
+	<li>No two rectangles overlap.</li>
+</ul>
diff --git a/leetcode/leetcode/3685-count-subarrays-of-length-three-with-a-condition/README.md b/leetcode/leetcode/3685-count-subarrays-of-length-three-with-a-condition/README.md
new file mode 100644
index 0000000..e421bbd
--- /dev/null
+++ b/leetcode/leetcode/3685-count-subarrays-of-length-three-with-a-condition/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/count-subarrays-of-length-three-with-a-condition">3685. Count Subarrays of Length Three With a Condition</a></h2><h3>Easy</h3><hr><p>Given an integer array <code>nums</code>, return the number of <span data-keyword="subarray-nonempty">subarrays</span> of length 3 such that the sum of the first and third numbers equals <em>exactly</em> half of the second number.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [1,2,1,4,1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">1</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>Only the subarray <code>[1,4,1]</code> contains exactly 3 elements where the sum of the first and third numbers equals half the middle number.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">nums = [1,1,1]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">0</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p><code>[1,1,1]</code> is the only subarray of length 3. However, its first and third numbers do not add to half the middle number.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= nums.length &lt;= 100</code></li>
+	<li><code><font face="monospace">-100 &lt;= nums[i] &lt;= 100</font></code></li>
+</ul>
diff --git a/leetcode/leetcode/371-sum-of-two-integers/371-sum-of-two-integers.java b/leetcode/leetcode/371-sum-of-two-integers/371-sum-of-two-integers.java
new file mode 100644
index 0000000..08cd5b9
--- /dev/null
+++ b/leetcode/leetcode/371-sum-of-two-integers/371-sum-of-two-integers.java
@@ -0,0 +1,7 @@
+class Solution {
+    public int getSum(int a, int b) {
+        if(b == 0) return a;
+        if(a == 0) return b;
+        return getSum(a^b, (a&b)<<1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/371-sum-of-two-integers/NOTES.md b/leetcode/leetcode/371-sum-of-two-integers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/371-sum-of-two-integers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/371-sum-of-two-integers/README.md b/leetcode/leetcode/371-sum-of-two-integers/README.md
new file mode 100644
index 0000000..bfd3202
--- /dev/null
+++ b/leetcode/leetcode/371-sum-of-two-integers/README.md
@@ -0,0 +1,17 @@
+<h2><a href="https://leetcode.com/problems/sum-of-two-integers/">371. Sum of Two Integers</a></h2><h3>Medium</h3><hr><div><p>Given two integers <code>a</code> and <code>b</code>, return <em>the sum of the two integers without using the operators</em> <code>+</code> <em>and</em> <code>-</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> a = 1, b = 2
+<strong>Output:</strong> 3
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> a = 2, b = 3
+<strong>Output:</strong> 5
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-1000 &lt;= a, b &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/380-insert-delete-getrandom-o1/380-insert-delete-getrandom-o1.java b/leetcode/leetcode/380-insert-delete-getrandom-o1/380-insert-delete-getrandom-o1.java
new file mode 100644
index 0000000..5bd73d5
--- /dev/null
+++ b/leetcode/leetcode/380-insert-delete-getrandom-o1/380-insert-delete-getrandom-o1.java
@@ -0,0 +1,47 @@
+class RandomizedSet {
+    public HashMap<Integer,Integer> map;
+    public HashMap<Integer,Integer> reverse;
+    int range;
+    public RandomizedSet() {
+        map = new HashMap<>();
+        reverse = new HashMap<>();
+        range = 0;
+    }
+    
+    public boolean insert(int val) {
+        if(reverse.containsKey(val)) return false;
+        map.put(range,val);
+        reverse.put(val,range);
+        range++;
+        return true;
+    }
+    
+    public boolean remove(int val) {
+        if(!reverse.containsKey(val)) return false;
+        int rangeVal = reverse.get(val);
+        reverse.remove(val);
+        if(rangeVal!=range - 1){
+            int value = map.get(range-1);
+            map.put(rangeVal,value);
+            reverse.put(value,rangeVal);
+        }else{
+            map.remove(rangeVal);
+        }
+        range--;
+        return true;
+    }
+    
+    public int getRandom() {
+        int random = (int) (Math.random() * (range));
+        return map.get(random);
+
+    }
+}
+
+/**
+ * Your RandomizedSet object will be instantiated and called as such:
+ * RandomizedSet obj = new RandomizedSet();
+ * boolean param_1 = obj.insert(val);
+ * boolean param_2 = obj.remove(val);
+ * int param_3 = obj.getRandom();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/380-insert-delete-getrandom-o1/NOTES.md b/leetcode/leetcode/380-insert-delete-getrandom-o1/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/380-insert-delete-getrandom-o1/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/380-insert-delete-getrandom-o1/README.md b/leetcode/leetcode/380-insert-delete-getrandom-o1/README.md
new file mode 100644
index 0000000..6b3cc89
--- /dev/null
+++ b/leetcode/leetcode/380-insert-delete-getrandom-o1/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/insert-delete-getrandom-o1/">380. Insert Delete GetRandom O(1)</a></h2><h3>Medium</h3><hr><div><p>Implement the <code>RandomizedSet</code> class:</p>
+
+<ul>
+	<li><code>RandomizedSet()</code> Initializes the <code>RandomizedSet</code> object.</li>
+	<li><code>bool insert(int val)</code> Inserts an item <code>val</code> into the set if not present. Returns <code>true</code> if the item was not present, <code>false</code> otherwise.</li>
+	<li><code>bool remove(int val)</code> Removes an item <code>val</code> from the set if present. Returns <code>true</code> if the item was present, <code>false</code> otherwise.</li>
+	<li><code>int getRandom()</code> Returns a random element from the current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the <b>same probability</b> of being returned.</li>
+</ul>
+
+<p>You must implement the functions of the class such that each function works in&nbsp;<strong>average</strong>&nbsp;<code>O(1)</code>&nbsp;time complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
+[[], [1], [2], [2], [], [1], [2], []]
+<strong>Output</strong>
+[null, true, false, true, 2, true, false, 2]
+
+<strong>Explanation</strong>
+RandomizedSet randomizedSet = new RandomizedSet();
+randomizedSet.insert(1); // Inserts 1 to the set. Returns true as 1 was inserted successfully.
+randomizedSet.remove(2); // Returns false as 2 does not exist in the set.
+randomizedSet.insert(2); // Inserts 2 to the set, returns true. Set now contains [1,2].
+randomizedSet.getRandom(); // getRandom() should return either 1 or 2 randomly.
+randomizedSet.remove(1); // Removes 1 from the set, returns true. Set now contains [2].
+randomizedSet.insert(2); // 2 was already in the set, so return false.
+randomizedSet.getRandom(); // Since 2 is the only number in the set, getRandom() will always return 2.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= val &lt;= 2<sup>31</sup> - 1</code></li>
+	<li>At most <code>2 *&nbsp;</code><code>10<sup>5</sup></code> calls will be made to <code>insert</code>, <code>remove</code>, and <code>getRandom</code>.</li>
+	<li>There will be <strong>at least one</strong> element in the data structure when <code>getRandom</code> is called.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/382-linked-list-random-node/382-linked-list-random-node.java b/leetcode/leetcode/382-linked-list-random-node/382-linked-list-random-node.java
new file mode 100644
index 0000000..bedf1eb
--- /dev/null
+++ b/leetcode/leetcode/382-linked-list-random-node/382-linked-list-random-node.java
@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public List<Integer> list = new ArrayList<Integer>();
+
+    public Solution(ListNode head) {
+        while(head!=null){
+            list.add(head.val);
+            head = head.next;
+        }
+    }
+    
+    public int getRandom() {
+        return list.get( (int) ((Math.random() * (list.size() - 0)) + 0));
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution obj = new Solution(head);
+ * int param_1 = obj.getRandom();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/382-linked-list-random-node/NOTES.md b/leetcode/leetcode/382-linked-list-random-node/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/382-linked-list-random-node/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/382-linked-list-random-node/README.md b/leetcode/leetcode/382-linked-list-random-node/README.md
new file mode 100644
index 0000000..c9cf37e
--- /dev/null
+++ b/leetcode/leetcode/382-linked-list-random-node/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/linked-list-random-node/">382. Linked List Random Node</a></h2><h3>Medium</h3><hr><div><p>Given a singly linked list, return a random node's value from the linked list. Each node must have the <strong>same probability</strong> of being chosen.</p>
+
+<p>Implement the <code>Solution</code> class:</p>
+
+<ul>
+	<li><code>Solution(ListNode head)</code> Initializes the object with the integer array nums.</li>
+	<li><code>int getRandom()</code> Chooses a node randomly from the list and returns its value. All the nodes of the list should be equally likely to be choosen.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/16/getrand-linked-list.jpg" style="width: 302px; height: 62px;">
+<pre><strong>Input</strong>
+["Solution", "getRandom", "getRandom", "getRandom", "getRandom", "getRandom"]
+[[[1, 2, 3]], [], [], [], [], []]
+<strong>Output</strong>
+[null, 1, 3, 2, 2, 3]
+
+<strong>Explanation</strong>
+Solution solution = new Solution([1, 2, 3]);
+solution.getRandom(); // return 1
+solution.getRandom(); // return 3
+solution.getRandom(); // return 2
+solution.getRandom(); // return 2
+solution.getRandom(); // return 3
+// getRandom() should return either 1, 2, or 3 randomly. Each element should have equal probability of returning.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the linked list will be in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li>At most <code>10<sup>4</sup></code> calls will be made to <code>getRandom</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>What if the linked list is extremely large and its length is unknown to you?</li>
+	<li>Could you solve this efficiently without using extra space?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/387-first-unique-character-in-a-string/387-first-unique-character-in-a-string.java b/leetcode/leetcode/387-first-unique-character-in-a-string/387-first-unique-character-in-a-string.java
new file mode 100644
index 0000000..3ad2ebf
--- /dev/null
+++ b/leetcode/leetcode/387-first-unique-character-in-a-string/387-first-unique-character-in-a-string.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int firstUniqChar(String s) {
+        int[] freq = new int[26];
+        for(int i = 0;i<s.length();i++){
+            freq[(int)(s.charAt(i)-'a')]++;
+        }
+        for(int i = 0;i<s.length();i++){
+            if(freq[(int)(s.charAt(i)-'a')] == 1) return i;
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/387-first-unique-character-in-a-string/NOTES.md b/leetcode/leetcode/387-first-unique-character-in-a-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/387-first-unique-character-in-a-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/387-first-unique-character-in-a-string/README.md b/leetcode/leetcode/387-first-unique-character-in-a-string/README.md
new file mode 100644
index 0000000..75e1487
--- /dev/null
+++ b/leetcode/leetcode/387-first-unique-character-in-a-string/README.md
@@ -0,0 +1,21 @@
+<h2><a href="https://leetcode.com/problems/first-unique-character-in-a-string/">387. First Unique Character in a String</a></h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code>, <em>find the first non-repeating character in it and return its index</em>. If it does not exist, return <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "leetcode"
+<strong>Output:</strong> 0
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "loveleetcode"
+<strong>Output:</strong> 2
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> s = "aabb"
+<strong>Output:</strong> -1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> consists of only lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/389-find-the-difference/389-find-the-difference.java b/leetcode/leetcode/389-find-the-difference/389-find-the-difference.java
new file mode 100644
index 0000000..46af0bf
--- /dev/null
+++ b/leetcode/leetcode/389-find-the-difference/389-find-the-difference.java
@@ -0,0 +1,15 @@
+class Solution {
+    public char findTheDifference(String s, String t) {
+        int[] freq = new int[26];
+        freq[t.charAt(0)-'a']++;
+        for(int i=0;i<s.length();i++){
+            freq[s.charAt(i) - 'a']--;
+            freq[t.charAt(i+1) - 'a']++;
+        }
+        for(int i = 0;i<26;i++){
+            if(freq[i] == 1) return (char)(i+'a');
+        }
+        return 'a';
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/389-find-the-difference/NOTES.md b/leetcode/leetcode/389-find-the-difference/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/389-find-the-difference/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/389-find-the-difference/README.md b/leetcode/leetcode/389-find-the-difference/README.md
new file mode 100644
index 0000000..bc582f7
--- /dev/null
+++ b/leetcode/leetcode/389-find-the-difference/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/find-the-difference/">389. Find the Difference</a></h2><h3>Easy</h3><hr><div><p>You are given two strings <code>s</code> and <code>t</code>.</p>
+
+<p>String <code>t</code> is generated by random shuffling string <code>s</code> and then add one more letter at a random position.</p>
+
+<p>Return the letter that was added to <code>t</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "abcd", t = "abcde"
+<strong>Output:</strong> "e"
+<strong>Explanation:</strong> 'e' is the letter that was added.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "", t = "y"
+<strong>Output:</strong> "y"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length &lt;= 1000</code></li>
+	<li><code>t.length == s.length + 1</code></li>
+	<li><code>s</code> and <code>t</code> consist of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/39-combination-sum/39-combination-sum.java b/leetcode/leetcode/39-combination-sum/39-combination-sum.java
new file mode 100644
index 0000000..9b49ab4
--- /dev/null
+++ b/leetcode/leetcode/39-combination-sum/39-combination-sum.java
@@ -0,0 +1,36 @@
+class Solution {
+    
+    public List<List<Integer>> combinationSumHelper(int target, int[] candidates, int index){
+        List<List<Integer>> list = new ArrayList<>();
+        if(target<=0) return list;
+        if(index==candidates.length) return list;
+        if(candidates[index] == target){
+            List<Integer> temp = new ArrayList<>();
+            temp.add(target);
+            list.add(temp);
+            list.addAll(combinationSumHelper(target,candidates,index+1));
+            return list;
+        }
+        for(int i = index;i<candidates.length;i++){
+            if(candidates[index] == target){
+                List<Integer> temp = new ArrayList<>();
+                temp.add(target);
+                list.add(temp);
+            }else{
+                List<List<Integer>> temp = combinationSumHelper(target - candidates[index],candidates,index);
+                if(temp.size()!=0){
+                    for(List<Integer> temp2: temp){
+                        temp2.add(candidates[index]);
+                        list.add(temp2);
+                    }
+                }
+            }
+            index++;
+            
+        }
+        return list;
+    }
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        return combinationSumHelper(target,candidates,0);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/39-combination-sum/NOTES.md b/leetcode/leetcode/39-combination-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/39-combination-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/39-combination-sum/README.md b/leetcode/leetcode/39-combination-sum/README.md
new file mode 100644
index 0000000..29193a3
--- /dev/null
+++ b/leetcode/leetcode/39-combination-sum/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/combination-sum/">39. Combination Sum</a></h2><h3>Medium</h3><hr><div><p>Given an array of <strong>distinct</strong> integers <code>candidates</code> and a target integer <code>target</code>, return <em>a list of all <strong>unique combinations</strong> of </em><code>candidates</code><em> where the chosen numbers sum to </em><code>target</code><em>.</em> You may return the combinations in <strong>any order</strong>.</p>
+
+<p>The <strong>same</strong> number may be chosen from <code>candidates</code> an <strong>unlimited number of times</strong>. Two combinations are unique if the frequency of at least one of the chosen numbers is different.</p>
+
+<p>It is <strong>guaranteed</strong> that the number of unique combinations that sum up to <code>target</code> is less than <code>150</code> combinations for the given input.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> candidates = [2,3,6,7], target = 7
+<strong>Output:</strong> [[2,2,3],[7]]
+<strong>Explanation:</strong>
+2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.
+7 is a candidate, and 7 = 7.
+These are the only two combinations.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> candidates = [2,3,5], target = 8
+<strong>Output:</strong> [[2,2,2,2],[2,3,3],[3,5]]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> candidates = [2], target = 1
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= candidates.length &lt;= 30</code></li>
+	<li><code>1 &lt;= candidates[i] &lt;= 200</code></li>
+	<li>All elements of <code>candidates</code> are <strong>distinct</strong>.</li>
+	<li><code>1 &lt;= target &lt;= 500</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/392-is-subsequence/392-is-subsequence.java b/leetcode/leetcode/392-is-subsequence/392-is-subsequence.java
new file mode 100644
index 0000000..2a8775c
--- /dev/null
+++ b/leetcode/leetcode/392-is-subsequence/392-is-subsequence.java
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean isSubsequence(String s, String t) {
+        int start = 0;
+        for(int i = 0;i<s.length();i++){
+            boolean found = false;
+            while(start<t.length()){
+                if(s.charAt(i) == t.charAt(start)){
+                    found = true;
+                    start++;
+                    break;
+                }
+                start++;
+            }
+            if(!found) return false;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/392-is-subsequence/NOTES.md b/leetcode/leetcode/392-is-subsequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/392-is-subsequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/392-is-subsequence/README.md b/leetcode/leetcode/392-is-subsequence/README.md
new file mode 100644
index 0000000..b45f147
--- /dev/null
+++ b/leetcode/leetcode/392-is-subsequence/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/is-subsequence/">392. Is Subsequence</a></h2><h3>Easy</h3><hr><div><p>Given two strings <code>s</code> and <code>t</code>, return <code>true</code><em> if </em><code>s</code><em> is a <strong>subsequence</strong> of </em><code>t</code><em>, or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>A <strong>subsequence</strong> of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., <code>"ace"</code> is a subsequence of <code>"<u>a</u>b<u>c</u>d<u>e</u>"</code> while <code>"aec"</code> is not).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "abc", t = "ahbgdc"
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "axc", t = "ahbgdc"
+<strong>Output:</strong> false
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length &lt;= 100</code></li>
+	<li><code>0 &lt;= t.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Suppose there are lots of incoming <code>s</code>, say <code>s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub></code> where <code>k &gt;= 10<sup>9</sup></code>, and you want to check one by one to see if <code>t</code> has its subsequence. In this scenario, how would you change your code?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/397-integer-replacement/397-integer-replacement.java b/leetcode/leetcode/397-integer-replacement/397-integer-replacement.java
new file mode 100644
index 0000000..c220603
--- /dev/null
+++ b/leetcode/leetcode/397-integer-replacement/397-integer-replacement.java
@@ -0,0 +1,9 @@
+class Solution {
+    public int integerReplacement(int n){
+        if(n==1) return 0;
+        if(n==Integer.MAX_VALUE) return 32;
+        if(n<3) return 1;
+        if(n%2 == 0) return 1+integerReplacement(n/2);
+        return 1+Math.min(integerReplacement(n-1),integerReplacement(n+1));
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/397-integer-replacement/NOTES.md b/leetcode/leetcode/397-integer-replacement/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/397-integer-replacement/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/397-integer-replacement/README.md b/leetcode/leetcode/397-integer-replacement/README.md
new file mode 100644
index 0000000..a3b6f96
--- /dev/null
+++ b/leetcode/leetcode/397-integer-replacement/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/integer-replacement/">397. Integer Replacement</a></h2><h3>Medium</h3><hr><div><p>Given a positive integer <code>n</code>,&nbsp;you can apply one of the following&nbsp;operations:</p>
+
+<ol>
+	<li>If <code>n</code> is even, replace <code>n</code> with <code>n / 2</code>.</li>
+	<li>If <code>n</code> is odd, replace <code>n</code> with either <code>n + 1</code> or <code>n - 1</code>.</li>
+</ol>
+
+<p>Return <em>the minimum number of operations needed for <code>n</code> to become <code>1</code></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 8
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 8 -&gt; 4 -&gt; 2 -&gt; 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 7
+<strong>Output:</strong> 4
+<strong>Explanation: </strong>7 -&gt; 8 -&gt; 4 -&gt; 2 -&gt; 1
+or 7 -&gt; 6 -&gt; 3 -&gt; 2 -&gt; 1
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/398-random-pick-index/398-random-pick-index.java b/leetcode/leetcode/398-random-pick-index/398-random-pick-index.java
new file mode 100644
index 0000000..da64dab
--- /dev/null
+++ b/leetcode/leetcode/398-random-pick-index/398-random-pick-index.java
@@ -0,0 +1,21 @@
+class Solution {
+    HashMap<Integer,List<Integer>> map;
+    public Solution(int[] nums) {
+        map = new HashMap<>(nums.length);
+        for(int i = 0;i<nums.length;i++){
+            List<Integer> list = map.getOrDefault(nums[i],new ArrayList<Integer>());
+            list.add(i);
+            map.put(nums[i],list);
+        }
+    }
+    public int pick(int target) {
+        List<Integer> list = map.get(target);
+        return list.get((int) ((Math.random() * (list.size() - 0)) + 0));
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution obj = new Solution(nums);
+ * int param_1 = obj.pick(target);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/398-random-pick-index/NOTES.md b/leetcode/leetcode/398-random-pick-index/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/398-random-pick-index/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/398-random-pick-index/README.md b/leetcode/leetcode/398-random-pick-index/README.md
new file mode 100644
index 0000000..fc840d8
--- /dev/null
+++ b/leetcode/leetcode/398-random-pick-index/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/random-pick-index/">398. Random Pick Index</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> with possible <strong>duplicates</strong>, randomly output the index of a given <code>target</code> number. You can assume that the given target number must exist in the array.</p>
+
+<p>Implement the <code>Solution</code> class:</p>
+
+<ul>
+	<li><code>Solution(int[] nums)</code> Initializes the object with the array <code>nums</code>.</li>
+	<li><code>int pick(int target)</code> Picks a random index <code>i</code> from <code>nums</code> where <code>nums[i] == target</code>. If there are multiple valid i's, then each index should have an equal probability of returning.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["Solution", "pick", "pick", "pick"]
+[[[1, 2, 3, 3, 3]], [3], [1], [3]]
+<strong>Output</strong>
+[null, 4, 0, 2]
+
+<strong>Explanation</strong>
+Solution solution = new Solution([1, 2, 3, 3, 3]);
+solution.pick(3); // It should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning.
+solution.pick(1); // It should return 0. Since in the array only nums[0] is equal to 1.
+solution.pick(3); // It should return either index 2, 3, or 4 randomly. Each index should have equal probability of returning.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>target</code> is an integer from <code>nums</code>.</li>
+	<li>At most <code>10<sup>4</sup></code> calls will be made to <code>pick</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/400-nth-digit/400-nth-digit.java b/leetcode/leetcode/400-nth-digit/400-nth-digit.java
new file mode 100644
index 0000000..32a2867
--- /dev/null
+++ b/leetcode/leetcode/400-nth-digit/400-nth-digit.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int findNthDigit(int n) {
+        if(n<10) return n;
+        if(n==Integer.MAX_VALUE) return 2; 
+        int weight = 1;
+        int counter = 1;
+        int place =10;
+        int num = 1;
+        while(counter+weight <=n){
+            counter+=weight;
+            num++;
+            if(num==place){
+                place = place*10;
+                weight++;
+            }
+        }
+        for(int i = weight-1;i!=-1;i--){
+            if(i==n-counter) return num%10;
+            num = num/10;
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/400-nth-digit/NOTES.md b/leetcode/leetcode/400-nth-digit/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/400-nth-digit/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/400-nth-digit/README.md b/leetcode/leetcode/400-nth-digit/README.md
new file mode 100644
index 0000000..fd608ea
--- /dev/null
+++ b/leetcode/leetcode/400-nth-digit/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/nth-digit/">400. Nth Digit</a></h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, return the <code>n<sup>th</sup></code> digit of the infinite integer sequence <code>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 11
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The 11<sup>th</sup> digit of the sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... is a 0, which is part of the number 10.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/413-arithmetic-slices/413-arithmetic-slices.java b/leetcode/leetcode/413-arithmetic-slices/413-arithmetic-slices.java
new file mode 100644
index 0000000..73336f0
--- /dev/null
+++ b/leetcode/leetcode/413-arithmetic-slices/413-arithmetic-slices.java
@@ -0,0 +1,28 @@
+class Solution {
+    public int numberOfArithmeticSlices(int[] nums) {
+        if(nums.length<3) return 0;
+        int[] dp = new int[nums.length+1];
+        dp[0] = 0;
+        dp[1] = 0;
+        dp[2] = 0;
+        dp[3] = 1;
+        for(int i = 4;i<=nums.length;i++){
+            dp[i] = dp[i-1] + i-2;
+        }
+        int i = 0;
+        int j = 1;
+        int result = 0;
+        while(j<nums.length){
+            int currentStreak = 2;
+            int k = j+1;
+            while(k<nums.length && nums[i]-nums[j] == nums[k-1]-nums[k]){
+                k++;
+                currentStreak++;
+            }
+            result+=dp[currentStreak];
+            i = k-1;
+            j = k;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/413-arithmetic-slices/NOTES.md b/leetcode/leetcode/413-arithmetic-slices/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/413-arithmetic-slices/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/413-arithmetic-slices/README.md b/leetcode/leetcode/413-arithmetic-slices/README.md
new file mode 100644
index 0000000..1b0299d
--- /dev/null
+++ b/leetcode/leetcode/413-arithmetic-slices/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/arithmetic-slices/">413. Arithmetic Slices</a></h2><h3>Medium</h3><hr><div><p>An integer array is called arithmetic if it consists of <strong>at least three elements</strong> and if the difference between any two consecutive elements is the same.</p>
+
+<ul>
+	<li>For example, <code>[1,3,5,7,9]</code>, <code>[7,7,7,7]</code>, and <code>[3,-1,-5,-9]</code> are arithmetic sequences.</li>
+</ul>
+
+<p>Given an integer array <code>nums</code>, return <em>the number of arithmetic <strong>subarrays</strong> of</em> <code>nums</code>.</p>
+
+<p>A <strong>subarray</strong> is a contiguous subsequence of the array.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> We have 3 arithmetic slices in nums: [1, 2, 3], [2, 3, 4] and [1,2,3,4] itself.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 5000</code></li>
+	<li><code>-1000 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/416-partition-equal-subset-sum/416-partition-equal-subset-sum.java b/leetcode/leetcode/416-partition-equal-subset-sum/416-partition-equal-subset-sum.java
new file mode 100644
index 0000000..20b84c9
--- /dev/null
+++ b/leetcode/leetcode/416-partition-equal-subset-sum/416-partition-equal-subset-sum.java
@@ -0,0 +1,22 @@
+class Solution {
+    public boolean canPartition(int[] nums) {
+        int sum = 0;
+        for(int num: nums) sum+=num;
+        if(sum%2!=0) return false;
+        sum = sum/2;
+        boolean[][] dp = new boolean[nums.length+1][sum+1];
+        for(int i = 0;i<=sum;i++) dp[0][i] = false;
+        for(int i = 0;i<=nums.length;i++) dp[i][0] = true;
+        for(int i = 1;i<=nums.length;i++){
+            for(int j = 1;j<=sum;j++){
+                dp[i][j] = dp[i-1][j];
+                if(!dp[i][j]){
+                    int val =  nums[i -1];
+                    if(j>=val) dp[i][j] = dp[i-1][j-val];
+                }
+            }
+            if(dp[i][sum]) return true;
+        }
+        return dp[nums.length][sum];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/416-partition-equal-subset-sum/NOTES.md b/leetcode/leetcode/416-partition-equal-subset-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/416-partition-equal-subset-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/416-partition-equal-subset-sum/README.md b/leetcode/leetcode/416-partition-equal-subset-sum/README.md
new file mode 100644
index 0000000..4da8a6d
--- /dev/null
+++ b/leetcode/leetcode/416-partition-equal-subset-sum/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/partition-equal-subset-sum/">416. Partition Equal Subset Sum</a></h2><h3>Medium</h3><hr><div><p>Given a <strong>non-empty</strong> array <code>nums</code> containing <strong>only positive integers</strong>, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,5,11,5]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The array can be partitioned as [1, 5, 5] and [11].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,5]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The array cannot be partitioned into equal sum subsets.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 200</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/42-trapping-rain-water/42-trapping-rain-water.java b/leetcode/leetcode/42-trapping-rain-water/42-trapping-rain-water.java
new file mode 100644
index 0000000..64f7037
--- /dev/null
+++ b/leetcode/leetcode/42-trapping-rain-water/42-trapping-rain-water.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int trap(int[] height) {
+        int n = height.length;
+        if(n<3) return 0;
+        int[] right = new int[n];
+        int rightMax = 0;
+        for(int i = 0;i<n;i++){
+            right[n - i - 1]  = rightMax;
+            rightMax = Math.max(height[n- i - 1],rightMax);
+        }
+        int res = 0;
+        int leftMax = 0;
+        for(int i = 0;i<n;i++){
+            int minHeight = Math.min(leftMax,right[i]);
+            if(minHeight>height[i]) res+=(minHeight-height[i]);
+            leftMax = Math.max(leftMax,height[i]);
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/42-trapping-rain-water/NOTES.md b/leetcode/leetcode/42-trapping-rain-water/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/42-trapping-rain-water/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/42-trapping-rain-water/README.md b/leetcode/leetcode/42-trapping-rain-water/README.md
new file mode 100644
index 0000000..b87d0a4
--- /dev/null
+++ b/leetcode/leetcode/42-trapping-rain-water/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/trapping-rain-water/">42. Trapping Rain Water</a></h2><h3>Hard</h3><hr><div><p>Given <code>n</code> non-negative integers representing an elevation map where the width of each bar is <code>1</code>, compute how much water it can trap after raining.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2018/10/22/rainwatertrap.png" style="width: 412px; height: 161px;">
+<pre><strong>Input:</strong> height = [0,1,0,2,1,0,1,3,2,1,2,1]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> height = [4,2,0,3,2,5]
+<strong>Output:</strong> 9
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == height.length</code></li>
+	<li><code>1 &lt;= n &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= height[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/429-n-ary-tree-level-order-traversal/429-n-ary-tree-level-order-traversal.java b/leetcode/leetcode/429-n-ary-tree-level-order-traversal/429-n-ary-tree-level-order-traversal.java
new file mode 100644
index 0000000..40e8af5
--- /dev/null
+++ b/leetcode/leetcode/429-n-ary-tree-level-order-traversal/429-n-ary-tree-level-order-traversal.java
@@ -0,0 +1,43 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+    public List<List<Integer>> levelOrder(Node root) {
+        if(root == null) return new ArrayList<>();
+        List<List<Integer>> list = new ArrayList<>();
+        List<Integer> root_list = new ArrayList<>(1);
+        root_list.add(root.val);
+        list.add(root_list);
+        Queue<Node> q = new LinkedList<>();
+        q.add(root);
+        while(!q.isEmpty()){
+            List<Integer> temp = new ArrayList<>(q.size());
+            for(int i = q.size();i>0;i--){
+                Node front = q.peek();
+                q.remove();
+                for(int j = 0;j<front.children.size();j++){
+                    temp.add(front.children.get(j).val);
+                    q.add(front.children.get(j));
+                }
+            }
+            if(temp.size()!=0) list.add(temp);
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/429-n-ary-tree-level-order-traversal/NOTES.md b/leetcode/leetcode/429-n-ary-tree-level-order-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/429-n-ary-tree-level-order-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/429-n-ary-tree-level-order-traversal/README.md b/leetcode/leetcode/429-n-ary-tree-level-order-traversal/README.md
new file mode 100644
index 0000000..03e9c50
--- /dev/null
+++ b/leetcode/leetcode/429-n-ary-tree-level-order-traversal/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/n-ary-tree-level-order-traversal/">429. N-ary Tree Level Order Traversal</a></h2><h3>Medium</h3><hr><div><p>Given an n-ary tree, return the <em>level order</em> traversal of its nodes' values.</p>
+
+<p><em>Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="width: 100%; max-width: 300px;"></p>
+
+<pre><strong>Input:</strong> root = [1,null,3,2,4,null,5,6]
+<strong>Output:</strong> [[1],[3,2,4],[5,6]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="width: 296px; height: 241px;"></p>
+
+<pre><strong>Input:</strong> root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
+<strong>Output:</strong> [[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The height of the n-ary tree is less than or equal to <code>1000</code></li>
+	<li>The total number of nodes is between <code>[0, 10<sup>4</sup>]</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/438-find-all-anagrams-in-a-string/438-find-all-anagrams-in-a-string.java b/leetcode/leetcode/438-find-all-anagrams-in-a-string/438-find-all-anagrams-in-a-string.java
new file mode 100644
index 0000000..859ce33
--- /dev/null
+++ b/leetcode/leetcode/438-find-all-anagrams-in-a-string/438-find-all-anagrams-in-a-string.java
@@ -0,0 +1,32 @@
+class Solution {
+    public List<Integer> findAnagrams(String s, String p) {
+        List<Integer> list = new ArrayList<>();
+        if(s.length()<p.length()) return list;
+        
+        HashMap<Character,Integer> fix = new HashMap<>(p.length());
+        for(int i = 0;i<p.length();i++){
+            fix.put(p.charAt(i),fix.getOrDefault(p.charAt(i),0)+1);
+        }
+        int start = 0;
+        int end = 0;
+        HashMap<Character,Integer> map = new HashMap<>(p.length());
+        while(end<p.length() && end<s.length()){
+            map.put(s.charAt(end),map.getOrDefault(s.charAt(end),0)+1);
+            end++;
+        }
+        while(end<=s.length()){
+            if(map.equals(fix)){
+                list.add(start);
+            }
+            if(map.get(s.charAt(start))>1){
+                map.put(s.charAt(start),map.get(s.charAt(start))-1);
+            }else{
+                map.remove(s.charAt(start));
+            }
+            if(end<s.length()) map.put(s.charAt(end),map.getOrDefault(s.charAt(end),0)+1);
+            end++;
+            start++;
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/438-find-all-anagrams-in-a-string/NOTES.md b/leetcode/leetcode/438-find-all-anagrams-in-a-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/438-find-all-anagrams-in-a-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/438-find-all-anagrams-in-a-string/README.md b/leetcode/leetcode/438-find-all-anagrams-in-a-string/README.md
new file mode 100644
index 0000000..b599121
--- /dev/null
+++ b/leetcode/leetcode/438-find-all-anagrams-in-a-string/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/find-all-anagrams-in-a-string/">438. Find All Anagrams in a String</a></h2><h3>Medium</h3><hr><div><p>Given two strings <code>s</code> and <code>p</code>, return <em>an array of all the start indices of </em><code>p</code><em>'s anagrams in </em><code>s</code>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>An <strong>Anagram</strong> is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "cbaebabacd", p = "abc"
+<strong>Output:</strong> [0,6]
+<strong>Explanation:</strong>
+The substring with start index = 0 is "cba", which is an anagram of "abc".
+The substring with start index = 6 is "bac", which is an anagram of "abc".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "abab", p = "ab"
+<strong>Output:</strong> [0,1,2]
+<strong>Explanation:</strong>
+The substring with start index = 0 is "ab", which is an anagram of "ab".
+The substring with start index = 1 is "ba", which is an anagram of "ab".
+The substring with start index = 2 is "ab", which is an anagram of "ab".
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length, p.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>s</code> and <code>p</code> consist of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/449-serialize-and-deserialize-bst/449-serialize-and-deserialize-bst.java b/leetcode/leetcode/449-serialize-and-deserialize-bst/449-serialize-and-deserialize-bst.java
new file mode 100644
index 0000000..bd0bf15
--- /dev/null
+++ b/leetcode/leetcode/449-serialize-and-deserialize-bst/449-serialize-and-deserialize-bst.java
@@ -0,0 +1,57 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Codec {
+
+    public class pair{
+        TreeNode root;
+        int index;
+        pair(TreeNode root, int index){
+            this.root = root;
+            this.index = index;
+        }
+    }
+    public String serialize(TreeNode root){
+        if(root == null){
+            String s = "N";
+            return s;
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append(Integer.toString(root.val));
+        sb.append(",");
+        sb.append(serialize(root.left));
+        sb.append(",");
+        sb.append(serialize(root.right));
+        return sb.toString();
+    }
+    // Decodes your encoded data to tree.
+    private pair helper(String[] s, int index){
+        if(index >= s.length) return new pair(null, index);
+        if(s[index].equals("N")) return new pair(null, index+1);
+        int val = Integer.parseInt(s[index++]);
+        TreeNode root = new TreeNode(val);
+        pair left = helper(s, index);
+        pair right = helper(s, left.index);
+        root.left = left.root;
+        root.right = right.root;
+        return new pair(root, right.index);
+    }
+    public TreeNode deserialize(String s) {
+        if(s.equals("N")) return null;
+        String[] res = s.split(",");
+        return helper(res,0).root;
+    }
+}
+
+// Your Codec object will be instantiated and called as such:
+// Codec ser = new Codec();
+// Codec deser = new Codec();
+// String tree = ser.serialize(root);
+// TreeNode ans = deser.deserialize(tree);
+// return ans;
\ No newline at end of file
diff --git a/leetcode/leetcode/449-serialize-and-deserialize-bst/NOTES.md b/leetcode/leetcode/449-serialize-and-deserialize-bst/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/449-serialize-and-deserialize-bst/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/449-serialize-and-deserialize-bst/README.md b/leetcode/leetcode/449-serialize-and-deserialize-bst/README.md
new file mode 100644
index 0000000..32e6f39
--- /dev/null
+++ b/leetcode/leetcode/449-serialize-and-deserialize-bst/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/serialize-and-deserialize-bst/">449. Serialize and Deserialize BST</a></h2><h3>Medium</h3><hr><div><p>Serialization is converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.</p>
+
+<p>Design an algorithm to serialize and deserialize a <b>binary search tree</b>. There is no restriction on how your serialization/deserialization algorithm should work. You need to ensure that a binary search tree can be serialized to a string, and this string can be deserialized to the original tree structure.</p>
+
+<p><b>The encoded string should be as compact as possible.</b></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> root = [2,1,3]
+<strong>Output:</strong> [2,1,3]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li>The input tree is <strong>guaranteed</strong> to be a binary search tree.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/45-jump-game-ii/45-jump-game-ii.java b/leetcode/leetcode/45-jump-game-ii/45-jump-game-ii.java
new file mode 100644
index 0000000..ea1d485
--- /dev/null
+++ b/leetcode/leetcode/45-jump-game-ii/45-jump-game-ii.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int jump(int[] arr) {
+        int res = 0;
+        int left = 0;
+        int right = 0;
+        while(right<arr.length-1){
+            int farthest = 0;
+            for(int i = left;i<=right;i++){
+                farthest = Math.max(farthest,i+arr[i]);
+            }
+            left = right+1;
+            right = farthest;
+            res++;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/45-jump-game-ii/NOTES.md b/leetcode/leetcode/45-jump-game-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/45-jump-game-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/45-jump-game-ii/README.md b/leetcode/leetcode/45-jump-game-ii/README.md
new file mode 100644
index 0000000..6bfdc0c
--- /dev/null
+++ b/leetcode/leetcode/45-jump-game-ii/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/jump-game-ii/">45. Jump Game II</a></h2><h3>Medium</h3><hr><div><p>Given an array of non-negative integers <code>nums</code>, you are initially positioned at the first index of the array.</p>
+
+<p>Each element in the array represents your maximum jump length at that position.</p>
+
+<p>Your goal is to reach the last index in the minimum number of jumps.</p>
+
+<p>You can assume that you can always reach the last index.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,3,1,1,4]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,3,0,1,4]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/450-delete-node-in-a-bst/450-delete-node-in-a-bst.java b/leetcode/leetcode/450-delete-node-in-a-bst/450-delete-node-in-a-bst.java
new file mode 100644
index 0000000..a182134
--- /dev/null
+++ b/leetcode/leetcode/450-delete-node-in-a-bst/450-delete-node-in-a-bst.java
@@ -0,0 +1,43 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int getMax(TreeNode root){
+        while(root.right!=null) root = root.right;
+        return root.val;
+    }
+    public TreeNode deleteNode(TreeNode root, int key) {
+        if(root == null) return root;
+        if(root.val == key){
+            if(root.left == null && root.right == null){
+                return null;
+            }else if(root.left == null && root.right != null){
+                return root.right;
+            }else if(root.left != null && root.right == null){
+                return root.left;
+            }else{
+                int val = getMax(root.left);
+                root.val = val;
+                root.left = deleteNode(root.left,val);
+            }
+        }
+        else if(root.val>key){
+            root.left = deleteNode(root.left,key);
+        }else{
+            root.right = deleteNode(root.right,key);
+        }
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/450-delete-node-in-a-bst/NOTES.md b/leetcode/leetcode/450-delete-node-in-a-bst/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/450-delete-node-in-a-bst/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/450-delete-node-in-a-bst/README.md b/leetcode/leetcode/450-delete-node-in-a-bst/README.md
new file mode 100644
index 0000000..348ebc0
--- /dev/null
+++ b/leetcode/leetcode/450-delete-node-in-a-bst/README.md
@@ -0,0 +1,47 @@
+<h2><a href="https://leetcode.com/problems/delete-node-in-a-bst/">450. Delete Node in a BST</a></h2><h3>Medium</h3><hr><div><p>Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.</p>
+
+<p>Basically, the deletion can be divided into two stages:</p>
+
+<ol>
+	<li>Search for a node to remove.</li>
+	<li>If the node is found, delete the node.</li>
+</ol>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/04/del_node_1.jpg" style="width: 800px; height: 214px;">
+<pre><strong>Input:</strong> root = [5,3,6,2,4,null,7], key = 3
+<strong>Output:</strong> [5,4,6,2,null,null,7]
+<strong>Explanation:</strong> Given key to delete is 3. So we find the node with value 3 and delete it.
+One valid answer is [5,4,6,2,null,null,7], shown in the above BST.
+Please notice that another valid answer is [5,2,6,null,4,null,7] and it's also accepted.
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/04/del_node_supp.jpg" style="width: 350px; height: 255px;">
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [5,3,6,2,4,null,7], key = 0
+<strong>Output:</strong> [5,3,6,2,4,null,7]
+<strong>Explanation:</strong> The tree does not contain a node with value = 0.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [], key = 0
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li>Each node has a <strong>unique</strong> value.</li>
+	<li><code>root</code> is a valid binary search tree.</li>
+	<li><code>-10<sup>5</sup> &lt;= key &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you solve it with time complexity <code>O(height of tree)</code>?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/451-sort-characters-by-frequency/451-sort-characters-by-frequency.java b/leetcode/leetcode/451-sort-characters-by-frequency/451-sort-characters-by-frequency.java
new file mode 100644
index 0000000..d96a5f0
--- /dev/null
+++ b/leetcode/leetcode/451-sort-characters-by-frequency/451-sort-characters-by-frequency.java
@@ -0,0 +1,22 @@
+class Solution {
+    public String frequencySort(String s) {
+        if(s.length()<3) return s;
+        int freq[][] = new int[122][2];
+        StringBuilder sb = new StringBuilder(s.length());
+        for(int i = 0;i<122;i++) freq[i][0] = i;
+        for(int i = 0;i<s.length();i++){
+            int index = s.charAt(i) - '0';
+            freq[index][1]++;
+        }
+        Arrays.sort(freq,(a,b)->Integer.compare(b[1],a[1]));
+        int i = 0;
+        while(freq[i][1]!=0){
+            while(freq[i][1]!=0){
+                sb.append((char)(freq[i][0] + '0'));
+                freq[i][1]--;
+            }
+            i++;
+        }
+        return sb.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/451-sort-characters-by-frequency/NOTES.md b/leetcode/leetcode/451-sort-characters-by-frequency/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/451-sort-characters-by-frequency/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/452-minimum-number-of-arrows-to-burst-balloons.java b/leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/452-minimum-number-of-arrows-to-burst-balloons.java
new file mode 100644
index 0000000..4ce7416
--- /dev/null
+++ b/leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/452-minimum-number-of-arrows-to-burst-balloons.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int findMinArrowShots(int[][] points) {
+        int res = 1;
+        Arrays.sort(points,(a,b)-> Integer.compare(a[1],b[1]));
+        int end = points[0][1];
+        for(int i = 0;i<points.length;i++){
+            if(points[i][0] > end){
+                res++;
+                end = points[i][1];
+            }
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/NOTES.md b/leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/README.md b/leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/README.md
new file mode 100644
index 0000000..470d3e1
--- /dev/null
+++ b/leetcode/leetcode/452-minimum-number-of-arrows-to-burst-balloons/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/">452. Minimum Number of Arrows to Burst Balloons</a></h2><h3>Medium</h3><hr><div><p>There are some spherical balloons taped onto a flat wall that represents the XY-plane. The balloons are represented as a 2D integer array <code>points</code> where <code>points[i] = [x<sub>start</sub>, x<sub>end</sub>]</code> denotes a balloon whose <strong>horizontal diameter</strong> stretches between <code>x<sub>start</sub></code> and <code>x<sub>end</sub></code>. You do not know the exact y-coordinates of the balloons.</p>
+
+<p>Arrows can be shot up <strong>directly vertically</strong> (in the positive y-direction) from different points along the x-axis. A balloon with <code>x<sub>start</sub></code> and <code>x<sub>end</sub></code> is <strong>burst</strong> by an arrow shot at <code>x</code> if <code>x<sub>start</sub> &lt;= x &lt;= x<sub>end</sub></code>. There is <strong>no limit</strong> to the number of arrows that can be shot. A shot arrow keeps traveling up infinitely, bursting any balloons in its path.</p>
+
+<p>Given the array <code>points</code>, return <em>the <strong>minimum</strong> number of arrows that must be shot to burst all balloons</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> points = [[10,16],[2,8],[1,6],[7,12]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The balloons can be burst by 2 arrows:
+- Shoot an arrow at x = 6, bursting the balloons [2,8] and [1,6].
+- Shoot an arrow at x = 11, bursting the balloons [10,16] and [7,12].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> points = [[1,2],[3,4],[5,6],[7,8]]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> One arrow needs to be shot for each balloon for a total of 4 arrows.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> points = [[1,2],[2,3],[3,4],[4,5]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The balloons can be burst by 2 arrows:
+- Shoot an arrow at x = 2, bursting the balloons [1,2] and [2,3].
+- Shoot an arrow at x = 4, bursting the balloons [3,4] and [4,5].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= points.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>points[i].length == 2</code></li>
+	<li><code>-2<sup>31</sup> &lt;= x<sub>start</sub> &lt; x<sub>end</sub> &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/46-permutations/46-permutations.java b/leetcode/leetcode/46-permutations/46-permutations.java
new file mode 100644
index 0000000..c8a546d
--- /dev/null
+++ b/leetcode/leetcode/46-permutations/46-permutations.java
@@ -0,0 +1,26 @@
+class Solution {
+    public List<List<Integer>> permute(int[] nums, int startIndex, int endIndex){
+        List<List<Integer>> list = new ArrayList<>();
+        if(startIndex > nums.length) return list;
+        if(startIndex ==  endIndex){
+            List<Integer> temp = new ArrayList<>();
+            temp.add(nums[startIndex]);
+            list.add(temp);
+            return list;
+        } 
+        List<List<Integer>>  temp = permute(nums,startIndex+1,endIndex);
+        for(int i = 0;i<temp.size();i++){
+            for(int j = 0;j<=temp.get(i).size();j++){
+                List<Integer> temp2 = new ArrayList<>();
+                temp2.addAll(temp.get(i));
+                temp2.add(j,nums[startIndex]);
+                list.add(temp2);
+            }
+        }
+        return list;
+        
+    }
+    public List<List<Integer>> permute(int[] nums) {
+        return permute(nums,0,nums.length-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/46-permutations/NOTES.md b/leetcode/leetcode/46-permutations/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/46-permutations/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/46-permutations/README.md b/leetcode/leetcode/46-permutations/README.md
new file mode 100644
index 0000000..975206f
--- /dev/null
+++ b/leetcode/leetcode/46-permutations/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/permutations/">46. Permutations</a></h2><h3>Medium</h3><hr><div><p>Given an array <code>nums</code> of distinct integers, return <em>all the possible permutations</em>. You can return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [0,1]
+<strong>Output:</strong> [[0,1],[1,0]]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> [[1]]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 6</code></li>
+	<li><code>-10 &lt;= nums[i] &lt;= 10</code></li>
+	<li>All the integers of <code>nums</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/462-minimum-moves-to-equal-array-elements-ii.java b/leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/462-minimum-moves-to-equal-array-elements-ii.java
new file mode 100644
index 0000000..70abf89
--- /dev/null
+++ b/leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/462-minimum-moves-to-equal-array-elements-ii.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int minMoves2(int[] nums) {
+        if(nums.length ==1) return 0;
+        // if(nums.length == 2) return Math.abs(nums[1]-nums[0]);
+        Arrays.sort(nums);
+        int median = nums.length%2 != 0 ? nums[nums.length/2] : (nums[nums.length/2-1] + nums[nums.length/2])/2;
+        int steps = 0;
+        for(int num: nums){
+            steps+=(Math.abs(num-median));
+        }
+        return steps;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/NOTES.md b/leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/README.md b/leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/README.md
new file mode 100644
index 0000000..4693ed2
--- /dev/null
+++ b/leetcode/leetcode/462-minimum-moves-to-equal-array-elements-ii/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/">462. Minimum Moves to Equal Array Elements II</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> of size <code>n</code>, return <em>the minimum number of moves required to make all array elements equal</em>.</p>
+
+<p>In one move, you can increment or decrement an element of the array by <code>1</code>.</p>
+
+<p>Test cases are designed so that the answer will fit in a <strong>32-bit</strong> integer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+Only two moves are needed (remember each move increments or decrements one element):
+[<u>1</u>,2,3]  =&gt;  [2,2,<u>3</u>]  =&gt;  [2,2,2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,10,2,9]
+<strong>Output:</strong> 16
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/470-implement-rand10-using-rand7/470-implement-rand10-using-rand7.java b/leetcode/leetcode/470-implement-rand10-using-rand7/470-implement-rand10-using-rand7.java
new file mode 100644
index 0000000..db54468
--- /dev/null
+++ b/leetcode/leetcode/470-implement-rand10-using-rand7/470-implement-rand10-using-rand7.java
@@ -0,0 +1,10 @@
+/**
+ * The rand7() API is already defined in the parent class SolBase.
+ * public int rand7();
+ * @return a random integer in the range 1 to 7
+ */
+class Solution extends SolBase {
+    public int rand10() {
+        return (rand7()+rand7()+rand7() + rand7()+rand7())%10 + 1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/470-implement-rand10-using-rand7/NOTES.md b/leetcode/leetcode/470-implement-rand10-using-rand7/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/470-implement-rand10-using-rand7/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/470-implement-rand10-using-rand7/README.md b/leetcode/leetcode/470-implement-rand10-using-rand7/README.md
new file mode 100644
index 0000000..f9e09d8
--- /dev/null
+++ b/leetcode/leetcode/470-implement-rand10-using-rand7/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/implement-rand10-using-rand7/">470. Implement Rand10() Using Rand7()</a></h2><h3>Medium</h3><hr><div><p>Given the <strong>API</strong> <code>rand7()</code> that generates a uniform random integer in the range <code>[1, 7]</code>, write a function <code>rand10()</code> that generates a uniform random integer in the range <code>[1, 10]</code>. You can only call the API <code>rand7()</code>, and you shouldn't call any other API. Please <strong>do not</strong> use a language's built-in random API.</p>
+
+<p>Each test case will have one <strong>internal</strong> argument <code>n</code>, the number of times that your implemented function <code>rand10()</code> will be called while testing. Note that this is <strong>not an argument</strong> passed to <code>rand10()</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> [2]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> [2,8]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> [3,8,10]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>What is the <a href="https://en.wikipedia.org/wiki/Expected_value" target="_blank">expected value</a> for the number of calls to <code>rand7()</code> function?</li>
+	<li>Could you minimize the number of calls to <code>rand7()</code>?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/48-rotate-image/48-rotate-image.java b/leetcode/leetcode/48-rotate-image/48-rotate-image.java
new file mode 100644
index 0000000..1d972db
--- /dev/null
+++ b/leetcode/leetcode/48-rotate-image/48-rotate-image.java
@@ -0,0 +1,31 @@
+class Solution {
+    
+    private void swap(int[][] matrix, int a, int b, int i, int j){
+        int temp = matrix[a][b];
+        matrix[a][b] = matrix[i][j];
+        matrix[i][j] = temp;
+    }
+    
+    public void rotateHelper(int[][] matrix, int start, int end){
+        if(start>end) return;
+        swap(matrix,start,start,start,end);
+        swap(matrix,end,start,end,end);
+        swap(matrix,start,start,end,end);
+        for(int i = start+1;i<end;i++){
+            swap(matrix,start,i,i,end);
+            swap(matrix,i,start,end,i);
+        }
+        int counter = 1;
+        for(int i = start+1;i<end;i++){
+            swap(matrix,start,i,end,end - counter);
+            counter++;
+        }
+        start++;
+        end--;
+        rotateHelper(matrix,start,end);
+    }
+    
+    public void rotate(int[][] matrix) {
+        rotateHelper(matrix,0,matrix.length -1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/48-rotate-image/NOTES.md b/leetcode/leetcode/48-rotate-image/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/48-rotate-image/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/48-rotate-image/README.md b/leetcode/leetcode/48-rotate-image/README.md
new file mode 100644
index 0000000..3781a8d
--- /dev/null
+++ b/leetcode/leetcode/48-rotate-image/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/rotate-image/">48. Rotate Image</a></h2><h3>Medium</h3><hr><div><p>You are given an <code>n x n</code> 2D <code>matrix</code> representing an image, rotate the image by <strong>90</strong> degrees (clockwise).</p>
+
+<p>You have to rotate the image <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank"><strong>in-place</strong></a>, which means you have to modify the input 2D matrix directly. <strong>DO NOT</strong> allocate another 2D matrix and do the rotation.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/mat1.jpg" style="width: 500px; height: 188px;">
+<pre><strong>Input:</strong> matrix = [[1,2,3],[4,5,6],[7,8,9]]
+<strong>Output:</strong> [[7,4,1],[8,5,2],[9,6,3]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/mat2.jpg" style="width: 500px; height: 201px;">
+<pre><strong>Input:</strong> matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
+<strong>Output:</strong> [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == matrix.length == matrix[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 20</code></li>
+	<li><code>-1000 &lt;= matrix[i][j] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/494-target-sum/494-target-sum.java b/leetcode/leetcode/494-target-sum/494-target-sum.java
new file mode 100644
index 0000000..02f7f92
--- /dev/null
+++ b/leetcode/leetcode/494-target-sum/494-target-sum.java
@@ -0,0 +1,13 @@
+class Solution {
+    private int helper(int[] nums, int index, int val){
+        if(index == nums.length){
+            if(val == 0) return 1;
+            else return 0;
+        }
+        return helper(nums,index+1,val-nums[index]) + helper(nums,index+1,val+nums[index]);
+        
+    }
+    public int findTargetSumWays(int[] nums, int target) {
+        return helper(nums,0,target);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/494-target-sum/NOTES.md b/leetcode/leetcode/494-target-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/494-target-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/494-target-sum/README.md b/leetcode/leetcode/494-target-sum/README.md
new file mode 100644
index 0000000..db8dbd4
--- /dev/null
+++ b/leetcode/leetcode/494-target-sum/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/target-sum/">494. Target Sum</a></h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>nums</code> and an integer <code>target</code>.</p>
+
+<p>You want to build an <strong>expression</strong> out of nums by adding one of the symbols <code>'+'</code> and <code>'-'</code> before each integer in nums and then concatenate all the integers.</p>
+
+<ul>
+	<li>For example, if <code>nums = [2, 1]</code>, you can add a <code>'+'</code> before <code>2</code> and a <code>'-'</code> before <code>1</code> and concatenate them to build the expression <code>"+2-1"</code>.</li>
+</ul>
+
+<p>Return the number of different <strong>expressions</strong> that you can build, which evaluates to <code>target</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,1,1,1], target = 3
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> There are 5 ways to assign symbols to make the sum of nums be target 3.
+-1 + 1 + 1 + 1 + 1 = 3
++1 - 1 + 1 + 1 + 1 = 3
++1 + 1 - 1 + 1 + 1 = 3
++1 + 1 + 1 - 1 + 1 = 3
++1 + 1 + 1 + 1 - 1 = 3
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1], target = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 20</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 1000</code></li>
+	<li><code>0 &lt;= sum(nums[i]) &lt;= 1000</code></li>
+	<li><code>-1000 &lt;= target &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/496-next-greater-element-i/496-next-greater-element-i.java b/leetcode/leetcode/496-next-greater-element-i/496-next-greater-element-i.java
new file mode 100644
index 0000000..aeb9b2a
--- /dev/null
+++ b/leetcode/leetcode/496-next-greater-element-i/496-next-greater-element-i.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        Stack<Integer> s = new Stack<>();
+        for(int num: nums2){
+            while(!s.isEmpty() && s.peek()<num){
+                map.put(s.pop(),num);
+            }
+            s.push(num);
+        }
+        for(int i = 0;i<nums1.length;i++){
+            nums1[i] = map.getOrDefault(nums1[i],-1);
+        }
+        return nums1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/496-next-greater-element-i/NOTES.md b/leetcode/leetcode/496-next-greater-element-i/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/496-next-greater-element-i/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/496-next-greater-element-i/README.md b/leetcode/leetcode/496-next-greater-element-i/README.md
new file mode 100644
index 0000000..a947674
--- /dev/null
+++ b/leetcode/leetcode/496-next-greater-element-i/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/next-greater-element-i/">496. Next Greater Element I</a></h2><h3>Easy</h3><hr><div><p>The <strong>next greater element</strong> of some element <code>x</code> in an array is the <strong>first greater</strong> element that is <strong>to the right</strong> of <code>x</code> in the same array.</p>
+
+<p>You are given two <strong>distinct 0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code>, where <code>nums1</code> is a subset of <code>nums2</code>.</p>
+
+<p>For each <code>0 &lt;= i &lt; nums1.length</code>, find the index <code>j</code> such that <code>nums1[i] == nums2[j]</code> and determine the <strong>next greater element</strong> of <code>nums2[j]</code> in <code>nums2</code>. If there is no next greater element, then the answer for this query is <code>-1</code>.</p>
+
+<p>Return <em>an array </em><code>ans</code><em> of length </em><code>nums1.length</code><em> such that </em><code>ans[i]</code><em> is the <strong>next greater element</strong> as described above.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [4,1,2], nums2 = [1,3,4,2]
+<strong>Output:</strong> [-1,3,-1]
+<strong>Explanation:</strong> The next greater element for each value of nums1 is as follows:
+- 4 is underlined in nums2 = [1,3,<u>4</u>,2]. There is no next greater element, so the answer is -1.
+- 1 is underlined in nums2 = [<u>1</u>,3,4,2]. The next greater element is 3.
+- 2 is underlined in nums2 = [1,3,4,<u>2</u>]. There is no next greater element, so the answer is -1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [2,4], nums2 = [1,2,3,4]
+<strong>Output:</strong> [3,-1]
+<strong>Explanation:</strong> The next greater element for each value of nums1 is as follows:
+- 2 is underlined in nums2 = [1,<u>2</u>,3,4]. The next greater element is 3.
+- 4 is underlined in nums2 = [1,2,3,<u>4</u>]. There is no next greater element, so the answer is -1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums1.length &lt;= nums2.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums1[i], nums2[i] &lt;= 10<sup>4</sup></code></li>
+	<li>All integers in <code>nums1</code> and <code>nums2</code> are <strong>unique</strong>.</li>
+	<li>All the integers of <code>nums1</code> also appear in <code>nums2</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you find an <code>O(nums1.length + nums2.length)</code> solution?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/509-fibonacci-number/509-fibonacci-number.java b/leetcode/leetcode/509-fibonacci-number/509-fibonacci-number.java
new file mode 100644
index 0000000..7e60785
--- /dev/null
+++ b/leetcode/leetcode/509-fibonacci-number/509-fibonacci-number.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int fib(int n) {
+        if(n<2) return n;
+        int first = 0;
+        int second = 1;
+        int current = first + second;
+        while(n!=1){
+            current = first+second;
+            first = second;
+            second = current;
+            --n;
+        }
+        return current;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/509-fibonacci-number/NOTES.md b/leetcode/leetcode/509-fibonacci-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/509-fibonacci-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/509-fibonacci-number/README.md b/leetcode/leetcode/509-fibonacci-number/README.md
new file mode 100644
index 0000000..5c4b5ad
--- /dev/null
+++ b/leetcode/leetcode/509-fibonacci-number/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/fibonacci-number/">509. Fibonacci Number</a></h2><h3>Easy</h3><hr><div><p>The <b>Fibonacci numbers</b>, commonly denoted <code>F(n)</code> form a sequence, called the <b>Fibonacci sequence</b>, such that each number is the sum of the two preceding ones, starting from <code>0</code> and <code>1</code>. That is,</p>
+
+<pre>F(0) = 0, F(1) = 1
+F(n) = F(n - 1) + F(n - 2), for n &gt; 1.
+</pre>
+
+<p>Given <code>n</code>, calculate <code>F(n)</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> F(2) = F(1) + F(0) = 1 + 0 = 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> F(3) = F(2) + F(1) = 1 + 1 = 2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> F(4) = F(3) + F(2) = 2 + 1 = 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 30</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/511-game-play-analysis-i/511-game-play-analysis-i.sql b/leetcode/leetcode/511-game-play-analysis-i/511-game-play-analysis-i.sql
new file mode 100644
index 0000000..7af8a95
--- /dev/null
+++ b/leetcode/leetcode/511-game-play-analysis-i/511-game-play-analysis-i.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT player_id,MIN(event_date) As first_login from Activity GROUP BY player_id;
\ No newline at end of file
diff --git a/leetcode/leetcode/511-game-play-analysis-i/NOTES.md b/leetcode/leetcode/511-game-play-analysis-i/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/511-game-play-analysis-i/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/511-game-play-analysis-i/README.md b/leetcode/leetcode/511-game-play-analysis-i/README.md
new file mode 100644
index 0000000..2b62564
--- /dev/null
+++ b/leetcode/leetcode/511-game-play-analysis-i/README.md
@@ -0,0 +1,47 @@
+<h2><a href="https://leetcode.com/problems/game-play-analysis-i/">511. Game Play Analysis I</a></h2><h3>Easy</h3><hr><div class="sql-schema-wrapper__3VBi"><a class="sql-schema-link__3cEg">SQL Schema<svg viewBox="0 0 24 24" width="1em" height="1em" class="icon__1Md2"><path fill-rule="evenodd" d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></svg></a></div><div><p>Table: <code>Activity</code></p>
+
+<pre>+--------------+---------+
+| Column Name  | Type    |
++--------------+---------+
+| player_id    | int     |
+| device_id    | int     |
+| event_date   | date    |
+| games_played | int     |
++--------------+---------+
+(player_id, event_date) is the primary key of this table.
+This table shows the activity of players of some games.
+Each row is a record of a player who logged in and played a number of games (possibly 0) before logging out on someday using some device.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write an SQL query to report the <strong>first login date</strong> for each player.</p>
+
+<p>Return the result table in <strong>any order</strong>.</p>
+
+<p>The query result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> 
+Activity table:
++-----------+-----------+------------+--------------+
+| player_id | device_id | event_date | games_played |
++-----------+-----------+------------+--------------+
+| 1         | 2         | 2016-03-01 | 5            |
+| 1         | 2         | 2016-05-02 | 6            |
+| 2         | 3         | 2017-06-25 | 1            |
+| 3         | 1         | 2016-03-02 | 0            |
+| 3         | 4         | 2018-07-03 | 5            |
++-----------+-----------+------------+--------------+
+<strong>Output:</strong> 
++-----------+-------------+
+| player_id | first_login |
++-----------+-------------+
+| 1         | 2016-03-01  |
+| 2         | 2017-06-25  |
+| 3         | 2016-03-02  |
++-----------+-------------+
+</pre>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/515-find-largest-value-in-each-tree-row/515-find-largest-value-in-each-tree-row.java b/leetcode/leetcode/515-find-largest-value-in-each-tree-row/515-find-largest-value-in-each-tree-row.java
new file mode 100644
index 0000000..2fec9b4
--- /dev/null
+++ b/leetcode/leetcode/515-find-largest-value-in-each-tree-row/515-find-largest-value-in-each-tree-row.java
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> largestValues(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        if(root == null) return list;
+        Queue<TreeNode> q = new LinkedList<>();
+        q.offer(root);
+        while(!q.isEmpty()){
+            int max  = Integer.MIN_VALUE;
+            for(int i = q.size();i>0;i--){
+                TreeNode front = q.poll();
+                max = Math.max(max,front.val);
+                if(front.left!=null) q.offer(front.left);
+                if(front.right!=null) q.offer(front.right);
+            }
+            list.add(max);
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/515-find-largest-value-in-each-tree-row/NOTES.md b/leetcode/leetcode/515-find-largest-value-in-each-tree-row/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/515-find-largest-value-in-each-tree-row/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/515-find-largest-value-in-each-tree-row/README.md b/leetcode/leetcode/515-find-largest-value-in-each-tree-row/README.md
new file mode 100644
index 0000000..892270a
--- /dev/null
+++ b/leetcode/leetcode/515-find-largest-value-in-each-tree-row/README.md
@@ -0,0 +1,23 @@
+<h2><a href="https://leetcode.com/problems/find-largest-value-in-each-tree-row/">515. Find Largest Value in Each Tree Row</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>an array of the largest value in each row</em> of the tree <strong>(0-indexed)</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/21/largest_e1.jpg" style="width: 300px; height: 172px;">
+<pre><strong>Input:</strong> root = [1,3,2,5,3,null,9]
+<strong>Output:</strong> [1,3,9]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,2,3]
+<strong>Output:</strong> [1,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree will be in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-2<sup>31</sup> &lt;= Node.val &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/520-detect-capital/520-detect-capital.java b/leetcode/leetcode/520-detect-capital/520-detect-capital.java
new file mode 100644
index 0000000..7ae6f9e
--- /dev/null
+++ b/leetcode/leetcode/520-detect-capital/520-detect-capital.java
@@ -0,0 +1,24 @@
+class Solution {
+    public boolean detectCapitalUse(String word) {
+        int n = word.length();
+        if (n == 1) {
+            return true;
+        }
+
+        if (Character.isUpperCase(word.charAt(0)) && Character.isUpperCase(word.charAt(1))) {
+            for (int i = 2; i < n; i++) {
+                if (Character.isLowerCase(word.charAt(i))) {
+                    return false;
+                }
+            }
+        } else {
+            for (int i = 1; i < n; i++) {
+                if (Character.isUpperCase(word.charAt(i))) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/520-detect-capital/NOTES.md b/leetcode/leetcode/520-detect-capital/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/520-detect-capital/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/525-contiguous-array/525-contiguous-array.java b/leetcode/leetcode/525-contiguous-array/525-contiguous-array.java
new file mode 100644
index 0000000..04bc1fe
--- /dev/null
+++ b/leetcode/leetcode/525-contiguous-array/525-contiguous-array.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int findMaxLength(int[] nums) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int ans = 0;
+        int sum = 0;
+        int i = 0;
+        for(i = 0;i<nums.length;i++){
+            if(nums[i] == 0){
+                sum--;
+            }else{
+                sum++;
+            }
+            if(map.containsKey(sum)){
+                ans = Math.max(ans,i - map.get(sum));
+            }else{
+                map.put(sum,i);
+            }
+            if(sum == 0) ans = i+1;
+        }
+        return sum == 0 ? i : ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/525-contiguous-array/NOTES.md b/leetcode/leetcode/525-contiguous-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/525-contiguous-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/525-contiguous-array/README.md b/leetcode/leetcode/525-contiguous-array/README.md
new file mode 100644
index 0000000..a59cfe7
--- /dev/null
+++ b/leetcode/leetcode/525-contiguous-array/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/contiguous-array/">525. Contiguous Array</a></h2><h3>Medium</h3><hr><div><p>Given a binary array <code>nums</code>, return <em>the maximum length of a contiguous subarray with an equal number of </em><code>0</code><em> and </em><code>1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> [0, 1] is the longest contiguous subarray with an equal number of 0 and 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1,0]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/532-k-diff-pairs-in-an-array/532-k-diff-pairs-in-an-array.java b/leetcode/leetcode/532-k-diff-pairs-in-an-array/532-k-diff-pairs-in-an-array.java
new file mode 100644
index 0000000..7815f31
--- /dev/null
+++ b/leetcode/leetcode/532-k-diff-pairs-in-an-array/532-k-diff-pairs-in-an-array.java
@@ -0,0 +1,28 @@
+class Solution {
+    private int binarySearch(int[] arr, int start, int element){
+        int low = start;
+        int high = arr.length -1;
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(arr[mid]==element){
+                return mid;
+            }else if(arr[mid]>element){
+                high = mid-1;                
+            }else{
+                low = mid+1;
+            }
+        }
+        return -1;
+    }
+    public int findPairs(int[] nums, int k) {
+        HashSet<Pair<Integer,Integer>> set = new HashSet<>();
+        Arrays.sort(nums);
+        for(int i = 0;i<nums.length;i++){
+            int res = binarySearch(nums,i+1,nums[i]+k);
+            if(res!=-1){
+                set.add(new Pair<Integer,Integer>(nums[i],nums[i]+k));
+            }
+        }
+        return set.size();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/532-k-diff-pairs-in-an-array/NOTES.md b/leetcode/leetcode/532-k-diff-pairs-in-an-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/532-k-diff-pairs-in-an-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/532-k-diff-pairs-in-an-array/README.md b/leetcode/leetcode/532-k-diff-pairs-in-an-array/README.md
new file mode 100644
index 0000000..c7c37e7
--- /dev/null
+++ b/leetcode/leetcode/532-k-diff-pairs-in-an-array/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/k-diff-pairs-in-an-array/">532. K-diff Pairs in an Array</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>nums</code> and an integer <code>k</code>, return <em>the number of <b>unique</b> k-diff pairs in the array</em>.</p>
+
+<p>A <strong>k-diff</strong> pair is an integer pair <code>(nums[i], nums[j])</code>, where the following are true:</p>
+
+<ul>
+	<li><code>0 &lt;= i, j &lt; nums.length</code></li>
+	<li><code>i != j</code></li>
+	<li><code>nums[i] - nums[j] == k</code></li>
+</ul>
+
+<p><strong>Notice</strong> that <code>|val|</code> denotes the absolute value of <code>val</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,1,4,1,5], k = 2
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There are two 2-diff pairs in the array, (1, 3) and (3, 5).
+Although we have two 1s in the input, we should only return the number of <strong>unique</strong> pairs.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,5], k = 1
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> There are four 1-diff pairs in the array, (1, 2), (2, 3), (3, 4) and (4, 5).
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3,1,5,4], k = 0
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> There is one 0-diff pair in the array, (1, 1).
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>7</sup> &lt;= nums[i] &lt;= 10<sup>7</sup></code></li>
+	<li><code>0 &lt;= k &lt;= 10<sup>7</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/538-convert-bst-to-greater-tree/538-convert-bst-to-greater-tree.java b/leetcode/leetcode/538-convert-bst-to-greater-tree/538-convert-bst-to-greater-tree.java
new file mode 100644
index 0000000..a816d31
--- /dev/null
+++ b/leetcode/leetcode/538-convert-bst-to-greater-tree/538-convert-bst-to-greater-tree.java
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    int pre = 0;
+    public TreeNode convertBST(TreeNode root) {
+        if(root == null) return root;
+        if(root.right!=null) convertBST(root.right);
+        pre = root.val = pre+root.val;
+        if (root.left != null) convertBST(root.left);
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/538-convert-bst-to-greater-tree/NOTES.md b/leetcode/leetcode/538-convert-bst-to-greater-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/538-convert-bst-to-greater-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/538-convert-bst-to-greater-tree/README.md b/leetcode/leetcode/538-convert-bst-to-greater-tree/README.md
new file mode 100644
index 0000000..9184ea8
--- /dev/null
+++ b/leetcode/leetcode/538-convert-bst-to-greater-tree/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/convert-bst-to-greater-tree/">538. Convert BST to Greater Tree</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus the sum of all keys greater than the original key in BST.</p>
+
+<p>As a reminder, a <em>binary search tree</em> is a tree that satisfies these constraints:</p>
+
+<ul>
+	<li>The left subtree of a node contains only nodes with keys <strong>less than</strong> the node's key.</li>
+	<li>The right subtree of a node contains only nodes with keys <strong>greater than</strong> the node's key.</li>
+	<li>Both the left and right subtrees must also be binary search trees.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/05/02/tree.png" style="width: 500px; height: 341px;">
+<pre><strong>Input:</strong> root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
+<strong>Output:</strong> [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [0,null,1]
+<strong>Output:</strong> [1,null,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li>All the values in the tree are <strong>unique</strong>.</li>
+	<li><code>root</code> is guaranteed to be a valid binary search tree.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as 1038: <a href="https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/" target="_blank">https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/54-spiral-matrix/54-spiral-matrix.java b/leetcode/leetcode/54-spiral-matrix/54-spiral-matrix.java
new file mode 100644
index 0000000..7607cfa
--- /dev/null
+++ b/leetcode/leetcode/54-spiral-matrix/54-spiral-matrix.java
@@ -0,0 +1,27 @@
+class Solution {
+    public List<Integer> spiralOrder(int[][] matrix) {
+        int rowStart = 0;
+        int rowEnd = matrix[0].length - 1;
+        int colStart = 0;
+        int colEnd = matrix.length - 1;
+        List<Integer> list = new ArrayList<>(matrix.length*matrix[0].length);
+        while(rowStart<rowEnd && colStart<colEnd){
+            for(int i = rowStart;i<=rowEnd;i++) list.add(matrix[colStart][i]);
+            for(int i = colStart+1;i<colEnd;i++) list.add(matrix[i][rowEnd]);
+            for(int i = rowEnd;i>=rowStart;i--) list.add(matrix[colEnd][i]);
+            for(int i = colEnd -1;i>colStart;i--) list.add(matrix[i][colStart]);
+            rowStart++;
+            rowEnd--;
+            colStart++;
+            colEnd--;
+        }
+        if(colStart == colEnd && rowStart == rowEnd){
+            list.add(matrix[rowStart][rowEnd]);
+        }else if(rowStart == rowEnd){
+            for(int i = colStart;i<=colEnd;i++) list.add(matrix[i][rowStart]);        
+        }else if(colStart == colEnd){
+            for(int i = rowStart;i<=rowEnd;i++) list.add(matrix[colStart][i]);         
+        } 
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/54-spiral-matrix/NOTES.md b/leetcode/leetcode/54-spiral-matrix/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/54-spiral-matrix/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/54-spiral-matrix/README.md b/leetcode/leetcode/54-spiral-matrix/README.md
new file mode 100644
index 0000000..0390c03
--- /dev/null
+++ b/leetcode/leetcode/54-spiral-matrix/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/spiral-matrix/">54. Spiral Matrix</a></h2><h3>Medium</h3><hr><div><p>Given an <code>m x n</code> <code>matrix</code>, return <em>all elements of the</em> <code>matrix</code> <em>in spiral order</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/spiral1.jpg" style="width: 242px; height: 242px;">
+<pre><strong>Input:</strong> matrix = [[1,2,3],[4,5,6],[7,8,9]]
+<strong>Output:</strong> [1,2,3,6,9,8,7,4,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/spiral.jpg" style="width: 322px; height: 242px;">
+<pre><strong>Input:</strong> matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+<strong>Output:</strong> [1,2,3,4,8,12,11,10,9,5,6,7]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == matrix.length</code></li>
+	<li><code>n == matrix[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 10</code></li>
+	<li><code>-100 &lt;= matrix[i][j] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/540-single-element-in-a-sorted-array/540-single-element-in-a-sorted-array.java b/leetcode/leetcode/540-single-element-in-a-sorted-array/540-single-element-in-a-sorted-array.java
new file mode 100644
index 0000000..280ea09
--- /dev/null
+++ b/leetcode/leetcode/540-single-element-in-a-sorted-array/540-single-element-in-a-sorted-array.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int singleNonDuplicate(int[] nums) {
+        if(nums.length == 1) return nums[0];
+        int low = 0;
+        int high = nums.length -1;
+        if(nums[low]!=nums[low+1]) return nums[low];
+        if(nums[high]!=nums[high-1]) return nums[high];
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(nums[mid] == nums[mid+1]){
+                if((high - mid)%2!=0){
+                    high = mid -1;
+                }else{
+                    low = mid;
+                }
+            }else if(nums[mid] == nums[mid-1]){
+                if((high - mid)%2==0){
+                    high = mid;
+                }else{
+                    low = mid+1;
+                }
+                
+            }else{
+                return nums[mid];
+            }
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/540-single-element-in-a-sorted-array/NOTES.md b/leetcode/leetcode/540-single-element-in-a-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/540-single-element-in-a-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/55-jump-game/55-jump-game.java b/leetcode/leetcode/55-jump-game/55-jump-game.java
new file mode 100644
index 0000000..abb6bdb
--- /dev/null
+++ b/leetcode/leetcode/55-jump-game/55-jump-game.java
@@ -0,0 +1,16 @@
+class Solution {
+    public boolean canJump(int[] nums) {
+        int left = 0;
+        int right = nums[0];
+        while(right<nums.length - 1){
+            int max = 0;
+            for(int i = left;i<=right;i++){
+                max = Math.max(max,i+nums[i]);
+            }
+            if(max == right ) return false;
+            left = right+1;
+            right = max;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/55-jump-game/NOTES.md b/leetcode/leetcode/55-jump-game/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/55-jump-game/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/55-jump-game/README.md b/leetcode/leetcode/55-jump-game/README.md
new file mode 100644
index 0000000..2789ae3
--- /dev/null
+++ b/leetcode/leetcode/55-jump-game/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/jump-game/">55. Jump Game</a></h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>nums</code>. You are initially positioned at the array's <strong>first index</strong>, and each element in the array represents your maximum jump length at that position.</p>
+
+<p>Return <code>true</code><em> if you can reach the last index, or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,3,1,1,4]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Jump 1 step from index 0 to 1, then 3 steps to the last index.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,2,1,0,4]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/560-subarray-sum-equals-k/560-subarray-sum-equals-k.java b/leetcode/leetcode/560-subarray-sum-equals-k/560-subarray-sum-equals-k.java
new file mode 100644
index 0000000..93d8545
--- /dev/null
+++ b/leetcode/leetcode/560-subarray-sum-equals-k/560-subarray-sum-equals-k.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int subarraySum(int[] nums, int k) {
+        HashMap<Integer, Integer> map = new HashMap<>();
+        int ans = 0;
+        int sum = 0;
+        map.put(0,1);
+        for(int i = 0;i<nums.length;i++){
+            sum += nums[i];
+            ans+=map.getOrDefault(sum-k,0);
+            map.put(sum,map.getOrDefault(sum,0)+1);
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/560-subarray-sum-equals-k/NOTES.md b/leetcode/leetcode/560-subarray-sum-equals-k/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/560-subarray-sum-equals-k/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/560-subarray-sum-equals-k/README.md b/leetcode/leetcode/560-subarray-sum-equals-k/README.md
new file mode 100644
index 0000000..8cf95b6
--- /dev/null
+++ b/leetcode/leetcode/560-subarray-sum-equals-k/README.md
@@ -0,0 +1,19 @@
+<h2><a href="https://leetcode.com/problems/subarray-sum-equals-k/">560. Subarray Sum Equals K</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>nums</code> and an integer <code>k</code>, return <em>the total number of subarrays whose sum equals to <code>k</code></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,1], k = 2
+<strong>Output:</strong> 2
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3], k = 3
+<strong>Output:</strong> 2
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= nums[i] &lt;= 1000</code></li>
+	<li><code>-10<sup>7</sup> &lt;= k &lt;= 10<sup>7</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/567-permutation-in-string/567-permutation-in-string.java b/leetcode/leetcode/567-permutation-in-string/567-permutation-in-string.java
new file mode 100644
index 0000000..254f5d9
--- /dev/null
+++ b/leetcode/leetcode/567-permutation-in-string/567-permutation-in-string.java
@@ -0,0 +1,30 @@
+class Solution {
+    public boolean checkInclusion(String s1, String s2) {
+        if(s1.length()>s2.length()) return false;
+        int[] freq = new int[26];
+        int[] second = new int[26];
+        for(int i =0;i<s1.length();i++){
+            freq[s1.charAt(i) - 'a']++;
+            second[s2.charAt(i)-'a']++;
+            
+        }
+        int i = 0;
+        int j = s1.length();
+        while(j<s2.length()){
+            if(equals(freq,second)) return true;
+            second[s2.charAt(j) - 'a']++;
+            second[s2.charAt(i) - 'a']--;
+            i++;
+            j++;            
+        }
+        return equals(freq,second);
+        
+    }
+    public boolean equals(int[] first, int[] second) {
+        for (int i = 0; i < 26; i++) {
+            if (first[i] != second[i])
+                return false;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/567-permutation-in-string/NOTES.md b/leetcode/leetcode/567-permutation-in-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/567-permutation-in-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/567-permutation-in-string/README.md b/leetcode/leetcode/567-permutation-in-string/README.md
new file mode 100644
index 0000000..e4a1dab
--- /dev/null
+++ b/leetcode/leetcode/567-permutation-in-string/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/permutation-in-string/">567. Permutation in String</a></h2><h3>Medium</h3><hr><div><p>Given two strings <code>s1</code> and <code>s2</code>, return <code>true</code><em> if </em><code>s2</code><em> contains a permutation of </em><code>s1</code><em>, or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>In other words, return <code>true</code> if one of <code>s1</code>'s permutations is the substring of <code>s2</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s1 = "ab", s2 = "eidbaooo"
+<strong>Output:</strong> true
+<strong>Explanation:</strong> s2 contains one permutation of s1 ("ba").
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s1 = "ab", s2 = "eidboaoo"
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s1.length, s2.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s1</code> and <code>s2</code> consist of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/575-distribute-candies/575-distribute-candies.java b/leetcode/leetcode/575-distribute-candies/575-distribute-candies.java
new file mode 100644
index 0000000..7ef35b2
--- /dev/null
+++ b/leetcode/leetcode/575-distribute-candies/575-distribute-candies.java
@@ -0,0 +1,9 @@
+class Solution {
+    public int distributeCandies(int[] candyType) {
+        HashSet<Integer> set = new HashSet<>();
+        for(int num: candyType){
+            set.add(num);
+        }
+        return Math.min(candyType.length/2,set.size());
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/575-distribute-candies/NOTES.md b/leetcode/leetcode/575-distribute-candies/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/575-distribute-candies/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/575-distribute-candies/README.md b/leetcode/leetcode/575-distribute-candies/README.md
new file mode 100644
index 0000000..4c8a800
--- /dev/null
+++ b/leetcode/leetcode/575-distribute-candies/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/distribute-candies/">575. Distribute Candies</a></h2><h3>Easy</h3><hr><div><p>Alice has <code>n</code> candies, where the <code>i<sup>th</sup></code> candy is of type <code>candyType[i]</code>. Alice noticed that she started to gain weight, so she visited a doctor.</p>
+
+<p>The doctor advised Alice to only eat <code>n / 2</code> of the candies she has (<code>n</code> is always even). Alice likes her candies very much, and she wants to eat the maximum number of different types of candies while still following the doctor's advice.</p>
+
+<p>Given the integer array <code>candyType</code> of length <code>n</code>, return <em>the <strong>maximum</strong> number of different types of candies she can eat if she only eats </em><code>n / 2</code><em> of them</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> candyType = [1,1,2,2,3,3]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Alice can only eat 6 / 2 = 3 candies. Since there are only 3 types, she can eat one of each type.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> candyType = [1,1,2,3]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Alice can only eat 4 / 2 = 2 candies. Whether she eats types [1,2], [1,3], or [2,3], she still can only eat 2 different types.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> candyType = [6,6,6,6]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> Alice can only eat 4 / 2 = 2 candies. Even though she can eat 2 candies, she only has 1 type.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == candyType.length</code></li>
+	<li><code>2 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>n</code>&nbsp;is even.</li>
+	<li><code>-10<sup>5</sup> &lt;= candyType[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/59-spiral-matrix-ii/59-spiral-matrix-ii.java b/leetcode/leetcode/59-spiral-matrix-ii/59-spiral-matrix-ii.java
new file mode 100644
index 0000000..46a7a20
--- /dev/null
+++ b/leetcode/leetcode/59-spiral-matrix-ii/59-spiral-matrix-ii.java
@@ -0,0 +1,33 @@
+class Solution {    
+    public int[][] generateMatrix(int n) {
+        int[][] matrix = new int[n][n];
+        int rowStart = 0;
+        int rowEnd = n -1;
+        int start = 1;
+        while(rowStart<=rowEnd){
+            if(rowStart == rowEnd){
+                matrix[rowStart][rowEnd] = start;
+                break;
+            }
+            for(int i = rowStart;i<=rowEnd;i++){
+                matrix[rowStart][i] = start;
+                start++;
+            }
+            for(int i = rowStart+1;i<rowEnd;i++){
+                matrix[i][rowEnd]=start;
+                start++;
+            }
+            for(int i = rowEnd;i>=rowStart;i--){
+                matrix[rowEnd][i] = start;
+                start++;
+            }
+            for(int i = rowEnd - 1;i>rowStart;i--){
+                matrix[i][rowStart] = start;
+                start++;
+            }
+            rowStart++;
+            rowEnd--;    
+        }
+        return matrix;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/59-spiral-matrix-ii/NOTES.md b/leetcode/leetcode/59-spiral-matrix-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/59-spiral-matrix-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/59-spiral-matrix-ii/README.md b/leetcode/leetcode/59-spiral-matrix-ii/README.md
new file mode 100644
index 0000000..70c7b71
--- /dev/null
+++ b/leetcode/leetcode/59-spiral-matrix-ii/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/spiral-matrix-ii/">59. Spiral Matrix II</a></h2><h3>Medium</h3><hr><div><p>Given a positive integer <code>n</code>, generate an <code>n x n</code> <code>matrix</code> filled with elements from <code>1</code> to <code>n<sup>2</sup></code> in spiral order.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/spiraln.jpg" style="width: 242px; height: 242px;">
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> [[1,2,3],[8,9,4],[7,6,5]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> [[1]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 20</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/595-big-countries/595-big-countries.sql b/leetcode/leetcode/595-big-countries/595-big-countries.sql
new file mode 100644
index 0000000..ce86236
--- /dev/null
+++ b/leetcode/leetcode/595-big-countries/595-big-countries.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT name,population,area from World WHERE area >= 3000000 OR population >= 25000000;
\ No newline at end of file
diff --git a/leetcode/leetcode/595-big-countries/NOTES.md b/leetcode/leetcode/595-big-countries/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/595-big-countries/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/595-big-countries/README.md b/leetcode/leetcode/595-big-countries/README.md
new file mode 100644
index 0000000..084a9c0
--- /dev/null
+++ b/leetcode/leetcode/595-big-countries/README.md
@@ -0,0 +1,53 @@
+<h2><a href="https://leetcode.com/problems/big-countries/">595. Big Countries</a></h2><h3>Easy</h3><hr><div class="sql-schema-wrapper__3VBi"><a class="sql-schema-link__3cEg">SQL Schema<svg viewBox="0 0 24 24" width="1em" height="1em" class="icon__1Md2"><path fill-rule="evenodd" d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></svg></a></div><div><p>Table: <code>World</code></p>
+
+<pre>+-------------+---------+
+| Column Name | Type    |
++-------------+---------+
+| name        | varchar |
+| continent   | varchar |
+| area        | int     |
+| population  | int     |
+| gdp         | int     |
++-------------+---------+
+name is the primary key column for this table.
+Each row of this table gives information about the name of a country, the continent to which it belongs, its area, the population, and its GDP value.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>A country is <strong>big</strong> if:</p>
+
+<ul>
+	<li>it has an area of at least&nbsp;three million (i.e., <code>3000000 km<sup>2</sup></code>), or</li>
+	<li>it has a population of at least&nbsp;twenty-five million (i.e., <code>25000000</code>).</li>
+</ul>
+
+<p>Write an SQL query to report the name, population, and area of the <strong>big countries</strong>.</p>
+
+<p>Return the result table in <strong>any order</strong>.</p>
+
+<p>The query result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> 
+World table:
++-------------+-----------+---------+------------+--------------+
+| name        | continent | area    | population | gdp          |
++-------------+-----------+---------+------------+--------------+
+| Afghanistan | Asia      | 652230  | 25500100   | 20343000000  |
+| Albania     | Europe    | 28748   | 2831741    | 12960000000  |
+| Algeria     | Africa    | 2381741 | 37100000   | 188681000000 |
+| Andorra     | Europe    | 468     | 78115      | 3712000000   |
+| Angola      | Africa    | 1246700 | 20609294   | 100990000000 |
++-------------+-----------+---------+------------+--------------+
+<strong>Output:</strong> 
++-------------+------------+---------+
+| name        | population | area    |
++-------------+------------+---------+
+| Afghanistan | 25500100   | 652230  |
+| Algeria     | 37100000   | 2381741 |
++-------------+------------+---------+
+</pre>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/596-classes-more-than-5-students/596-classes-more-than-5-students.sql b/leetcode/leetcode/596-classes-more-than-5-students/596-classes-more-than-5-students.sql
new file mode 100644
index 0000000..1741877
--- /dev/null
+++ b/leetcode/leetcode/596-classes-more-than-5-students/596-classes-more-than-5-students.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT class from Courses GROUP BY class having count(student)>=5;
\ No newline at end of file
diff --git a/leetcode/leetcode/596-classes-more-than-5-students/NOTES.md b/leetcode/leetcode/596-classes-more-than-5-students/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/596-classes-more-than-5-students/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/596-classes-more-than-5-students/README.md b/leetcode/leetcode/596-classes-more-than-5-students/README.md
new file mode 100644
index 0000000..76feecc
--- /dev/null
+++ b/leetcode/leetcode/596-classes-more-than-5-students/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/classes-more-than-5-students/">596. Classes More Than 5 Students</a></h2><h3>Easy</h3><hr><div class="sql-schema-wrapper__3VBi"><a class="sql-schema-link__3cEg">SQL Schema<svg viewBox="0 0 24 24" width="1em" height="1em" class="icon__1Md2"><path fill-rule="evenodd" d="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"></path></svg></a></div><div><p>Table: <code>Courses</code></p>
+
+<pre>+-------------+---------+
+| Column Name | Type    |
++-------------+---------+
+| student     | varchar |
+| class       | varchar |
++-------------+---------+
+(student, class) is the primary key column for this table.
+Each row of this table indicates the name of a student and the class in which they are enrolled.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write an SQL query to report all the classes that have <strong>at least five students</strong>.</p>
+
+<p>Return the result table in <strong>any order</strong>.</p>
+
+<p>The query result format is in the following example.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> 
+Courses table:
++---------+----------+
+| student | class    |
++---------+----------+
+| A       | Math     |
+| B       | English  |
+| C       | Math     |
+| D       | Biology  |
+| E       | Math     |
+| F       | Computer |
+| G       | Math     |
+| H       | Math     |
+| I       | Math     |
++---------+----------+
+<strong>Output:</strong> 
++---------+
+| class   |
++---------+
+| Math    |
++---------+
+<strong>Explanation:</strong> 
+- Math has 6 students, so we include it.
+- English has 1 student, so we do not include it.
+- Biology has 1 student, so we do not include it.
+- Computer has 1 student, so we do not include it.
+</pre>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/605-can-place-flowers/605-can-place-flowers.java b/leetcode/leetcode/605-can-place-flowers/605-can-place-flowers.java
new file mode 100644
index 0000000..4d961db
--- /dev/null
+++ b/leetcode/leetcode/605-can-place-flowers/605-can-place-flowers.java
@@ -0,0 +1,26 @@
+class Solution {
+    public boolean canPlaceFlowers(int[] flowerbed, int n) {
+        int i = 0;
+        int len = flowerbed.length;
+        if(len == 1) return flowerbed[0] == 0 || n==0;
+        if(flowerbed[0] == 0 && flowerbed[1] == 0){
+            flowerbed[0] = 1;
+            n--;
+        }
+        if(n==0) return true;
+        if(flowerbed[len - 2] == 0 && flowerbed[len -1] == 0){
+            flowerbed[len - 1] = 1;
+            n--;
+        }
+        if(n==0) return true;
+        while(i<len -2){
+            if(flowerbed[i] == 0 && flowerbed[i+1] == 0 && flowerbed[i+2] == 0){
+                flowerbed[++i] = 1;
+                n--;
+            }
+            i = i+1;
+            if(n==0) return true;
+        }
+        return n<=0;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/605-can-place-flowers/NOTES.md b/leetcode/leetcode/605-can-place-flowers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/605-can-place-flowers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/605-can-place-flowers/README.md b/leetcode/leetcode/605-can-place-flowers/README.md
new file mode 100644
index 0000000..b98f56a
--- /dev/null
+++ b/leetcode/leetcode/605-can-place-flowers/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/can-place-flowers/">605. Can Place Flowers</a></h2><h3>Easy</h3><hr><div><p>You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in <strong>adjacent</strong> plots.</p>
+
+<p>Given an integer array <code>flowerbed</code> containing <code>0</code>'s and <code>1</code>'s, where <code>0</code> means empty and <code>1</code> means not empty, and an integer <code>n</code>, return <em>if</em> <code>n</code> new flowers can be planted in the <code>flowerbed</code> without violating the no-adjacent-flowers rule.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> flowerbed = [1,0,0,0,1], n = 1
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> flowerbed = [1,0,0,0,1], n = 2
+<strong>Output:</strong> false
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= flowerbed.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>flowerbed[i]</code> is <code>0</code> or <code>1</code>.</li>
+	<li>There are no two adjacent flowers in <code>flowerbed</code>.</li>
+	<li><code>0 &lt;= n &lt;= flowerbed.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/606-construct-string-from-binary-tree/606-construct-string-from-binary-tree.java b/leetcode/leetcode/606-construct-string-from-binary-tree/606-construct-string-from-binary-tree.java
new file mode 100644
index 0000000..8575593
--- /dev/null
+++ b/leetcode/leetcode/606-construct-string-from-binary-tree/606-construct-string-from-binary-tree.java
@@ -0,0 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public StringBuilder helper(TreeNode root){
+        if(root == null) return new StringBuilder();
+        StringBuilder left = helper(root.left);
+        StringBuilder right = helper(root.right);
+        StringBuilder result = new StringBuilder();
+        result.append(Integer.toString(root.val));
+        if(left.length()==0 && right.length() == 0) return result;
+        if(left.length() !=0 && right.length() ==0){
+            result.append("(");
+            result.append(left.toString());
+            result.append(")");
+            return result;
+        }
+        result.append("(");
+        result.append(left.toString());
+        result.append(")");
+        result.append("(");
+        result.append(right.toString());
+        result.append(")");
+        return result;
+
+    }
+    public String tree2str(TreeNode root) {
+        return helper(root).toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/606-construct-string-from-binary-tree/NOTES.md b/leetcode/leetcode/606-construct-string-from-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/606-construct-string-from-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/606-construct-string-from-binary-tree/README.md b/leetcode/leetcode/606-construct-string-from-binary-tree/README.md
new file mode 100644
index 0000000..1450b79
--- /dev/null
+++ b/leetcode/leetcode/606-construct-string-from-binary-tree/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/construct-string-from-binary-tree/">606. Construct String from Binary Tree</a></h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, construct a string consisting of parenthesis and integers from a binary tree with the preorder traversal way, and return it.</p>
+
+<p>Omit all the empty parenthesis pairs that do not affect the one-to-one mapping relationship between the string and the original binary tree.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/05/03/cons1-tree.jpg" style="width: 292px; height: 301px;">
+<pre><strong>Input:</strong> root = [1,2,3,4]
+<strong>Output:</strong> "1(2(4))(3)"
+<strong>Explanation:</strong> Originally, it needs to be "1(2(4)())(3()())", but you need to omit all the unnecessary empty parenthesis pairs. And it will be "1(2(4))(3)"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/05/03/cons2-tree.jpg" style="width: 207px; height: 293px;">
+<pre><strong>Input:</strong> root = [1,2,3,null,4]
+<strong>Output:</strong> "1(2()(4))(3)"
+<strong>Explanation:</strong> Almost the same as the first example, except we cannot omit the first parenthesis pair to break the one-to-one mapping relationship between the input and the output.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/61-rotate-list/61-rotate-list.java b/leetcode/leetcode/61-rotate-list/61-rotate-list.java
new file mode 100644
index 0000000..22ac6c8
--- /dev/null
+++ b/leetcode/leetcode/61-rotate-list/61-rotate-list.java
@@ -0,0 +1,39 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    
+
+    
+    public ListNode rotateRight(ListNode head, int k) {
+        if(head ==null || head.next == null) return head;
+        ListNode temp = head;
+        int size = 0;
+        while(temp!=null){
+            temp = temp.next;
+            size ++;
+        }
+        k = k%size;
+        if(k==0) return head;
+        temp = head;
+        int counter = 0;
+        while(counter<size-k-1){
+            temp = temp.next;
+            counter++;
+        }
+        ListNode temp2  =temp.next;
+        temp.next = null;
+        temp = temp2;
+        while(temp.next != null) temp = temp.next;
+        temp.next = head;
+        head = temp2;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/61-rotate-list/NOTES.md b/leetcode/leetcode/61-rotate-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/61-rotate-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/62-unique-paths/62-unique-paths.java b/leetcode/leetcode/62-unique-paths/62-unique-paths.java
new file mode 100644
index 0000000..347d2ea
--- /dev/null
+++ b/leetcode/leetcode/62-unique-paths/62-unique-paths.java
@@ -0,0 +1,27 @@
+class Solution {
+    private int uniquePath(int m,int n, int row, int col, int[][] dp){
+        if(row == m  && col == n ) return 1;
+        int down = 0;
+        int right = 0;
+        if(row!=m){
+            if(dp[row+1][col]!=0){
+                down = dp[row+1][col];
+            }else{
+                down = uniquePath(m,n,row+1,col,dp);
+            }
+        }
+        if(col!=n){
+            if(dp[row][col+1]!=0){
+                right = dp[row][col+1];
+            }else{
+                right = uniquePath(m,n,row,col+1,dp);
+            }
+        }
+        dp[row][col] = down + right;
+        return dp[row][col];
+    }
+    public int uniquePaths(int m, int n) {
+        int[][] dp = new int[m][n];
+        return uniquePath(m-1,n-1,0,0,dp);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/62-unique-paths/NOTES.md b/leetcode/leetcode/62-unique-paths/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/62-unique-paths/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/62-unique-paths/README.md b/leetcode/leetcode/62-unique-paths/README.md
new file mode 100644
index 0000000..f5816d6
--- /dev/null
+++ b/leetcode/leetcode/62-unique-paths/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/unique-paths/">62. Unique Paths</a></h2><h3>Medium</h3><hr><div><p>There is a robot on an <code>m x n</code> grid. The robot is initially located at the <strong>top-left corner</strong> (i.e., <code>grid[0][0]</code>). The robot tries to move to the <strong>bottom-right corner</strong> (i.e., <code>grid[m - 1][n - 1]</code>). The robot can only move either down or right at any point in time.</p>
+
+<p>Given the two integers <code>m</code> and <code>n</code>, return <em>the number of possible unique paths that the robot can take to reach the bottom-right corner</em>.</p>
+
+<p>The test cases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png" style="width: 400px; height: 183px;">
+<pre><strong>Input:</strong> m = 3, n = 7
+<strong>Output:</strong> 28
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> m = 3, n = 2
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
+1. Right -&gt; Down -&gt; Down
+2. Down -&gt; Down -&gt; Right
+3. Down -&gt; Right -&gt; Down
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= m, n &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/623-add-one-row-to-tree/623-add-one-row-to-tree.java b/leetcode/leetcode/623-add-one-row-to-tree/623-add-one-row-to-tree.java
new file mode 100644
index 0000000..bc1bcc8
--- /dev/null
+++ b/leetcode/leetcode/623-add-one-row-to-tree/623-add-one-row-to-tree.java
@@ -0,0 +1,38 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode addOneRow(TreeNode root, int val, int depth) {
+        if(root == null) return null;
+        if(depth-1 == 0){
+            TreeNode newRoot = new TreeNode(val);
+            newRoot.left = root;
+            return newRoot;
+        }
+        if(depth - 2 == 0){
+            TreeNode left = new TreeNode(val);
+            TreeNode right = new TreeNode(val);
+            left.left = root.left;
+            right.right = root.right;
+            root.left = left;
+            root.right = right;
+            return root;
+        }
+        root.left = addOneRow(root.left,val,depth-1);
+        root.right = addOneRow(root.right,val,depth-1);
+        return root;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/623-add-one-row-to-tree/NOTES.md b/leetcode/leetcode/623-add-one-row-to-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/623-add-one-row-to-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/623-add-one-row-to-tree/README.md b/leetcode/leetcode/623-add-one-row-to-tree/README.md
new file mode 100644
index 0000000..c0b6db6
--- /dev/null
+++ b/leetcode/leetcode/623-add-one-row-to-tree/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/add-one-row-to-tree/">623. Add One Row to Tree</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree and two integers <code>val</code> and <code>depth</code>, add a row of nodes with value <code>val</code> at the given depth <code>depth</code>.</p>
+
+<p>Note that the <code>root</code> node is at depth <code>1</code>.</p>
+
+<p>The adding rule is:</p>
+
+<ul>
+	<li>Given the integer <code>depth</code>, for each not null tree node <code>cur</code> at the depth <code>depth - 1</code>, create two tree nodes with value <code>val</code> as <code>cur</code>'s left subtree root and right subtree root.</li>
+	<li><code>cur</code>'s original left subtree should be the left subtree of the new left subtree root.</li>
+	<li><code>cur</code>'s original right subtree should be the right subtree of the new right subtree root.</li>
+	<li>If <code>depth == 1</code> that means there is no depth <code>depth - 1</code> at all, then create a tree node with value <code>val</code> as the new root of the whole original tree, and the original tree is the new root's left subtree.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/15/addrow-tree.jpg" style="width: 500px; height: 231px;">
+<pre><strong>Input:</strong> root = [4,2,6,3,1,5], val = 1, depth = 2
+<strong>Output:</strong> [4,1,1,2,null,null,6,3,1,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/11/add2-tree.jpg" style="width: 500px; height: 277px;">
+<pre><strong>Input:</strong> root = [4,2,null,3,1], val = 1, depth = 3
+<strong>Output:</strong> [4,2,null,1,1,3,null,null,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li>The depth of the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li><code>-10<sup>5</sup> &lt;= val &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= depth &lt;= the depth of tree + 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/63-unique-paths-ii/63-unique-paths-ii.java b/leetcode/leetcode/63-unique-paths-ii/63-unique-paths-ii.java
new file mode 100644
index 0000000..de37489
--- /dev/null
+++ b/leetcode/leetcode/63-unique-paths-ii/63-unique-paths-ii.java
@@ -0,0 +1,33 @@
+class Solution {
+    private int uniquePath(int m,int n, int row, int col, int[][] dp,int[][] grid){
+        if(grid[row][col] == 1) return 0;
+        if(row == m  && col == n ) return 1;
+        int down = 0;
+        int right = 0;
+        if(row!=m){
+            if(dp[row+1][col]!=-1){
+                down = dp[row+1][col];
+            }else{
+                down = uniquePath(m,n,row+1,col,dp,grid);
+            }
+        }
+        if(col!=n){
+            if(dp[row][col+1]!=-1){
+                right = dp[row][col+1];
+            }else{
+                right = uniquePath(m,n,row,col+1,dp,grid);
+            }
+        }
+        dp[row][col] = down + right;
+        return dp[row][col];
+    }
+    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+        int row = obstacleGrid.length;
+        int col = obstacleGrid[0].length;
+        int[][] dp = new int[row][col];
+        for(int i = 0;i<row;i++){
+            for(int j = 0;j<col;j++) dp[i][j] = -1;
+        }
+        return uniquePath(row-1,col-1,0,0,dp,obstacleGrid);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/63-unique-paths-ii/NOTES.md b/leetcode/leetcode/63-unique-paths-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/63-unique-paths-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/63-unique-paths-ii/README.md b/leetcode/leetcode/63-unique-paths-ii/README.md
new file mode 100644
index 0000000..7fce5c7
--- /dev/null
+++ b/leetcode/leetcode/63-unique-paths-ii/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/unique-paths-ii/">63. Unique Paths II</a></h2><h3>Medium</h3><hr><div><p>A robot is located at the top-left corner of a <code>m x n</code> grid (marked 'Start' in the diagram below).</p>
+
+<p>The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).</p>
+
+<p>Now consider if some obstacles are added to the grids. How many unique paths would there be?</p>
+
+<p>An obstacle and space is marked as <code>1</code> and <code>0</code> respectively in the grid.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/robot1.jpg" style="width: 242px; height: 242px;">
+<pre><strong>Input:</strong> obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There is one obstacle in the middle of the 3x3 grid above.
+There are two ways to reach the bottom-right corner:
+1. Right -&gt; Right -&gt; Down -&gt; Down
+2. Down -&gt; Down -&gt; Right -&gt; Right
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg" style="width: 162px; height: 162px;">
+<pre><strong>Input:</strong> obstacleGrid = [[0,1],[0,0]]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m ==&nbsp;obstacleGrid.length</code></li>
+	<li><code>n ==&nbsp;obstacleGrid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 100</code></li>
+	<li><code>obstacleGrid[i][j]</code> is <code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/637-average-of-levels-in-binary-tree/NOTES.md b/leetcode/leetcode/637-average-of-levels-in-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/637-average-of-levels-in-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/637-average-of-levels-in-binary-tree/README.md b/leetcode/leetcode/637-average-of-levels-in-binary-tree/README.md
new file mode 100644
index 0000000..af82a24
--- /dev/null
+++ b/leetcode/leetcode/637-average-of-levels-in-binary-tree/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/average-of-levels-in-binary-tree/">637. Average of Levels in Binary Tree</a></h2><h3>Easy</h3><hr><div>Given the <code>root</code> of a binary tree, return <em>the average value of the nodes on each level in the form of an array</em>. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/avg1-tree.jpg" style="width: 277px; height: 302px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> [3.00000,14.50000,11.00000]
+Explanation: The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11.
+Hence return [3, 14.5, 11].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/avg2-tree.jpg" style="width: 292px; height: 302px;">
+<pre><strong>Input:</strong> root = [3,9,20,15,7]
+<strong>Output:</strong> [3.00000,14.50000,11.00000]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-2<sup>31</sup> &lt;= Node.val &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/64-minimum-path-sum/64-minimum-path-sum.java b/leetcode/leetcode/64-minimum-path-sum/64-minimum-path-sum.java
new file mode 100644
index 0000000..72cb245
--- /dev/null
+++ b/leetcode/leetcode/64-minimum-path-sum/64-minimum-path-sum.java
@@ -0,0 +1,30 @@
+class Solution {
+    public int minPathSum(int[][] grid, int currentRow,int currentCol, int rows, int cols, int[][] dp){
+        if(currentRow == rows && currentCol == cols) return grid[rows][cols];
+        int down = Integer.MAX_VALUE;
+        int right = Integer.MAX_VALUE;
+        if(currentRow!=rows){ 
+            if(dp[currentRow+1][currentCol]!=-1){
+                down = dp[currentRow+1][currentCol];
+            }else down = minPathSum(grid,currentRow+1,currentCol,rows,cols,dp);
+        }
+        if(currentCol!= cols){
+            if(dp[currentRow][currentCol+1]!=-1) right = dp[currentRow][currentCol];
+            else right = minPathSum(grid,currentRow,currentCol+1,rows,cols,dp);
+        }
+        dp[currentRow][currentCol] = Math.min(down,right) + grid[currentRow][currentCol];
+        return dp[currentRow][currentCol];
+    }
+    public int minPathSum(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        int[][] dp = new int[m][n];
+        for(int i = 0;i<m;i++){
+            for(int j = 0;j<n;j++){
+                dp[i][j] = -1;
+            }
+        }
+        return minPathSum(grid,0,0,m- 1,n -1,dp);
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/64-minimum-path-sum/NOTES.md b/leetcode/leetcode/64-minimum-path-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/64-minimum-path-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/64-minimum-path-sum/README.md b/leetcode/leetcode/64-minimum-path-sum/README.md
new file mode 100644
index 0000000..18b4fcd
--- /dev/null
+++ b/leetcode/leetcode/64-minimum-path-sum/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/minimum-path-sum/">64. Minimum Path Sum</a></h2><h3>Medium</h3><hr><div><p>Given a <code>m x n</code> <code>grid</code> filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.</p>
+
+<p><strong>Note:</strong> You can only move either down or right at any point in time.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/05/minpath.jpg" style="width: 242px; height: 242px;">
+<pre><strong>Input:</strong> grid = [[1,3,1],[1,5,1],[4,2,1]]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[1,2,3],[4,5,6]]
+<strong>Output:</strong> 12
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 200</code></li>
+	<li><code>0 &lt;= grid[i][j] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/645-set-mismatch/645-set-mismatch.java b/leetcode/leetcode/645-set-mismatch/645-set-mismatch.java
new file mode 100644
index 0000000..b460652
--- /dev/null
+++ b/leetcode/leetcode/645-set-mismatch/645-set-mismatch.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int[] findErrorNums(int[] nums) {
+        int xor = nums[0];
+        int[] result = new int[2];
+        int sum = 0;
+        boolean found = false;
+        for(int i = 0;i<nums.length;i++){
+            sum+=(Math.abs(nums[i]));
+            if(!found){
+                int index = Math.abs(nums[i]) -1;
+                if(nums[index]<0){
+                    result[0] = index+1;
+                    found= true;
+                }
+                nums[index] = -nums[index];
+            }
+        }
+        sum = sum- result[0];
+        result[1] = (nums.length+1)*(nums.length)/2 -sum;
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/645-set-mismatch/README.md b/leetcode/leetcode/645-set-mismatch/README.md
new file mode 100644
index 0000000..94b0406
--- /dev/null
+++ b/leetcode/leetcode/645-set-mismatch/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/set-mismatch/">645. Set Mismatch</a></h2><h3>Easy</h3><hr><div><p>You have a set of integers <code>s</code>, which originally contains all the numbers from <code>1</code> to <code>n</code>. Unfortunately, due to some error, one of the numbers in <code>s</code> got duplicated to another number in the set, which results in <strong>repetition of one</strong> number and <strong>loss of another</strong> number.</p>
+
+<p>You are given an integer array <code>nums</code> representing the data status of this set after the error.</p>
+
+<p>Find the number that occurs twice and the number that is missing and return <em>them in the form of an array</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,2,4]
+<strong>Output:</strong> [2,3]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1]
+<strong>Output:</strong> [1,2]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/662-maximum-width-of-binary-tree/662-maximum-width-of-binary-tree.java b/leetcode/leetcode/662-maximum-width-of-binary-tree/662-maximum-width-of-binary-tree.java
new file mode 100644
index 0000000..89f29c3
--- /dev/null
+++ b/leetcode/leetcode/662-maximum-width-of-binary-tree/662-maximum-width-of-binary-tree.java
@@ -0,0 +1,49 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    class pair{
+        int index;
+        TreeNode node;
+        pair(TreeNode node, int index){
+            this.index = index;
+            this.node = node;
+        }
+    }
+    public int widthOfBinaryTree(TreeNode root) {
+        Queue<pair> q = new LinkedList<>();
+        int leftMost = -1;
+        int rightMost = -1;
+        int max = 0;
+        q.add(new pair(root,0));
+        while(!q.isEmpty()){
+            for(int i = q.size();i!=0;i--){
+                pair front = q.remove();
+                if(leftMost == -1 && rightMost == -1){
+                    leftMost = front.index;
+                    rightMost = front.index;
+                }else if(rightMost<front.index){
+                    rightMost = front.index;
+                }
+                if(front.node.left!=null) q.add(new pair(front.node.left, 2 * front.index + 1));
+                if(front.node.right!=null) q.add(new pair(front.node.right, 2 * front.index + 2));
+            }
+            max = Math.max(max,rightMost - leftMost +1);
+            leftMost = -1;
+            rightMost = -1;
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/662-maximum-width-of-binary-tree/NOTES.md b/leetcode/leetcode/662-maximum-width-of-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/662-maximum-width-of-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/662-maximum-width-of-binary-tree/README.md b/leetcode/leetcode/662-maximum-width-of-binary-tree/README.md
new file mode 100644
index 0000000..6b09e1d
--- /dev/null
+++ b/leetcode/leetcode/662-maximum-width-of-binary-tree/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/maximum-width-of-binary-tree/">662. Maximum Width of Binary Tree</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the <strong>maximum width</strong> of the given tree</em>.</p>
+
+<p>The <strong>maximum width</strong> of a tree is the maximum <strong>width</strong> among all levels.</p>
+
+<p>The <strong>width</strong> of one level is defined as the length between the end-nodes (the leftmost and rightmost non-null nodes), where the null nodes between the end-nodes are also counted into the length calculation.</p>
+
+<p>It is <strong>guaranteed</strong> that the answer will in the range of <strong>32-bit</strong> signed integer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/05/03/width1-tree.jpg" style="width: 359px; height: 302px;">
+<pre><strong>Input:</strong> root = [1,3,2,5,3,null,9]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The maximum width existing in the third level with the length 4 (5,3,null,9).
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/05/03/width2-tree.jpg" style="width: 224px; height: 302px;">
+<pre><strong>Input:</strong> root = [1,3,null,5,3]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The maximum width existing in the third level with the length 2 (5,3).
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/05/03/width3-tree.jpg" style="width: 289px; height: 299px;">
+<pre><strong>Input:</strong> root = [1,3,2,5]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The maximum width existing in the second level with the length 2 (3,2).
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 3000]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/669-trim-a-binary-search-tree/669-trim-a-binary-search-tree.java b/leetcode/leetcode/669-trim-a-binary-search-tree/669-trim-a-binary-search-tree.java
new file mode 100644
index 0000000..a34ced0
--- /dev/null
+++ b/leetcode/leetcode/669-trim-a-binary-search-tree/669-trim-a-binary-search-tree.java
@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode trimBST(TreeNode root, int low, int high) {
+        if(root == null) return root;
+        if(root.val<low) root = trimBST(root.right,low,high);
+        else if(root.val>high) root = trimBST(root.left,low,high);
+        else{
+            root.left = trimBST(root.left,low,high);
+            root.right = trimBST(root.right,low,high);
+        }
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/669-trim-a-binary-search-tree/NOTES.md b/leetcode/leetcode/669-trim-a-binary-search-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/669-trim-a-binary-search-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/669-trim-a-binary-search-tree/README.md b/leetcode/leetcode/669-trim-a-binary-search-tree/README.md
new file mode 100644
index 0000000..abf51fd
--- /dev/null
+++ b/leetcode/leetcode/669-trim-a-binary-search-tree/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/trim-a-binary-search-tree/">669. Trim a Binary Search Tree</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary search tree and the lowest and highest boundaries as <code>low</code> and <code>high</code>, trim the tree so that all its elements lies in <code>[low, high]</code>. Trimming the tree should <strong>not</strong> change the relative structure of the elements that will remain in the tree (i.e., any node's descendant should remain a descendant). It can be proven that there is a <strong>unique answer</strong>.</p>
+
+<p>Return <em>the root of the trimmed binary search tree</em>. Note that the root may change depending on the given bounds.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/09/trim1.jpg" style="width: 450px; height: 126px;">
+<pre><strong>Input:</strong> root = [1,0,2], low = 1, high = 2
+<strong>Output:</strong> [1,null,2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/09/trim2.jpg" style="width: 450px; height: 277px;">
+<pre><strong>Input:</strong> root = [3,0,4,null,2,null,null,1], low = 1, high = 3
+<strong>Output:</strong> [3,2,null,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li>The value of each node in the tree is <strong>unique</strong>.</li>
+	<li><code>root</code> is guaranteed to be a valid binary search tree.</li>
+	<li><code>0 &lt;= low &lt;= high &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/67-add-binary/67-add-binary.java b/leetcode/leetcode/67-add-binary/67-add-binary.java
new file mode 100644
index 0000000..9f46881
--- /dev/null
+++ b/leetcode/leetcode/67-add-binary/67-add-binary.java
@@ -0,0 +1,17 @@
+class Solution {
+    public String addBinary(String a, String b) {
+        StringBuilder sb = new StringBuilder();
+        int i = a.length() -1;
+        int j = b.length() -1;
+        int carry = 0;
+        while(i>=0 || j>=0){
+            int sum = carry;
+            if(i>=0) sum += a.charAt(i--) - '0';
+            if(j>=0) sum += b.charAt(j--) - '0';
+            sb.append(sum % 2);
+            carry = sum /2;
+        }
+        if(carry!=0) sb.append(carry);
+        return sb.reverse().toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/67-add-binary/README.md b/leetcode/leetcode/67-add-binary/README.md
new file mode 100644
index 0000000..fc85c32
--- /dev/null
+++ b/leetcode/leetcode/67-add-binary/README.md
@@ -0,0 +1,19 @@
+<h2><a href="https://leetcode.com/problems/add-binary/">67. Add Binary</a></h2><h3>Easy</h3><hr><div><p>Given two binary strings <code>a</code> and <code>b</code>, return <em>their sum as a binary string</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> a = "11", b = "1"
+<strong>Output:</strong> "100"
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> a = "1010", b = "1011"
+<strong>Output:</strong> "10101"
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= a.length, b.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>a</code> and <code>b</code> consist&nbsp;only of <code>'0'</code> or <code>'1'</code> characters.</li>
+	<li>Each string does not contain leading zeros except for the zero itself.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/671-second-minimum-node-in-a-binary-tree.java b/leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/671-second-minimum-node-in-a-binary-tree.java
new file mode 100644
index 0000000..560a97d
--- /dev/null
+++ b/leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/671-second-minimum-node-in-a-binary-tree.java
@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int findSecondMinimumValue(TreeNode root) {
+        if(root==null || root.right==null || root.left==null) return -1;
+        Queue<TreeNode> q = new LinkedList<>();
+        q.add(root);
+        Integer secondMin = null;
+        while(q.size()!=0){
+            TreeNode front = q.remove();
+            if(front.left!=null) q.add(front.left);
+            if(front.right!=null) q.add(front.right);
+            if(front.val!=root.val) {
+			    if(secondMin==null) secondMin = front.val;
+			    else secondMin = Math.min(secondMin, front.val);
+		    }
+        }
+        return secondMin==null? -1 : secondMin;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/NOTES.md b/leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/README.md b/leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/README.md
new file mode 100644
index 0000000..269badf
--- /dev/null
+++ b/leetcode/leetcode/671-second-minimum-node-in-a-binary-tree/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/">671. Second Minimum Node In a Binary Tree</a></h2><h3>Easy</h3><hr><div><p>Given a non-empty special binary tree consisting of nodes with the non-negative value, where each node in this tree has exactly <code>two</code> or <code>zero</code> sub-node. If the node has two sub-nodes, then this node's value is the smaller value among its two sub-nodes. More formally, the property&nbsp;<code>root.val = min(root.left.val, root.right.val)</code>&nbsp;always holds.</p>
+
+<p>Given such a binary tree, you need to output the <b>second minimum</b> value in the set made of all the nodes' value in the whole tree.</p>
+
+<p>If no such second minimum value exists, output -1 instead.</p>
+
+<p>&nbsp;</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/15/smbt1.jpg" style="width: 431px; height: 302px;">
+<pre><strong>Input:</strong> root = [2,2,5,null,null,5,7]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The smallest value is 2, the second smallest value is 5.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/15/smbt2.jpg" style="width: 321px; height: 182px;">
+<pre><strong>Input:</strong> root = [2,2,2]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> The smallest value is 2, but there isn't any second smallest value.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 25]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>root.val == min(root.left.val, root.right.val)</code>&nbsp;for each internal node of the tree.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/695-max-area-of-island/695-max-area-of-island.java b/leetcode/leetcode/695-max-area-of-island/695-max-area-of-island.java
new file mode 100644
index 0000000..799d241
--- /dev/null
+++ b/leetcode/leetcode/695-max-area-of-island/695-max-area-of-island.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int helper(int[][] grid, int i, int j){
+        if(i<0 || i==grid.length || j<0 || j==grid[i].length) return 0;
+        if(grid[i][j] == 0) return 0;
+        grid[i][j] = 0;
+        return 1+helper(grid,i+1,j) + helper(grid,i,j+1) + helper(grid,i-1,j) + helper(grid,i,j-1);
+    }
+    public int maxAreaOfIsland(int[][] grid) {
+        int max = 0;
+        for(int i = 0;i<grid.length;i++){
+            for(int j = 0;j<grid[i].length;j++){
+                if(grid[i][j]==1) max = Math.max(max,helper(grid,i,j));
+            }
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/695-max-area-of-island/NOTES.md b/leetcode/leetcode/695-max-area-of-island/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/695-max-area-of-island/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/695-max-area-of-island/README.md b/leetcode/leetcode/695-max-area-of-island/README.md
new file mode 100644
index 0000000..e887ae2
--- /dev/null
+++ b/leetcode/leetcode/695-max-area-of-island/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/max-area-of-island/">695. Max Area of Island</a></h2><h3>Medium</h3><hr><div><p>You are given an <code>m x n</code> binary matrix <code>grid</code>. An island is a group of <code>1</code>'s (representing land) connected <strong>4-directionally</strong> (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.</p>
+
+<p>The <strong>area</strong> of an island is the number of cells with a value <code>1</code> in the island.</p>
+
+<p>Return <em>the maximum <strong>area</strong> of an island in </em><code>grid</code>. If there is no island, return <code>0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/05/01/maxarea1-grid.jpg" style="width: 500px; height: 310px;">
+<pre><strong>Input:</strong> grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The answer is not 11, because the island must be connected 4-directionally.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[0,0,0,0,0,0,0,0]]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 50</code></li>
+	<li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/70-climbing-stairs/70-climbing-stairs.java b/leetcode/leetcode/70-climbing-stairs/70-climbing-stairs.java
new file mode 100644
index 0000000..ca7e6e8
--- /dev/null
+++ b/leetcode/leetcode/70-climbing-stairs/70-climbing-stairs.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int climbStairs(int n) {
+        if(n < 3) return n;
+        int first = 1;
+        int second = 2;
+        int ans = first+second;
+        while(--n!=1){
+            ans = first+second;
+            first = second;
+            second = ans;
+        }
+        
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/70-climbing-stairs/README.md b/leetcode/leetcode/70-climbing-stairs/README.md
new file mode 100644
index 0000000..d3c4192
--- /dev/null
+++ b/leetcode/leetcode/70-climbing-stairs/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/climbing-stairs/">70. Climbing Stairs</a></h2><h3>Easy</h3><hr><div><p>You are climbing a staircase. It takes <code>n</code> steps to reach the top.</p>
+
+<p>Each time you can either climb <code>1</code> or <code>2</code> steps. In how many distinct ways can you climb to the top?</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There are two ways to climb to the top.
+1. 1 step + 1 step
+2. 2 steps
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> There are three ways to climb to the top.
+1. 1 step + 1 step + 1 step
+2. 1 step + 2 steps
+3. 2 steps + 1 step
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 45</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/700-search-in-a-binary-search-tree/700-search-in-a-binary-search-tree.java b/leetcode/leetcode/700-search-in-a-binary-search-tree/700-search-in-a-binary-search-tree.java
new file mode 100644
index 0000000..a09d23f
--- /dev/null
+++ b/leetcode/leetcode/700-search-in-a-binary-search-tree/700-search-in-a-binary-search-tree.java
@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode searchBST(TreeNode root, int val) {
+        if(root == null) return null;
+        if(root.val == val) return root;
+        else if(root.val> val) return searchBST(root.left,val);
+        return searchBST(root.right,val);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/700-search-in-a-binary-search-tree/NOTES.md b/leetcode/leetcode/700-search-in-a-binary-search-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/700-search-in-a-binary-search-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/700-search-in-a-binary-search-tree/README.md b/leetcode/leetcode/700-search-in-a-binary-search-tree/README.md
new file mode 100644
index 0000000..08be87e
--- /dev/null
+++ b/leetcode/leetcode/700-search-in-a-binary-search-tree/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/search-in-a-binary-search-tree/">700. Search in a Binary Search Tree</a></h2><h3>Easy</h3><hr><div><p>You are given the <code>root</code> of a binary search tree (BST) and an integer <code>val</code>.</p>
+
+<p>Find the node in the BST that the node's value equals <code>val</code> and return the subtree rooted with that node. If such a node does not exist, return <code>null</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/12/tree1.jpg" style="width: 422px; height: 302px;">
+<pre><strong>Input:</strong> root = [4,2,7,1,3], val = 2
+<strong>Output:</strong> [2,1,3]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/12/tree2.jpg" style="width: 422px; height: 302px;">
+<pre><strong>Input:</strong> root = [4,2,7,1,3], val = 5
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 5000]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>7</sup></code></li>
+	<li><code>root</code> is a binary search tree.</li>
+	<li><code>1 &lt;= val &lt;= 10<sup>7</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/701-insert-into-a-binary-search-tree/701-insert-into-a-binary-search-tree.java b/leetcode/leetcode/701-insert-into-a-binary-search-tree/701-insert-into-a-binary-search-tree.java
new file mode 100644
index 0000000..ccd3d71
--- /dev/null
+++ b/leetcode/leetcode/701-insert-into-a-binary-search-tree/701-insert-into-a-binary-search-tree.java
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode insertIntoBST(TreeNode root, int val) {
+        if(root == null) return new TreeNode(val);
+        if(val>root.val){
+            root.right = insertIntoBST(root.right,val);
+        }else{
+            root.left = insertIntoBST(root.left,val);
+        }
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/701-insert-into-a-binary-search-tree/NOTES.md b/leetcode/leetcode/701-insert-into-a-binary-search-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/701-insert-into-a-binary-search-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/701-insert-into-a-binary-search-tree/README.md b/leetcode/leetcode/701-insert-into-a-binary-search-tree/README.md
new file mode 100644
index 0000000..a5872f9
--- /dev/null
+++ b/leetcode/leetcode/701-insert-into-a-binary-search-tree/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/insert-into-a-binary-search-tree/">701. Insert into a Binary Search Tree</a></h2><h3>Medium</h3><hr><div><p>You are given the <code>root</code> node of a binary search tree (BST) and a <code>value</code> to insert into the tree. Return <em>the root node of the BST after the insertion</em>. It is <strong>guaranteed</strong> that the new value does not exist in the original BST.</p>
+
+<p><strong>Notice</strong>&nbsp;that there may exist&nbsp;multiple valid ways for the&nbsp;insertion, as long as the tree remains a BST after insertion. You can return <strong>any of them</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/05/insertbst.jpg" style="width: 752px; height: 221px;">
+<pre><strong>Input:</strong> root = [4,2,7,1,3], val = 5
+<strong>Output:</strong> [4,2,7,1,3,5]
+<strong>Explanation:</strong> Another accepted tree is:
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/05/bst.jpg" style="width: 352px; height: 301px;">
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [40,20,60,10,30,50,70], val = 25
+<strong>Output:</strong> [40,20,60,10,30,50,70,null,null,25]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
+<strong>Output:</strong> [4,2,7,1,3,5]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in&nbsp;the tree will be in the range <code>[0,&nbsp;10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>8</sup> &lt;= Node.val &lt;= 10<sup>8</sup></code></li>
+	<li>All the values <code>Node.val</code> are <strong>unique</strong>.</li>
+	<li><code>-10<sup>8</sup> &lt;= val &lt;= 10<sup>8</sup></code></li>
+	<li>It's <strong>guaranteed</strong> that <code>val</code> does not exist in the original BST.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/704-binary-search/704-binary-search.java b/leetcode/leetcode/704-binary-search/704-binary-search.java
new file mode 100644
index 0000000..5ccc190
--- /dev/null
+++ b/leetcode/leetcode/704-binary-search/704-binary-search.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int search(int[] nums, int target) {
+        int low = 0;
+        int high = nums.length - 1;
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(nums[mid] == target){
+                return mid;
+            } else if(nums[mid] > target){
+                high  = mid-1;
+            } else{
+                low = mid+1;
+            }
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/704-binary-search/NOTES.md b/leetcode/leetcode/704-binary-search/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/704-binary-search/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/704-binary-search/README.md b/leetcode/leetcode/704-binary-search/README.md
new file mode 100644
index 0000000..4ecd7d9
--- /dev/null
+++ b/leetcode/leetcode/704-binary-search/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/binary-search/">704. Binary Search</a></h2><h3>Easy</h3><hr><div><p>Given an array of integers <code>nums</code> which is sorted in ascending order, and an integer <code>target</code>, write a function to search <code>target</code> in <code>nums</code>. If <code>target</code> exists, then return its index. Otherwise, return <code>-1</code>.</p>
+
+<p>You must write an algorithm with <code>O(log n)</code> runtime complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,0,3,5,9,12], target = 9
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> 9 exists in nums and its index is 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,0,3,5,9,12], target = 2
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> 2 does not exist in nums so return -1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt; nums[i], target &lt; 10<sup>4</sup></code></li>
+	<li>All the integers in <code>nums</code> are <strong>unique</strong>.</li>
+	<li><code>nums</code> is sorted in ascending order.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/709-to-lower-case/709-to-lower-case.java b/leetcode/leetcode/709-to-lower-case/709-to-lower-case.java
new file mode 100644
index 0000000..78724c4
--- /dev/null
+++ b/leetcode/leetcode/709-to-lower-case/709-to-lower-case.java
@@ -0,0 +1,5 @@
+class Solution {
+    public String toLowerCase(String s) {
+        return s.toLowerCase();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/709-to-lower-case/NOTES.md b/leetcode/leetcode/709-to-lower-case/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/709-to-lower-case/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/709-to-lower-case/README.md b/leetcode/leetcode/709-to-lower-case/README.md
new file mode 100644
index 0000000..c4c75f2
--- /dev/null
+++ b/leetcode/leetcode/709-to-lower-case/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/to-lower-case/">709. To Lower Case</a></h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code>, return <em>the string after replacing every uppercase letter with the same lowercase letter</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "Hello"
+<strong>Output:</strong> "hello"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "here"
+<strong>Output:</strong> "here"
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "LOVELY"
+<strong>Output:</strong> "lovely"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 100</code></li>
+	<li><code>s</code> consists of printable ASCII characters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/72-edit-distance/72-edit-distance.java b/leetcode/leetcode/72-edit-distance/72-edit-distance.java
new file mode 100644
index 0000000..282d206
--- /dev/null
+++ b/leetcode/leetcode/72-edit-distance/72-edit-distance.java
@@ -0,0 +1,30 @@
+class Solution {
+    public int helper(String word1, String word2, int i, int j, int[][] dp){
+        if(dp[i][j]!=-1) return dp[i][j];
+        if(i == word1.length() && j == word2.length()) return 0;
+        if(i == word1.length() && j!=word2.length()){
+            return word2.length() - j;
+        }
+        if(i!=word1.length() && j == word2.length()){
+            return word1.length() - i;
+        }
+        int ans = Integer.MAX_VALUE;
+        if(word1.charAt(i) == word2.charAt(j)){
+            ans  = helper(word1,word2,i+1,j+1,dp);
+        }else{
+            ans = 1+Math.min(helper(word1,word2,i+1,j+1,dp),Math.min(helper(word1,word2,i,j+1,dp),helper(word1,word2,i+1,j,dp)));
+        }
+        dp[i][j] = ans;
+        return dp[i][j];
+        
+    }
+    public int minDistance(String word1, String word2) {
+        int[][] dp = new int[word1.length()+1][word2.length()+1];
+        for(int i = 0;i<=word1.length();i++){
+            for(int j = 0;j<=word2.length();j++){
+                dp[i][j] = -1;
+            }
+        }
+        return helper(word1,word2,0,0,dp);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/72-edit-distance/NOTES.md b/leetcode/leetcode/72-edit-distance/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/72-edit-distance/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/72-edit-distance/README.md b/leetcode/leetcode/72-edit-distance/README.md
new file mode 100644
index 0000000..aa50d5e
--- /dev/null
+++ b/leetcode/leetcode/72-edit-distance/README.md
@@ -0,0 +1,41 @@
+<h2><a href="https://leetcode.com/problems/edit-distance/">72. Edit Distance</a></h2><h3>Hard</h3><hr><div><p>Given two strings <code>word1</code> and <code>word2</code>, return <em>the minimum number of operations required to convert <code>word1</code> to <code>word2</code></em>.</p>
+
+<p>You have the following three operations permitted on a word:</p>
+
+<ul>
+	<li>Insert a character</li>
+	<li>Delete a character</li>
+	<li>Replace a character</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> word1 = "horse", word2 = "ros"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 
+horse -&gt; rorse (replace 'h' with 'r')
+rorse -&gt; rose (remove 'r')
+rose -&gt; ros (remove 'e')
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> word1 = "intention", word2 = "execution"
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> 
+intention -&gt; inention (remove 't')
+inention -&gt; enention (replace 'i' with 'e')
+enention -&gt; exention (replace 'n' with 'x')
+exention -&gt; exection (replace 'n' with 'c')
+exection -&gt; execution (insert 'u')
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= word1.length, word2.length &lt;= 500</code></li>
+	<li><code>word1</code> and <code>word2</code> consist of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/73-set-matrix-zeroes/73-set-matrix-zeroes.java b/leetcode/leetcode/73-set-matrix-zeroes/73-set-matrix-zeroes.java
new file mode 100644
index 0000000..57e80df
--- /dev/null
+++ b/leetcode/leetcode/73-set-matrix-zeroes/73-set-matrix-zeroes.java
@@ -0,0 +1,53 @@
+class Solution {
+    
+    public void setZeroes(int[][] matrix) {
+        Boolean isRow = false;
+        Boolean isCol = false;
+        for(int i = 0;i<matrix[0].length;i++){
+            if(matrix[0][i]==0){
+                isRow = true;
+                break;
+            }
+        }
+        for(int i = 0;i<matrix.length;i++){
+            if(matrix[i][0] == 0){
+                isCol = true;
+                break;
+            }
+        }
+        for(int i = 1;i<matrix.length;i++){
+            for(int j = 1;j<matrix[0].length;j++){
+                if(matrix[i][j] == 0){
+                    matrix[i][0] = 0;
+                    matrix[0][j] = 0;
+                }
+            }
+        }
+        for(int i = 1;i<matrix[0].length;i++){
+            if(matrix[0][i] == 0){
+                for(int j = 1;j<matrix.length;j++){
+                    matrix[j][i] = 0;
+                }
+            }
+        }
+        for(int i = 1;i<matrix.length;i++){
+            if(matrix[i][0] == 0){
+                for(int j = 1;j<matrix[0].length;j++){
+                    matrix[i][j] = 0;
+                }
+            }
+        }
+        if(isRow){
+            for(int i = 0;i<matrix[0].length;i++){
+                matrix[0][i] = 0;
+            }
+        }
+        if(isCol){
+            for(int i = 0;i<matrix.length;i++){
+                matrix[i][0] = 0;
+            }
+        }
+        
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/73-set-matrix-zeroes/NOTES.md b/leetcode/leetcode/73-set-matrix-zeroes/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/73-set-matrix-zeroes/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/73-set-matrix-zeroes/README.md b/leetcode/leetcode/73-set-matrix-zeroes/README.md
new file mode 100644
index 0000000..28f107f
--- /dev/null
+++ b/leetcode/leetcode/73-set-matrix-zeroes/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/set-matrix-zeroes/">73. Set Matrix Zeroes</a></h2><h3>Medium</h3><hr><div><p>Given an <code>m x n</code> integer matrix <code>matrix</code>, if an element is <code>0</code>, set its entire row and column to <code>0</code>'s, and return <em>the matrix</em>.</p>
+
+<p>You must do it <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in place</a>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/17/mat1.jpg" style="width: 450px; height: 169px;">
+<pre><strong>Input:</strong> matrix = [[1,1,1],[1,0,1],[1,1,1]]
+<strong>Output:</strong> [[1,0,1],[0,0,0],[1,0,1]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/17/mat2.jpg" style="width: 450px; height: 137px;">
+<pre><strong>Input:</strong> matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+<strong>Output:</strong> [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == matrix.length</code></li>
+	<li><code>n == matrix[0].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 200</code></li>
+	<li><code>-2<sup>31</sup> &lt;= matrix[i][j] &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>A straightforward solution using <code>O(mn)</code> space is probably a bad idea.</li>
+	<li>A simple improvement uses <code>O(m + n)</code> space, but still not the best solution.</li>
+	<li>Could you devise a constant space solution?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/735-asteroid-collision/735-asteroid-collision.java b/leetcode/leetcode/735-asteroid-collision/735-asteroid-collision.java
new file mode 100644
index 0000000..fa37314
--- /dev/null
+++ b/leetcode/leetcode/735-asteroid-collision/735-asteroid-collision.java
@@ -0,0 +1,39 @@
+class Solution {
+    public int[] asteroidCollision(int[] asteroids) {
+        Stack<Integer> s = new Stack<>();
+        int i = 0;
+        while(i<asteroids.length){
+            int val = asteroids[i];
+            if(s.isEmpty()){
+                s.push(val);
+                i++;
+                continue;
+            }
+            else if(s.peek()>0 && val<0){
+                while(!s.isEmpty()){
+                    if(s.peek() + val == 0){
+                        s.pop();
+                        i++;
+                        break;
+                    }else if(s.peek()>-val){
+                        i++;
+                        break;
+                    }else if(s.peek()<0 && val<0){
+                        // s.push(val);
+                        break;
+                    }else{
+                        s.pop();
+                    }
+                }
+                continue;
+            }
+            s.push(val);
+            i++;
+        }
+        int[] res = new int[s.size()];
+        for(i = res.length - 1;i!=-1;i--){
+            res[i] = s.pop();
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/735-asteroid-collision/NOTES.md b/leetcode/leetcode/735-asteroid-collision/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/735-asteroid-collision/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/739-daily-temperatures/739-daily-temperatures.java b/leetcode/leetcode/739-daily-temperatures/739-daily-temperatures.java
new file mode 100644
index 0000000..e1e3fdb
--- /dev/null
+++ b/leetcode/leetcode/739-daily-temperatures/739-daily-temperatures.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int[] dailyTemperatures(int[] temperatures) {
+        int[] res = new int[temperatures.length];
+        Stack<Integer> s = new Stack<>();
+        for(int i = 0;i<temperatures.length;){
+            if(s.empty()) {
+                s.push(i);
+                i++;
+            }
+            if(i == temperatures.length) break;
+            if(temperatures[s.peek()]>=temperatures[i]){
+                s.push(i);
+                i++;
+            }else{
+                res[s.peek()] = i - s.peek();
+                s.pop();
+                
+            }
+        }
+        return res;
+    }
+}
diff --git a/leetcode/leetcode/739-daily-temperatures/NOTES.md b/leetcode/leetcode/739-daily-temperatures/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/739-daily-temperatures/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/739-daily-temperatures/README.md b/leetcode/leetcode/739-daily-temperatures/README.md
new file mode 100644
index 0000000..0308368
--- /dev/null
+++ b/leetcode/leetcode/739-daily-temperatures/README.md
@@ -0,0 +1,21 @@
+<h2><a href="https://leetcode.com/problems/daily-temperatures/">739. Daily Temperatures</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>temperatures</code> represents the daily temperatures, return <em>an array</em> <code>answer</code> <em>such that</em> <code>answer[i]</code> <em>is the number of days you have to wait after the</em> <code>i<sup>th</sup></code> <em>day to get a warmer temperature</em>. If there is no future day for which this is possible, keep <code>answer[i] == 0</code> instead.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> temperatures = [73,74,75,71,69,72,76,73]
+<strong>Output:</strong> [1,1,4,2,1,1,0,0]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> temperatures = [30,40,50,60]
+<strong>Output:</strong> [1,1,1,0]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> temperatures = [30,60,90]
+<strong>Output:</strong> [1,1,0]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;=&nbsp;temperatures.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>30 &lt;=&nbsp;temperatures[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/74-search-a-2d-matrix/74-search-a-2d-matrix.java b/leetcode/leetcode/74-search-a-2d-matrix/74-search-a-2d-matrix.java
new file mode 100644
index 0000000..ca7fcdd
--- /dev/null
+++ b/leetcode/leetcode/74-search-a-2d-matrix/74-search-a-2d-matrix.java
@@ -0,0 +1,20 @@
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int row = matrix.length;
+        int col = matrix[0].length;
+        for(int i = 0;i<row;i++){
+            if(matrix[i][col-1]>=target ){
+                row = 0;
+                col = matrix[0].length -1;
+                while(row<=col){
+                    int mid = (row+col)/2;
+                    if(matrix[i][mid]==target) return true;
+                    else if(matrix[i][mid]>target) col = mid-1;
+                    else row = mid+1;
+                }
+                return false;
+            }
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/74-search-a-2d-matrix/NOTES.md b/leetcode/leetcode/74-search-a-2d-matrix/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/74-search-a-2d-matrix/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/74-search-a-2d-matrix/README.md b/leetcode/leetcode/74-search-a-2d-matrix/README.md
new file mode 100644
index 0000000..5a3025a
--- /dev/null
+++ b/leetcode/leetcode/74-search-a-2d-matrix/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/search-a-2d-matrix/">74. Search a 2D Matrix</a></h2><h3>Medium</h3><hr><div><p>Write an efficient algorithm that searches for a value in an <code>m x n</code> matrix. This matrix has the following properties:</p>
+
+<ul>
+	<li>Integers in each row are sorted from left to right.</li>
+	<li>The first integer of each row is greater than the last integer of the previous row.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/05/mat.jpg" style="width: 322px; height: 242px;">
+<pre><strong>Input:</strong> matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/05/mat2.jpg" style="width: 322px; height: 242px;">
+<pre><strong>Input:</strong> matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == matrix.length</code></li>
+	<li><code>n == matrix[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 100</code></li>
+	<li><code>-10<sup>4</sup> &lt;= matrix[i][j], target &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/740-delete-and-earn/740-delete-and-earn.java b/leetcode/leetcode/740-delete-and-earn/740-delete-and-earn.java
new file mode 100644
index 0000000..f5a259f
--- /dev/null
+++ b/leetcode/leetcode/740-delete-and-earn/740-delete-and-earn.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int deleteAndEarn(int[] nums) {
+        int[] freq = new int[100001];
+        for(int num: nums){
+            freq[num]++;
+        }
+        int inc = 0;
+        int exc = 0;
+        for(int i = 0;i<=10000;i++){
+            int ni = exc+freq[i]*i;
+            int ne = Math.max(inc,exc);
+            inc = ni;
+            exc = ne;
+        }
+        return Math.max(inc,exc);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/740-delete-and-earn/README.md b/leetcode/leetcode/740-delete-and-earn/README.md
new file mode 100644
index 0000000..8cab44f
--- /dev/null
+++ b/leetcode/leetcode/740-delete-and-earn/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/delete-and-earn/">740. Delete and Earn</a></h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>nums</code>. You want to maximize the number of points you get by performing the following operation any number of times:</p>
+
+<ul>
+	<li>Pick any <code>nums[i]</code> and delete it to earn <code>nums[i]</code> points. Afterwards, you must delete <b>every</b> element equal to <code>nums[i] - 1</code> and <strong>every</strong> element equal to <code>nums[i] + 1</code>.</li>
+</ul>
+
+<p>Return <em>the <strong>maximum number of points</strong> you can earn by applying the above operation some number of times</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,4,2]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> You can perform the following operations:
+- Delete 4 to earn 4 points. Consequently, 3 is also deleted. nums = [2].
+- Delete 2 to earn 2 points. nums = [].
+You earn a total of 6 points.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,2,3,3,3,4]
+<strong>Output:</strong> 9
+<strong>Explanation:</strong> You can perform the following operations:
+- Delete a 3 to earn 3 points. All 2's and 4's are also deleted. nums = [3,3].
+- Delete a 3 again to earn 3 points. nums = [3].
+- Delete a 3 once more to earn 3 points. nums = [].
+You earn a total of 9 points.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/746-min-cost-climbing-stairs/746-min-cost-climbing-stairs.java b/leetcode/leetcode/746-min-cost-climbing-stairs/746-min-cost-climbing-stairs.java
new file mode 100644
index 0000000..686b4f9
--- /dev/null
+++ b/leetcode/leetcode/746-min-cost-climbing-stairs/746-min-cost-climbing-stairs.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int minCost(int[] cost, int currentIndex, int[] dp){
+        if(currentIndex>=cost.length) return 0;
+        if(currentIndex  == cost.length - 1) return cost[currentIndex];
+        if(dp[currentIndex]!=-1) return dp[currentIndex];
+        int ans = Integer.MAX_VALUE;
+        if(dp[currentIndex+1] != -1) ans = Math.min(ans,dp[currentIndex+1]);
+        else ans = Math.min(ans,minCost(cost,currentIndex+1,dp));
+        if(dp[currentIndex+2] != -1) ans = Math.min(ans,dp[currentIndex+2]);
+        else ans = Math.min(ans,minCost(cost,currentIndex+2,dp));
+        dp[currentIndex] = cost[currentIndex] +  ans;
+        return dp[currentIndex];
+    }
+    public int minCostClimbingStairs(int[] cost) {
+        int[] dp = new int[cost.length+2];
+        for(int i = 0;i<cost.length;i++) dp[i] = -1; 
+        return Math.min(minCost(cost,0,dp),minCost(cost,1,dp));        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/746-min-cost-climbing-stairs/NOTES.md b/leetcode/leetcode/746-min-cost-climbing-stairs/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/746-min-cost-climbing-stairs/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/746-min-cost-climbing-stairs/README.md b/leetcode/leetcode/746-min-cost-climbing-stairs/README.md
new file mode 100644
index 0000000..6d2d0bc
--- /dev/null
+++ b/leetcode/leetcode/746-min-cost-climbing-stairs/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/min-cost-climbing-stairs/">746. Min Cost Climbing Stairs</a></h2><h3>Easy</h3><hr><div><p>You are given an integer array <code>cost</code> where <code>cost[i]</code> is the cost of <code>i<sup>th</sup></code> step on a staircase. Once you pay the cost, you can either climb one or two steps.</p>
+
+<p>You can either start from the step with index <code>0</code>, or the step with index <code>1</code>.</p>
+
+<p>Return <em>the minimum cost to reach the top of the floor</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> cost = [10,<u>15</u>,20]
+<strong>Output:</strong> 15
+<strong>Explanation:</strong> You will start at index 1.
+- Pay 15 and climb two steps to reach the top.
+The total cost is 15.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> cost = [<u>1</u>,100,<u>1</u>,1,<u>1</u>,100,<u>1</u>,<u>1</u>,100,<u>1</u>]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> You will start at index 0.
+- Pay 1 and climb two steps to reach index 2.
+- Pay 1 and climb two steps to reach index 4.
+- Pay 1 and climb two steps to reach index 6.
+- Pay 1 and climb one step to reach index 7.
+- Pay 1 and climb two steps to reach index 9.
+- Pay 1 and climb one step to reach the top.
+The total cost is 6.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= cost.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= cost[i] &lt;= 999</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/747-largest-number-at-least-twice-of-others/747-largest-number-at-least-twice-of-others.java b/leetcode/leetcode/747-largest-number-at-least-twice-of-others/747-largest-number-at-least-twice-of-others.java
new file mode 100644
index 0000000..3c6a88d
--- /dev/null
+++ b/leetcode/leetcode/747-largest-number-at-least-twice-of-others/747-largest-number-at-least-twice-of-others.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int dominantIndex(int[] arr) {
+        int largest = 0;
+        int secondLargest = -1;
+        for(int i = 1;i<arr.length;i++){
+            if(arr[i]>arr[largest]){
+                secondLargest = arr[largest];
+                largest = i;
+            }else if(arr[i]>secondLargest){
+                secondLargest = arr[i];
+            }
+        }
+        if(arr[largest]>=2*secondLargest) return largest;
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/747-largest-number-at-least-twice-of-others/NOTES.md b/leetcode/leetcode/747-largest-number-at-least-twice-of-others/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/747-largest-number-at-least-twice-of-others/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/747-largest-number-at-least-twice-of-others/README.md b/leetcode/leetcode/747-largest-number-at-least-twice-of-others/README.md
new file mode 100644
index 0000000..2539f7d
--- /dev/null
+++ b/leetcode/leetcode/747-largest-number-at-least-twice-of-others/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/largest-number-at-least-twice-of-others/">747. Largest Number At Least Twice of Others</a></h2><h3>Easy</h3><hr><div><p>You are given an integer array <code>nums</code> where the largest integer is <strong>unique</strong>.</p>
+
+<p>Determine whether the largest element in the array is <strong>at least twice</strong> as much as every other number in the array. If it is, return <em>the <strong>index</strong> of the largest element, or return </em><code>-1</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,6,1,0]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> 6 is the largest integer.
+For every other number in the array x, 6 is at least twice as big as x.
+The index of value 6 is 1, so we return 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> 4 is less than twice the value of 3, so we return -1.</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> 1 is trivially at least twice the value as any other number because there are no other numbers.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 50</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 100</code></li>
+	<li>The largest element in <code>nums</code> is unique.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/75-sort-colors/75-sort-colors.java b/leetcode/leetcode/75-sort-colors/75-sort-colors.java
new file mode 100644
index 0000000..9401777
--- /dev/null
+++ b/leetcode/leetcode/75-sort-colors/75-sort-colors.java
@@ -0,0 +1,24 @@
+class Solution { 
+    private void swap(int[] arr, int i,int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    public void sortColors(int[] nums) {
+        int left = 0;
+        int right = nums.length  -1;
+        int current = 0;
+        while(current<=right){
+            if(nums[current] == 0){
+                swap(nums,left,current);
+                left++;
+                current++;
+            }else if(nums[current] == 2){
+                swap(nums,right, current);
+                right--;
+            }else{
+                current++;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/75-sort-colors/NOTES.md b/leetcode/leetcode/75-sort-colors/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/75-sort-colors/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/75-sort-colors/README.md b/leetcode/leetcode/75-sort-colors/README.md
new file mode 100644
index 0000000..2505728
--- /dev/null
+++ b/leetcode/leetcode/75-sort-colors/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/sort-colors/">75. Sort Colors</a></h2><h3>Medium</h3><hr><div><p>Given an array <code>nums</code> with <code>n</code> objects colored red, white, or blue, sort them <strong><a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> </strong>so that objects of the same color are adjacent, with the colors in the order red, white, and blue.</p>
+
+<p>We will use the integers <code>0</code>, <code>1</code>, and <code>2</code> to represent the color red, white, and blue, respectively.</p>
+
+<p>You must solve this problem without using the library's sort function.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,0,2,1,1,0]
+<strong>Output:</strong> [0,0,1,1,2,2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,0,1]
+<strong>Output:</strong> [0,1,2]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 300</code></li>
+	<li><code>nums[i]</code> is either <code>0</code>, <code>1</code>, or <code>2</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong>&nbsp;Could you come up with a one-pass algorithm using only&nbsp;constant extra space?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/78-subsets/78-subsets.java b/leetcode/leetcode/78-subsets/78-subsets.java
new file mode 100644
index 0000000..a860c57
--- /dev/null
+++ b/leetcode/leetcode/78-subsets/78-subsets.java
@@ -0,0 +1,26 @@
+class Solution {
+    public List<List<Integer>> subsetHelper(int[] nums, int currentIndex){
+        List<List<Integer>> list =  new ArrayList<>();
+        if(currentIndex==nums.length) return list;
+        if(currentIndex == nums.length - 1){
+            List<Integer>  temp = new ArrayList<>(1);
+            temp.add(nums[currentIndex]);
+            list.add(temp);
+            List<Integer> temp2 = new ArrayList<>();
+            list.add(temp2);
+            return list;
+            
+        }
+        list.addAll(subsetHelper(nums,currentIndex+1));
+        int size = list.size();
+        for(int i = 0;i<size;i++){
+            List<Integer> temp = new ArrayList<>(list.get(i));
+            temp.add(nums[currentIndex]);
+            list.add(temp);
+        }
+        return list;
+    }
+    public List<List<Integer>> subsets(int[] nums) {
+        return subsetHelper(nums,0);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/78-subsets/NOTES.md b/leetcode/leetcode/78-subsets/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/78-subsets/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/78-subsets/README.md b/leetcode/leetcode/78-subsets/README.md
new file mode 100644
index 0000000..9a28b51
--- /dev/null
+++ b/leetcode/leetcode/78-subsets/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/subsets/">78. Subsets</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> of <strong>unique</strong> elements, return <em>all possible subsets (the power set)</em>.</p>
+
+<p>The solution set <strong>must not</strong> contain duplicate subsets. Return the solution in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0]
+<strong>Output:</strong> [[],[0]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10</code></li>
+	<li><code>-10 &lt;= nums[i] &lt;= 10</code></li>
+	<li>All the numbers of&nbsp;<code>nums</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/79-word-search/79-word-search.java b/leetcode/leetcode/79-word-search/79-word-search.java
new file mode 100644
index 0000000..691b436
--- /dev/null
+++ b/leetcode/leetcode/79-word-search/79-word-search.java
@@ -0,0 +1,26 @@
+class Solution {
+    public boolean helper(char[][] board, String word, int row, int col){
+        if(word.length()==0) return true;
+        if(row<0 || col<0 || row==board.length || col ==board[0].length) return false;
+        if(board[row][col]=='0') return false;
+        if(word.charAt(0) == board[row][col]){
+            board[row][col] = '0';
+            boolean ans = helper(board,word.substring(1,word.length()),row+1,col) ||
+                helper(board,word.substring(1,word.length()),row,col+1)||
+                helper(board,word.substring(1,word.length()),row-1,col)||
+                helper(board,word.substring(1,word.length()),row,col-1);
+            if(ans) return ans;
+            board[row][col] = word.charAt(0);
+        }
+        return false;
+    }
+    public boolean exist(char[][] board, String word) {
+        for(int i = 0;i<board.length;i++){
+            for(int j = 0;j<board[0].length;j++){
+                boolean ans = helper(board, word, i,j);
+                if(ans) return ans;
+            }
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/79-word-search/NOTES.md b/leetcode/leetcode/79-word-search/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/79-word-search/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/79-word-search/README.md b/leetcode/leetcode/79-word-search/README.md
new file mode 100644
index 0000000..d9c5c62
--- /dev/null
+++ b/leetcode/leetcode/79-word-search/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/word-search/">79. Word Search</a></h2><h3>Medium</h3><hr><div><p>Given an <code>m x n</code> grid of characters <code>board</code> and a string <code>word</code>, return <code>true</code> <em>if</em> <code>word</code> <em>exists in the grid</em>.</p>
+
+<p>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.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/word2.jpg" style="width: 322px; height: 242px;">
+<pre><strong>Input:</strong> board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/04/word-1.jpg" style="width: 322px; height: 242px;">
+<pre><strong>Input:</strong> board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/15/word3.jpg" style="width: 322px; height: 242px;">
+<pre><strong>Input:</strong> board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == board.length</code></li>
+	<li><code>n = board[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 6</code></li>
+	<li><code>1 &lt;= word.length &lt;= 15</code></li>
+	<li><code>board</code> and <code>word</code> consists of only lowercase and uppercase English letters.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you use search pruning to make your solution faster with a larger <code>board</code>?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/799-champagne-tower/799-champagne-tower.java b/leetcode/leetcode/799-champagne-tower/799-champagne-tower.java
new file mode 100644
index 0000000..e57a388
--- /dev/null
+++ b/leetcode/leetcode/799-champagne-tower/799-champagne-tower.java
@@ -0,0 +1,17 @@
+class Solution {
+    public double champagneTower(int poured, int query_row, int query_glass) {
+        double[][] A = new double[102][102];
+        A[0][0] = (double) poured;
+        for (int r = 0; r <= query_row; ++r) {
+            for (int c = 0; c <= r; ++c) {
+                double q = (A[r][c] - 1.0) / 2.0;
+                if (q > 0) {
+                    A[r+1][c] += q;
+                    A[r+1][c+1] += q;
+                }
+            }
+        }
+
+        return Math.min(1, A[query_row][query_glass]);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/799-champagne-tower/NOTES.md b/leetcode/leetcode/799-champagne-tower/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/799-champagne-tower/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/799-champagne-tower/README.md b/leetcode/leetcode/799-champagne-tower/README.md
new file mode 100644
index 0000000..0a05ee4
--- /dev/null
+++ b/leetcode/leetcode/799-champagne-tower/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/champagne-tower/">799. Champagne Tower</a></h2><h3>Medium</h3><hr><div><p>We stack glasses in a pyramid, where the <strong>first</strong> row has <code>1</code> glass, the <strong>second</strong> row has <code>2</code> glasses, and so on until the 100<sup>th</sup> row.&nbsp; Each glass holds one cup&nbsp;of champagne.</p>
+
+<p>Then, some champagne is poured into the first glass at the top.&nbsp; When the topmost glass is full, any excess liquid poured will fall equally to the glass immediately to the left and right of it.&nbsp; When those glasses become full, any excess champagne will fall equally to the left and right of those glasses, and so on.&nbsp; (A glass at the bottom row has its excess champagne fall on the floor.)</p>
+
+<p>For example, after one cup of champagne is poured, the top most glass is full.&nbsp; After two cups of champagne are poured, the two glasses on the second row are half full.&nbsp; After three cups of champagne are poured, those two cups become full - there are 3 full glasses total now.&nbsp; After four cups of champagne are poured, the third row has the middle glass half full, and the two outside glasses are a quarter full, as pictured below.</p>
+
+<p><img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/03/09/tower.png" style="height: 241px; width: 350px;"></p>
+
+<p>Now after pouring some non-negative integer cups of champagne, return how full the <code>j<sup>th</sup></code> glass in the <code>i<sup>th</sup></code> row is (both <code>i</code> and <code>j</code> are 0-indexed.)</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> poured = 1, query_row = 1, query_glass = 1
+<strong>Output:</strong> 0.00000
+<strong>Explanation:</strong> We poured 1 cup of champange to the top glass of the tower (which is indexed as (0, 0)). There will be no excess liquid so all the glasses under the top glass will remain empty.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> poured = 2, query_row = 1, query_glass = 1
+<strong>Output:</strong> 0.50000
+<strong>Explanation:</strong> We poured 2 cups of champange to the top glass of the tower (which is indexed as (0, 0)). There is one cup of excess liquid. The glass indexed as (1, 0) and the glass indexed as (1, 1) will share the excess liquid equally, and each will get half cup of champange.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> poured = 100000009, query_row = 33, query_glass = 17
+<strong>Output:</strong> 1.00000
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;=&nbsp;poured &lt;= 10<sup>9</sup></code></li>
+	<li><code>0 &lt;= query_glass &lt;= query_row&nbsp;&lt; 100</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/8-string-to-integer-atoi/8-string-to-integer-atoi.java b/leetcode/leetcode/8-string-to-integer-atoi/8-string-to-integer-atoi.java
new file mode 100644
index 0000000..9a94f57
--- /dev/null
+++ b/leetcode/leetcode/8-string-to-integer-atoi/8-string-to-integer-atoi.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int myAtoi(String s) {
+        boolean neg = false;
+        int len = s.length();
+        
+        int res = 0;
+        int index = 0;
+        while(index<len && s.charAt(index)==' ') ++index;
+        if(index<len && s.charAt(index)=='-'){
+            neg = true;
+            ++index;
+        }else if(index<len && s.charAt(index)=='+') ++index;
+        while(index<len){
+            char ch = s.charAt(index);
+            if(!Character.isDigit(ch)) break;
+            int digit = ch - '0';
+            if ((res > Integer.MAX_VALUE / 10) || 
+                (res == Integer.MAX_VALUE / 10 && digit > Integer.MAX_VALUE % 10)) {     
+                // If integer overflowed return 2^31-1, otherwise if underflowed return -2^31.    
+                return !neg ? Integer.MAX_VALUE : Integer.MIN_VALUE;
+            }
+            res = res*10 + digit;
+            ++index;
+            
+        }
+        return neg ? -res : res;
+    }
+                    
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/8-string-to-integer-atoi/NOTES.md b/leetcode/leetcode/8-string-to-integer-atoi/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/8-string-to-integer-atoi/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/8-string-to-integer-atoi/README.md b/leetcode/leetcode/8-string-to-integer-atoi/README.md
new file mode 100644
index 0000000..3866ace
--- /dev/null
+++ b/leetcode/leetcode/8-string-to-integer-atoi/README.md
@@ -0,0 +1,74 @@
+<h2><a href="https://leetcode.com/problems/string-to-integer-atoi/">8. String to Integer (atoi)</a></h2><h3>Medium</h3><hr><div><p>Implement the <code>myAtoi(string s)</code> function, which converts a string to a 32-bit signed integer (similar to C/C++'s <code>atoi</code> function).</p>
+
+<p>The algorithm for <code>myAtoi(string s)</code> is as follows:</p>
+
+<ol>
+	<li>Read in and ignore any leading whitespace.</li>
+	<li>Check if the next character (if not already at the end of the string) is <code>'-'</code> or <code>'+'</code>. Read this character in if it is either. This determines if the final result is negative or positive respectively. Assume the result is positive if neither is present.</li>
+	<li>Read in next the characters until the next non-digit character or the end of the input is reached. The rest of the string is ignored.</li>
+	<li>Convert these digits into an integer (i.e. <code>"123" -&gt; 123</code>, <code>"0032" -&gt; 32</code>). If no digits were read, then the integer is <code>0</code>. Change the sign as necessary (from step 2).</li>
+	<li>If the integer is out of the 32-bit signed integer range <code>[-2<sup>31</sup>, 2<sup>31</sup> - 1]</code>, then clamp the integer so that it remains in the range. Specifically, integers less than <code>-2<sup>31</sup></code> should be clamped to <code>-2<sup>31</sup></code>, and integers greater than <code>2<sup>31</sup> - 1</code> should be clamped to <code>2<sup>31</sup> - 1</code>.</li>
+	<li>Return the integer as the final result.</li>
+</ol>
+
+<p><strong>Note:</strong></p>
+
+<ul>
+	<li>Only the space character <code>' '</code> is considered a whitespace character.</li>
+	<li><strong>Do not ignore</strong> any characters other than the leading whitespace or the rest of the string after the digits.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "42"
+<strong>Output:</strong> 42
+<strong>Explanation:</strong> The underlined characters are what is read in, the caret is the current reader position.
+Step 1: "42" (no characters read because there is no leading whitespace)
+         ^
+Step 2: "42" (no characters read because there is neither a '-' nor '+')
+         ^
+Step 3: "<u>42</u>" ("42" is read in)
+           ^
+The parsed integer is 42.
+Since 42 is in the range [-2<sup>31</sup>, 2<sup>31</sup> - 1], the final result is 42.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "   -42"
+<strong>Output:</strong> -42
+<strong>Explanation:</strong>
+Step 1: "<u>   </u>-42" (leading whitespace is read and ignored)
+            ^
+Step 2: "   <u>-</u>42" ('-' is read, so the result should be negative)
+             ^
+Step 3: "   -<u>42</u>" ("42" is read in)
+               ^
+The parsed integer is -42.
+Since -42 is in the range [-2<sup>31</sup>, 2<sup>31</sup> - 1], the final result is -42.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "4193 with words"
+<strong>Output:</strong> 4193
+<strong>Explanation:</strong>
+Step 1: "4193 with words" (no characters read because there is no leading whitespace)
+         ^
+Step 2: "4193 with words" (no characters read because there is neither a '-' nor '+')
+         ^
+Step 3: "<u>4193</u> with words" ("4193" is read in; reading stops because the next character is a non-digit)
+             ^
+The parsed integer is 4193.
+Since 4193 is in the range [-2<sup>31</sup>, 2<sup>31</sup> - 1], the final result is 4193.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length &lt;= 200</code></li>
+	<li><code>s</code> consists of English letters (lower-case and upper-case), digits (<code>0-9</code>), <code>' '</code>, <code>'+'</code>, <code>'-'</code>, and <code>'.'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/807-max-increase-to-keep-city-skyline/807-max-increase-to-keep-city-skyline.java b/leetcode/leetcode/807-max-increase-to-keep-city-skyline/807-max-increase-to-keep-city-skyline.java
new file mode 100644
index 0000000..614582f
--- /dev/null
+++ b/leetcode/leetcode/807-max-increase-to-keep-city-skyline/807-max-increase-to-keep-city-skyline.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int maxIncreaseKeepingSkyline(int[][] grid) {
+        int sum = 0;
+        int n = grid.length;
+        int[] row_max = new int[n];
+        int[] col_max = new int[n];
+        for(int i = 0;i<n;i++){
+            for(int j =0;j<n;j++){
+                row_max[i] = Math.max(grid[i][j],row_max[i]);
+                col_max[j] = Math.max(grid[i][j],col_max[j]);
+            }
+        }
+        for(int i = 0;i<n;i++){
+            for(int j = 0;j<n;j++){
+                sum+=(Math.min(row_max[i],col_max[j]) - grid[i][j]);
+            }
+        }
+        return sum;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/807-max-increase-to-keep-city-skyline/NOTES.md b/leetcode/leetcode/807-max-increase-to-keep-city-skyline/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/807-max-increase-to-keep-city-skyline/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/807-max-increase-to-keep-city-skyline/README.md b/leetcode/leetcode/807-max-increase-to-keep-city-skyline/README.md
new file mode 100644
index 0000000..b4fc24c
--- /dev/null
+++ b/leetcode/leetcode/807-max-increase-to-keep-city-skyline/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/max-increase-to-keep-city-skyline/">807. Max Increase to Keep City Skyline</a></h2><h3>Medium</h3><hr><div><p>There is a city composed of <code>n x n</code> blocks, where each block contains a single building shaped like a vertical square prism. You are given a <strong>0-indexed</strong> <code>n x n</code> integer matrix <code>grid</code> where <code>grid[r][c]</code> represents the <strong>height</strong> of the building located in the block at row <code>r</code> and column <code>c</code>.</p>
+
+<p>A city's <strong>skyline</strong> is the the outer contour formed by all the building when viewing the side of the city from a distance. The <strong>skyline</strong> from each cardinal direction north, east, south, and west may be different.</p>
+
+<p>We are allowed to increase the height of <strong>any number of buildings by any amount</strong> (the amount can be different per building). The height of a <code>0</code>-height building can also be increased. However, increasing the height of a building should <strong>not</strong> affect the city's <strong>skyline</strong> from any cardinal direction.</p>
+
+<p>Return <em>the <strong>maximum total sum</strong> that the height of the buildings can be increased by <strong>without</strong> changing the city's <strong>skyline</strong> from any cardinal direction</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/21/807-ex1.png" style="width: 700px; height: 603px;">
+<pre><strong>Input:</strong> grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
+<strong>Output:</strong> 35
+<strong>Explanation:</strong> The building heights are shown in the center of the above image.
+The skylines when viewed from each cardinal direction are drawn in red.
+The grid after increasing the height of buildings without affecting skylines is:
+gridNew = [ [8, 4, 8, 7],
+            [7, 4, 7, 7],
+            [9, 4, 8, 7],
+            [3, 3, 3, 3] ]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[0,0,0],[0,0,0],[0,0,0]]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> Increasing the height of any building will result in the skyline changing.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == grid.length</code></li>
+	<li><code>n == grid[r].length</code></li>
+	<li><code>2 &lt;= n &lt;= 50</code></li>
+	<li><code>0 &lt;= grid[r][c] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/814-binary-tree-pruning/814-binary-tree-pruning.c b/leetcode/leetcode/814-binary-tree-pruning/814-binary-tree-pruning.c
new file mode 100644
index 0000000..7937b66
--- /dev/null
+++ b/leetcode/leetcode/814-binary-tree-pruning/814-binary-tree-pruning.c
@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+
+
+struct TreeNode* pruneTree(struct TreeNode* root){
+    if(root == NULL) return root;
+    root->left = pruneTree(root->left);
+    root->right = pruneTree(root->right);
+    if(root->left == NULL && root->right == NULL && root->val == 0)
+        return NULL;
+    return root;
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/814-binary-tree-pruning/814-binary-tree-pruning.java b/leetcode/leetcode/814-binary-tree-pruning/814-binary-tree-pruning.java
new file mode 100644
index 0000000..ce80992
--- /dev/null
+++ b/leetcode/leetcode/814-binary-tree-pruning/814-binary-tree-pruning.java
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode pruneTree(TreeNode root) {
+        if(root == null) return root;
+        root.left = pruneTree(root.left);
+        root.right = pruneTree(root.right);
+        if(root.left == null && root.right == null && root.val == 0)
+            return null;
+        return root;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/814-binary-tree-pruning/NOTES.md b/leetcode/leetcode/814-binary-tree-pruning/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/814-binary-tree-pruning/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/814-binary-tree-pruning/README.md b/leetcode/leetcode/814-binary-tree-pruning/README.md
new file mode 100644
index 0000000..515a9a1
--- /dev/null
+++ b/leetcode/leetcode/814-binary-tree-pruning/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-pruning/">814. Binary Tree Pruning</a></h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the same tree where every subtree (of the given tree) not containing a </em><code>1</code><em> has been removed</em>.</p>
+
+<p>A subtree of a node <code>node</code> is <code>node</code> plus every node that is a descendant of <code>node</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_2.png" style="width: 500px; height: 140px;">
+<pre><strong>Input:</strong> root = [1,null,0,0,1]
+<strong>Output:</strong> [1,null,0,null,1]
+<strong>Explanation:</strong> 
+Only the red nodes satisfy the property "every subtree not containing a 1".
+The diagram on the right represents the answer.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/06/1028_1.png" style="width: 500px; height: 115px;">
+<pre><strong>Input:</strong> root = [1,0,1,0,0,0,1]
+<strong>Output:</strong> [1,null,1,null,1]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/04/05/1028.png" style="width: 500px; height: 134px;">
+<pre><strong>Input:</strong> root = [1,1,0,1,1,0,1,0]
+<strong>Output:</strong> [1,1,0,1,1,null,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 200]</code>.</li>
+	<li><code>Node.val</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/82-remove-duplicates-from-sorted-list-ii.java b/leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/82-remove-duplicates-from-sorted-list-ii.java
new file mode 100644
index 0000000..2b71eb7
--- /dev/null
+++ b/leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/82-remove-duplicates-from-sorted-list-ii.java
@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        if(head==null || head.next == null) return head;
+        ListNode res = new ListNode();
+        ListNode prev = res;
+        res.next = head;
+        while(head!=null && head.next!=null){
+            if(head.val != head.next.val){
+                prev = prev.next;
+                head = head.next;
+            }else{
+                while(head.next!= null && head.val == head.next.val){
+                    head = head.next;
+                }
+                prev.next = head.next;
+                head = prev.next;
+            }
+        }
+        return res.next;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/NOTES.md b/leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/README.md b/leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/README.md
new file mode 100644
index 0000000..f981c5f
--- /dev/null
+++ b/leetcode/leetcode/82-remove-duplicates-from-sorted-list-ii/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/">82. Remove Duplicates from Sorted List II</a></h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a sorted linked list, <em>delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list</em>. Return <em>the linked list <strong>sorted</strong> as well</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist1.jpg" style="width: 500px; height: 142px;">
+<pre><strong>Input:</strong> head = [1,2,3,3,4,4,5]
+<strong>Output:</strong> [1,2,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist2.jpg" style="width: 500px; height: 205px;">
+<pre><strong>Input:</strong> head = [1,1,1,2,3]
+<strong>Output:</strong> [2,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 300]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li>The list is guaranteed to be <strong>sorted</strong> in ascending order.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/846-hand-of-straights/846-hand-of-straights.java b/leetcode/leetcode/846-hand-of-straights/846-hand-of-straights.java
new file mode 100644
index 0000000..5957bcf
--- /dev/null
+++ b/leetcode/leetcode/846-hand-of-straights/846-hand-of-straights.java
@@ -0,0 +1,34 @@
+class Solution {
+    public boolean isNStraightHand(int[] nums, int k) {
+        if(nums.length%k!=0) return false;
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int start = Integer.MAX_VALUE;
+        int max = Integer.MIN_VALUE;
+        for(int num: nums){
+            map.put(num,map.getOrDefault(num,0)+1);
+            start = Math.min(start,num);
+            max = Math.max(max,num);
+        }
+        while(start<=max){
+            int nextMin=-1;
+            int K = k;
+            if(map.containsKey(start)){
+                while(K!=0){
+                    if(!map.containsKey(start)) return false;
+                    map.put(start,map.get(start)-1);
+                    if(map.get(start) == 0){
+                        map.remove(start);
+                    }
+                    if(nextMin == -1 && map.containsKey(start)) nextMin = start;
+                    start++;
+                    K--;
+                }
+                if(nextMin!=-1) start = nextMin;
+            }else{
+                start++;
+            }
+        }
+        return true;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/846-hand-of-straights/NOTES.md b/leetcode/leetcode/846-hand-of-straights/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/846-hand-of-straights/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/846-hand-of-straights/README.md b/leetcode/leetcode/846-hand-of-straights/README.md
new file mode 100644
index 0000000..1d0db7d
--- /dev/null
+++ b/leetcode/leetcode/846-hand-of-straights/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/hand-of-straights/">846. Hand of Straights</a></h2><h3>Medium</h3><hr><div><p>Alice has some number of cards and she wants to rearrange the cards into groups so that each group is of size <code>groupSize</code>, and consists of <code>groupSize</code> consecutive cards.</p>
+
+<p>Given an integer array <code>hand</code> where <code>hand[i]</code> is the value written on the <code>i<sup>th</sup></code> card and an integer <code>groupSize</code>, return <code>true</code> if she can rearrange the cards, or <code>false</code> otherwise.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Alice's hand can be rearranged as [1,2,3],[2,3,4],[6,7,8]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> hand = [1,2,3,4,5], groupSize = 4
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Alice's hand can not be rearranged into groups of 4.
+
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= hand.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= hand[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= groupSize &lt;= hand.length</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as 1296: <a href="https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/" target="_blank">https://leetcode.com/problems/divide-array-in-sets-of-k-consecutive-numbers/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/849-maximize-distance-to-closest-person/849-maximize-distance-to-closest-person.java b/leetcode/leetcode/849-maximize-distance-to-closest-person/849-maximize-distance-to-closest-person.java
new file mode 100644
index 0000000..cd63bc7
--- /dev/null
+++ b/leetcode/leetcode/849-maximize-distance-to-closest-person/849-maximize-distance-to-closest-person.java
@@ -0,0 +1,23 @@
+class Solution {
+    public int maxDistToClosest(int[] seats) {
+        int start = Integer.MIN_VALUE;
+        int end = Integer.MAX_VALUE;
+        int ans = 0;
+        int len = seats.length;
+        for(int i = 0;i<len;i++){
+            if(seats[i] == 0){
+                start = i;
+                end = start+1;
+                while(end<len){
+                    if(seats[end] == 1) break;
+                    end++;
+                }
+                if(end>=len || start == 0) ans = Math.max(ans,end-start);
+                else if((end-start)%2==0) ans = Math.max(ans,(end - start)/2);
+                else ans = Math.max(ans,(end - start +1)/2);
+                i = end;
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/849-maximize-distance-to-closest-person/NOTES.md b/leetcode/leetcode/849-maximize-distance-to-closest-person/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/849-maximize-distance-to-closest-person/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/849-maximize-distance-to-closest-person/README.md b/leetcode/leetcode/849-maximize-distance-to-closest-person/README.md
new file mode 100644
index 0000000..7db346d
--- /dev/null
+++ b/leetcode/leetcode/849-maximize-distance-to-closest-person/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/maximize-distance-to-closest-person/">849. Maximize Distance to Closest Person</a></h2><h3>Medium</h3><hr><div><p>You are given an array representing a row of <code>seats</code> where <code>seats[i] = 1</code> represents a person sitting in the <code>i<sup>th</sup></code> seat, and <code>seats[i] = 0</code> represents that the <code>i<sup>th</sup></code> seat is empty <strong>(0-indexed)</strong>.</p>
+
+<p>There is at least one empty seat, and at least one person sitting.</p>
+
+<p>Alex wants to sit in the seat such that the distance between him and the closest person to him is maximized.&nbsp;</p>
+
+<p>Return <em>that maximum distance to the closest person</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/10/distance.jpg" style="width: 650px; height: 257px;">
+<pre><strong>Input:</strong> seats = [1,0,0,0,1,0,1]
+<strong>Output:</strong> 2
+<strong>Explanation: </strong>
+If Alex sits in the second open seat (i.e. seats[2]), then the closest person has distance 2.
+If Alex sits in any other open seat, the closest person has distance 1.
+Thus, the maximum distance to the closest person is 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> seats = [1,0,0,0]
+<strong>Output:</strong> 3
+<strong>Explanation: </strong>
+If Alex sits in the last seat (i.e. seats[3]), the closest person is 3 seats away.
+This is the maximum distance possible, so the answer is 3.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> seats = [0,1]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= seats.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>seats[i]</code>&nbsp;is <code>0</code> or&nbsp;<code>1</code>.</li>
+	<li>At least one seat is <strong>empty</strong>.</li>
+	<li>At least one seat is <strong>occupied</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/852-peak-index-in-a-mountain-array/852-peak-index-in-a-mountain-array.java b/leetcode/leetcode/852-peak-index-in-a-mountain-array/852-peak-index-in-a-mountain-array.java
new file mode 100644
index 0000000..c7d3803
--- /dev/null
+++ b/leetcode/leetcode/852-peak-index-in-a-mountain-array/852-peak-index-in-a-mountain-array.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int peakIndexInMountainArray(int[] arr) {
+        int low = 0;
+        int high = arr.length -1;
+        while(low<high){
+            int mid = (low+high)/2;
+            if(arr[mid]<arr[mid+1]){
+                low = mid+1;
+            }else{
+                high = mid;
+            }
+        }
+        return low;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/852-peak-index-in-a-mountain-array/NOTES.md b/leetcode/leetcode/852-peak-index-in-a-mountain-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/852-peak-index-in-a-mountain-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/852-peak-index-in-a-mountain-array/README.md b/leetcode/leetcode/852-peak-index-in-a-mountain-array/README.md
new file mode 100644
index 0000000..7168047
--- /dev/null
+++ b/leetcode/leetcode/852-peak-index-in-a-mountain-array/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/peak-index-in-a-mountain-array/">852. Peak Index in a Mountain Array</a></h2><h3>Easy</h3><hr><div><p>Let's call an array <code>arr</code> a <strong>mountain</strong>&nbsp;if the following properties hold:</p>
+
+<ul>
+	<li><code>arr.length &gt;= 3</code></li>
+	<li>There exists some <code>i</code> with&nbsp;<code>0 &lt; i&nbsp;&lt; arr.length - 1</code>&nbsp;such that:
+	<ul>
+		<li><code>arr[0] &lt; arr[1] &lt; ... arr[i-1] &lt; arr[i] </code></li>
+		<li><code>arr[i] &gt; arr[i+1] &gt; ... &gt; arr[arr.length - 1]</code></li>
+	</ul>
+	</li>
+</ul>
+
+<p>Given an integer array <code>arr</code> that is <strong>guaranteed</strong> to be&nbsp;a mountain, return any&nbsp;<code>i</code>&nbsp;such that&nbsp;<code>arr[0] &lt; arr[1] &lt; ... arr[i - 1] &lt; arr[i] &gt; arr[i + 1] &gt; ... &gt; arr[arr.length - 1]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [0,1,0]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [0,2,1,0]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [0,10,5,2]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= arr.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= arr[i] &lt;= 10<sup>6</sup></code></li>
+	<li><code>arr</code> is <strong>guaranteed</strong> to be a mountain array.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Finding the <code>O(n)</code> is straightforward, could you find an <code>O(log(n))</code> solution?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/867-transpose-matrix/867-transpose-matrix.java b/leetcode/leetcode/867-transpose-matrix/867-transpose-matrix.java
new file mode 100644
index 0000000..ff72162
--- /dev/null
+++ b/leetcode/leetcode/867-transpose-matrix/867-transpose-matrix.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int[][] transpose(int[][] matrix) {
+        int m = matrix.length;
+        int n = matrix[0].length;
+        int[][] result = new int[n][m];
+        for(int i = 0;i<m;i++){
+            for(int j = 0;j<n;j++){
+                result[j][i] = matrix[i][j];
+            }
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/867-transpose-matrix/NOTES.md b/leetcode/leetcode/867-transpose-matrix/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/867-transpose-matrix/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/867-transpose-matrix/README.md b/leetcode/leetcode/867-transpose-matrix/README.md
new file mode 100644
index 0000000..10817d1
--- /dev/null
+++ b/leetcode/leetcode/867-transpose-matrix/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/transpose-matrix/">867. Transpose Matrix</a></h2><h3>Easy</h3><hr><div><p>Given a 2D integer array <code>matrix</code>, return <em>the <strong>transpose</strong> of</em> <code>matrix</code>.</p>
+
+<p>The <strong>transpose</strong> of a matrix is the matrix flipped over its main diagonal, switching the matrix's row and column indices.</p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2021/02/10/hint_transpose.png" style="width: 600px; height: 197px;"></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [[1,2,3],[4,5,6],[7,8,9]]
+<strong>Output:</strong> [[1,4,7],[2,5,8],[3,6,9]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [[1,2,3],[4,5,6]]
+<strong>Output:</strong> [[1,4],[2,5],[3,6]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == matrix.length</code></li>
+	<li><code>n == matrix[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 1000</code></li>
+	<li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= matrix[i][j] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/875-koko-eating-bananas/875-koko-eating-bananas.java b/leetcode/leetcode/875-koko-eating-bananas/875-koko-eating-bananas.java
new file mode 100644
index 0000000..95694e4
--- /dev/null
+++ b/leetcode/leetcode/875-koko-eating-bananas/875-koko-eating-bananas.java
@@ -0,0 +1,25 @@
+class Solution {
+    
+    public int minEatingSpeed(int[] piles, int h) {
+        int max = 0;
+        int min = 1;
+        for(int num: piles){
+            max = Math.max(num,max);
+        }
+        if(piles.length == h) return max;
+        int speed = max;
+        while(min<=max){
+            int mid = min + (max-min)/2;
+            int res = 0;
+            for(int num: piles) res += (int)Math.ceil(num*1.0/mid);
+            if(res<=h){
+                speed = mid;
+                max = mid-1;
+            }else{
+                min = mid+1;
+            }
+        }
+        return speed;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/875-koko-eating-bananas/NOTES.md b/leetcode/leetcode/875-koko-eating-bananas/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/875-koko-eating-bananas/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/875-koko-eating-bananas/README.md b/leetcode/leetcode/875-koko-eating-bananas/README.md
new file mode 100644
index 0000000..014b8f3
--- /dev/null
+++ b/leetcode/leetcode/875-koko-eating-bananas/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/koko-eating-bananas/">875. Koko Eating Bananas</a></h2><h3>Medium</h3><hr><div><p>Koko loves to eat bananas. There are <code>n</code> piles of bananas, the <code>i<sup>th</sup></code> pile has <code>piles[i]</code> bananas. The guards have gone and will come back in <code>h</code> hours.</p>
+
+<p>Koko can decide her bananas-per-hour eating speed of <code>k</code>. Each hour, she chooses some pile of bananas and eats <code>k</code> bananas from that pile. If the pile has less than <code>k</code> bananas, she eats all of them instead and will not eat any more bananas during this hour.</p>
+
+<p>Koko likes to eat slowly but still wants to finish eating all the bananas before the guards return.</p>
+
+<p>Return <em>the minimum integer</em> <code>k</code> <em>such that she can eat all the bananas within</em> <code>h</code> <em>hours</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> piles = [3,6,7,11], h = 8
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> piles = [30,11,23,4,20], h = 5
+<strong>Output:</strong> 30
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> piles = [30,11,23,4,20], h = 6
+<strong>Output:</strong> 23
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= piles.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>piles.length &lt;= h &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= piles[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/88-merge-sorted-array/88-merge-sorted-array.java b/leetcode/leetcode/88-merge-sorted-array/88-merge-sorted-array.java
new file mode 100644
index 0000000..706f9b9
--- /dev/null
+++ b/leetcode/leetcode/88-merge-sorted-array/88-merge-sorted-array.java
@@ -0,0 +1,17 @@
+class Solution {
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+        int counter = m + n -1;
+        while(counter>=0){
+            if(m!=0 && n!=0 && nums1[m-1]>=nums2[n-1]){
+                nums1[counter] = nums1[m-1];
+                nums1[m-1] = 0;
+                m--;
+            }else if(n!=0){
+                nums1[counter] = nums2[n-1];
+                n--;
+            }
+            counter--;
+            
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/88-merge-sorted-array/NOTES.md b/leetcode/leetcode/88-merge-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/88-merge-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/88-merge-sorted-array/README.md b/leetcode/leetcode/88-merge-sorted-array/README.md
new file mode 100644
index 0000000..dc53856
--- /dev/null
+++ b/leetcode/leetcode/88-merge-sorted-array/README.md
@@ -0,0 +1,46 @@
+<h2><a href="https://leetcode.com/problems/merge-sorted-array/">88. Merge Sorted Array</a></h2><h3>Easy</h3><hr><div><p>You are given two integer arrays <code>nums1</code> and <code>nums2</code>, sorted in <strong>non-decreasing order</strong>, and two integers <code>m</code> and <code>n</code>, representing the number of elements in <code>nums1</code> and <code>nums2</code> respectively.</p>
+
+<p><strong>Merge</strong> <code>nums1</code> and <code>nums2</code> into a single array sorted in <strong>non-decreasing order</strong>.</p>
+
+<p>The final sorted array should not be returned by the function, but instead be <em>stored inside the array </em><code>nums1</code>. To accommodate this, <code>nums1</code> has a length of <code>m + n</code>, where the first <code>m</code> elements denote the elements that should be merged, and the last <code>n</code> elements are set to <code>0</code> and should be ignored. <code>nums2</code> has a length of <code>n</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+<strong>Output:</strong> [1,2,2,3,5,6]
+<strong>Explanation:</strong> The arrays we are merging are [1,2,3] and [2,5,6].
+The result of the merge is [<u>1</u>,<u>2</u>,2,<u>3</u>,5,6] with the underlined elements coming from nums1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1], m = 1, nums2 = [], n = 0
+<strong>Output:</strong> [1]
+<strong>Explanation:</strong> The arrays we are merging are [1] and [].
+The result of the merge is [1].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [0], m = 0, nums2 = [1], n = 1
+<strong>Output:</strong> [1]
+<strong>Explanation:</strong> The arrays we are merging are [] and [1].
+The result of the merge is [1].
+Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>nums1.length == m + n</code></li>
+	<li><code>nums2.length == n</code></li>
+	<li><code>0 &lt;= m, n &lt;= 200</code></li>
+	<li><code>1 &lt;= m + n &lt;= 200</code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums1[i], nums2[j] &lt;= 10<sup>9</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up: </strong>Can you come up with an algorithm that runs in <code>O(m + n)</code> time?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/889-construct-binary-tree-from-preorder-and-postorder-traversal.java b/leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/889-construct-binary-tree-from-preorder-and-postorder-traversal.java
new file mode 100644
index 0000000..983a24a
--- /dev/null
+++ b/leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/889-construct-binary-tree-from-preorder-and-postorder-traversal.java
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode contructFromPrePost(int[] preorder, int preStart, int preEnd, int[] postorder, int posStart, int posEnd){
+        if(preStart>preEnd) return null;
+        TreeNode root = new TreeNode(preorder[preStart]);
+        if(preStart==preEnd) return root;
+        int index = posStart;
+        while(index>=posStart){
+            if(postorder[index] == preorder[preStart+1]) break;
+            index++;
+        }
+        root.left = contructFromPrePost(preorder,preStart+1,preStart+index - posStart+1,postorder,posStart,index);
+        root.right = contructFromPrePost(preorder,preEnd - ( posEnd - index - 1)+1,preEnd,postorder,index+1,posEnd-1);
+        return root;
+    }
+    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
+        int len = preorder.length-1;
+        return contructFromPrePost(preorder,0,len, postorder, 0, len);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/NOTES.md b/leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/README.md b/leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/README.md
new file mode 100644
index 0000000..7ae417f
--- /dev/null
+++ b/leetcode/leetcode/889-construct-binary-tree-from-preorder-and-postorder-traversal/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/construct-binary-tree-from-preorder-and-postorder-traversal/">889. Construct Binary Tree from Preorder and Postorder Traversal</a></h2><h3>Medium</h3><hr><div><p>Given two integer arrays, <code>preorder</code> and <code>postorder</code> where <code>preorder</code> is the preorder traversal of a binary tree of <strong>distinct</strong> values and <code>postorder</code> is the postorder traversal of the same tree, reconstruct and return <em>the binary tree</em>.</p>
+
+<p>If there exist multiple answers, you can <strong>return any</strong> of them.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/07/24/lc-prepost.jpg" style="width: 304px; height: 265px;">
+<pre><strong>Input:</strong> preorder = [1,2,4,5,3,6,7], postorder = [4,5,2,6,7,3,1]
+<strong>Output:</strong> [1,2,3,4,5,6,7]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> preorder = [1], postorder = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= preorder.length &lt;= 30</code></li>
+	<li><code>1 &lt;= preorder[i] &lt;= preorder.length</code></li>
+	<li>All the values of <code>preorder</code> are <strong>unique</strong>.</li>
+	<li><code>postorder.length == preorder.length</code></li>
+	<li><code>1 &lt;= postorder[i] &lt;= postorder.length</code></li>
+	<li>All the values of <code>postorder</code> are <strong>unique</strong>.</li>
+	<li>It is guaranteed that <code>preorder</code> and <code>postorder</code> are the preorder traversal and postorder traversal of the same binary tree.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/890-find-and-replace-pattern/890-find-and-replace-pattern.java b/leetcode/leetcode/890-find-and-replace-pattern/890-find-and-replace-pattern.java
new file mode 100644
index 0000000..16a37e1
--- /dev/null
+++ b/leetcode/leetcode/890-find-and-replace-pattern/890-find-and-replace-pattern.java
@@ -0,0 +1,21 @@
+class Solution {
+    public boolean match(String word, String pattern){
+        HashMap<Character,Character> map = new HashMap<>();
+        HashMap<Character,Character> map1 = new HashMap<>();
+        for(int i = 0;i<word.length();i++){
+            char s = word.charAt(i);
+            char t = pattern.charAt(i);
+            if(!map.containsKey(s)) map.put(s,t);
+            if(!map1.containsKey(t)) map1.put(t,s);
+            if(map.get(s) !=t || map1.get(t)!=s) return false;
+        }
+        return true;
+    }
+    public List<String> findAndReplacePattern(String[] words, String pattern) {
+        List<String> list = new ArrayList<>();
+        for(String word : words){
+            if(match(word,pattern)) list.add(word);
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/890-find-and-replace-pattern/NOTES.md b/leetcode/leetcode/890-find-and-replace-pattern/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/890-find-and-replace-pattern/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/890-find-and-replace-pattern/README.md b/leetcode/leetcode/890-find-and-replace-pattern/README.md
new file mode 100644
index 0000000..0866cb1
--- /dev/null
+++ b/leetcode/leetcode/890-find-and-replace-pattern/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/find-and-replace-pattern/">890. Find and Replace Pattern</a></h2><h3>Medium</h3><hr><div><p>Given a list of strings <code>words</code> and a string <code>pattern</code>, return <em>a list of</em> <code>words[i]</code> <em>that match</em> <code>pattern</code>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>A word matches the pattern if there exists a permutation of letters <code>p</code> so that after replacing every letter <code>x</code> in the pattern with <code>p(x)</code>, we get the desired word.</p>
+
+<p>Recall that a permutation of letters is a bijection from letters to letters: every letter maps to another letter, and no two letters map to the same letter.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
+<strong>Output:</strong> ["mee","aqq"]
+<strong>Explanation:</strong> "mee" matches the pattern because there is a permutation {a -&gt; m, b -&gt; e, ...}. 
+"ccc" does not match the pattern because {a -&gt; c, b -&gt; c, ...} is not a permutation, since a and b map to the same letter.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words = ["a","b","c"], pattern = "a"
+<strong>Output:</strong> ["a","b","c"]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= pattern.length &lt;= 20</code></li>
+	<li><code>1 &lt;= words.length &lt;= 50</code></li>
+	<li><code>words[i].length == pattern.length</code></li>
+	<li><code>pattern</code> and <code>words[i]</code> are lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/9-palindrome-number/9-palindrome-number.cpp b/leetcode/leetcode/9-palindrome-number/9-palindrome-number.cpp
new file mode 100644
index 0000000..68d798f
--- /dev/null
+++ b/leetcode/leetcode/9-palindrome-number/9-palindrome-number.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    bool isPalindrome(int x) {
+        if(x<0 || (x!=0 && x%10==0)) return false;
+        int rev = 0;
+        while(x>rev){
+            rev = (rev*10) + x%10;
+            x = x/10;
+        }
+        return x == rev || x ==  rev/10 ;
+    }
+};
\ No newline at end of file
diff --git a/leetcode/leetcode/9-palindrome-number/9-palindrome-number.java b/leetcode/leetcode/9-palindrome-number/9-palindrome-number.java
new file mode 100644
index 0000000..6e6c720
--- /dev/null
+++ b/leetcode/leetcode/9-palindrome-number/9-palindrome-number.java
@@ -0,0 +1,11 @@
+class Solution {
+    public boolean isPalindrome(int x) {
+        if(x<0 || (x!=0 && x%10==0)) return false;
+        int rev = 0;
+        while(x>rev){
+            rev = (rev*10) + x%10;
+            x = x/10;
+        }
+        return x == rev || x ==  rev/10 ;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/9-palindrome-number/NOTES.md b/leetcode/leetcode/9-palindrome-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/9-palindrome-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/9-palindrome-number/README.md b/leetcode/leetcode/9-palindrome-number/README.md
new file mode 100644
index 0000000..97ae141
--- /dev/null
+++ b/leetcode/leetcode/9-palindrome-number/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/palindrome-number/">9. Palindrome Number</a></h2><h3>Easy</h3><hr><div><p>Given an integer <code>x</code>, return <code>true</code> if <code>x</code> is palindrome integer.</p>
+
+<p>An integer is a <strong>palindrome</strong> when it reads the same backward as forward.</p>
+
+<ul>
+	<li>For example, <code>121</code> is a palindrome while <code>123</code> is not.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> x = 121
+<strong>Output:</strong> true
+<strong>Explanation:</strong> 121 reads as 121 from left to right and from right to left.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> x = -121
+<strong>Output:</strong> false
+<strong>Explanation:</strong> From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> x = 10
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Reads 01 from right to left. Therefore it is not a palindrome.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup>&nbsp;&lt;= x &lt;= 2<sup>31</sup>&nbsp;- 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you solve it without converting the integer to a string?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/931-minimum-falling-path-sum/931-minimum-falling-path-sum.java b/leetcode/leetcode/931-minimum-falling-path-sum/931-minimum-falling-path-sum.java
new file mode 100644
index 0000000..8b2693c
--- /dev/null
+++ b/leetcode/leetcode/931-minimum-falling-path-sum/931-minimum-falling-path-sum.java
@@ -0,0 +1,28 @@
+class Solution {
+    private int minPath(int[][] matrix, int row, int col, int[][] dp){
+        if(row == matrix.length-1) return matrix[row][col];
+        if(dp[row][col] != Integer.MAX_VALUE) return dp[row][col];
+        int left = Integer.MAX_VALUE;
+        int right = Integer.MAX_VALUE;
+        int down = Integer.MAX_VALUE;
+        if(row+1<matrix.length) down = minPath(matrix,row+1,col,dp);
+        if(row+1<matrix.length && col-1>-1) left = minPath(matrix,row+1,col-1,dp);
+        if(row+1<matrix.length && col+1<matrix[0].length) right = minPath(matrix,row+1,col+1,dp);
+        dp[row][col] = matrix[row][col] + Math.min(left,Math.min(down,right));
+        return dp[row][col];
+    }
+    public int minFallingPathSum(int[][] matrix) {
+        int[][] dp = new int[matrix.length][matrix[0].length];
+        for(int i =0;i<matrix.length;i++){
+            for(int j = 0;j<matrix[0].length;j++){
+                dp[i][j] = Integer.MAX_VALUE;
+            }
+        }
+        int min = Integer.MAX_VALUE;
+        for(int i = 0;i<matrix[0].length;i++){
+            min = Math.min(min,minPath(matrix,0,i,dp));
+        }
+        return min;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/94-binary-tree-inorder-traversal/94-binary-tree-inorder-traversal.java b/leetcode/leetcode/94-binary-tree-inorder-traversal/94-binary-tree-inorder-traversal.java
new file mode 100644
index 0000000..76284e7
--- /dev/null
+++ b/leetcode/leetcode/94-binary-tree-inorder-traversal/94-binary-tree-inorder-traversal.java
@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> list = new ArrayList<Integer>();
+        if(root==null){
+            return list;
+        }
+        list.addAll(inorderTraversal(root.left));
+        list.add(root.val);
+        list.addAll(inorderTraversal(root.right));
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/94-binary-tree-inorder-traversal/NOTES.md b/leetcode/leetcode/94-binary-tree-inorder-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/94-binary-tree-inorder-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/94-binary-tree-inorder-traversal/README.md b/leetcode/leetcode/94-binary-tree-inorder-traversal/README.md
new file mode 100644
index 0000000..e6ca03e
--- /dev/null
+++ b/leetcode/leetcode/94-binary-tree-inorder-traversal/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-inorder-traversal/">94. Binary Tree Inorder Traversal</a></h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the inorder traversal of its nodes' values</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 125px; height: 200px;">
+<pre><strong>Input:</strong> root = [1,null,2,3]
+<strong>Output:</strong> [1,3,2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/941-valid-mountain-array/941-valid-mountain-array.java b/leetcode/leetcode/941-valid-mountain-array/941-valid-mountain-array.java
new file mode 100644
index 0000000..9e30c0d
--- /dev/null
+++ b/leetcode/leetcode/941-valid-mountain-array/941-valid-mountain-array.java
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean validMountainArray(int[] arr) {
+        if(arr.length<3) return false;
+        int increasing = 0;
+        int decreasing = arr.length -1;
+        for(int i = 0;i<arr.length-1;i++){
+            if(arr[i]>=arr[i+1]) break;
+            increasing++;
+        }
+        for(int j = arr.length-1;j!=0;j--){
+            if(arr[j]>=arr[j-1]) break;
+            decreasing--;
+        }
+        if(increasing == 0 || decreasing == arr.length - 1) return false;
+        return increasing==decreasing;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/941-valid-mountain-array/NOTES.md b/leetcode/leetcode/941-valid-mountain-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/941-valid-mountain-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/941-valid-mountain-array/README.md b/leetcode/leetcode/941-valid-mountain-array/README.md
new file mode 100644
index 0000000..c2672e9
--- /dev/null
+++ b/leetcode/leetcode/941-valid-mountain-array/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/valid-mountain-array/">941. Valid Mountain Array</a></h2><h3>Easy</h3><hr><div><p>Given an array of integers <code>arr</code>, return <em><code>true</code> if and only if it is a valid mountain array</em>.</p>
+
+<p>Recall that arr is a mountain array if and only if:</p>
+
+<ul>
+	<li><code>arr.length &gt;= 3</code></li>
+	<li>There exists some <code>i</code> with <code>0 &lt; i &lt; arr.length - 1</code> such that:
+	<ul>
+		<li><code>arr[0] &lt; arr[1] &lt; ... &lt; arr[i - 1] &lt; arr[i] </code></li>
+		<li><code>arr[i] &gt; arr[i + 1] &gt; ... &gt; arr[arr.length - 1]</code></li>
+	</ul>
+	</li>
+</ul>
+<img src="https://assets.leetcode.com/uploads/2019/10/20/hint_valid_mountain_array.png" width="500">
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> arr = [2,1]
+<strong>Output:</strong> false
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> arr = [3,5,5]
+<strong>Output:</strong> false
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> arr = [0,3,2,1]
+<strong>Output:</strong> true
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= arr[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/946-validate-stack-sequences/946-validate-stack-sequences.java b/leetcode/leetcode/946-validate-stack-sequences/946-validate-stack-sequences.java
new file mode 100644
index 0000000..c4871eb
--- /dev/null
+++ b/leetcode/leetcode/946-validate-stack-sequences/946-validate-stack-sequences.java
@@ -0,0 +1,26 @@
+class Solution {
+    public boolean validateStackSequences(int[] pushed, int[] popped) {
+        Stack<Integer> s = new Stack<>();
+        int i = 0;
+        int j = 0;
+        while(i<pushed.length || j<popped.length){
+            if(s.isEmpty()){
+                s.push(pushed[i]);
+                i++;
+                continue;
+            }
+            if(s.peek() == popped[j]){
+                s.pop();
+                j++;
+                continue;
+            }
+            if(i<pushed.length){
+                s.push(pushed[i]);
+                i++;
+            }else{
+                return false;
+            }
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/946-validate-stack-sequences/NOTES.md b/leetcode/leetcode/946-validate-stack-sequences/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/946-validate-stack-sequences/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/946-validate-stack-sequences/README.md b/leetcode/leetcode/946-validate-stack-sequences/README.md
new file mode 100644
index 0000000..7f03a3a
--- /dev/null
+++ b/leetcode/leetcode/946-validate-stack-sequences/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/validate-stack-sequences/">946. Validate Stack Sequences</a></h2><h3>Medium</h3><hr><div><p>Given two integer arrays <code>pushed</code> and <code>popped</code> each with distinct values, return <code>true</code><em> if this could have been the result of a sequence of push and pop operations on an initially empty stack, or </em><code>false</code><em> otherwise.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> We might do the following sequence:
+push(1), push(2), push(3), push(4),
+pop() -&gt; 4,
+push(5),
+pop() -&gt; 5, pop() -&gt; 3, pop() -&gt; 2, pop() -&gt; 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> 1 cannot be popped before 2.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= pushed.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= pushed[i] &lt;= 1000</code></li>
+	<li>All the elements of <code>pushed</code> are <strong>unique</strong>.</li>
+	<li><code>popped.length == pushed.length</code></li>
+	<li><code>popped</code> is a permutation of <code>pushed</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/96-unique-binary-search-trees/96-unique-binary-search-trees.java b/leetcode/leetcode/96-unique-binary-search-trees/96-unique-binary-search-trees.java
new file mode 100644
index 0000000..43f8189
--- /dev/null
+++ b/leetcode/leetcode/96-unique-binary-search-trees/96-unique-binary-search-trees.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int numTrees(int n) {
+        if(n<3) return n;
+        int[] dp = new int[n+1];
+        dp[0] = 1;
+        dp[1] = 1;
+        for(int i =2 ;i<n+1;i++){
+            for(int j = 0;j<i;j++){
+                dp[i]+=(dp[j]*dp[i-j-1]);
+            }
+        }
+        return dp[n];
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/96-unique-binary-search-trees/NOTES.md b/leetcode/leetcode/96-unique-binary-search-trees/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/96-unique-binary-search-trees/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/96-unique-binary-search-trees/README.md b/leetcode/leetcode/96-unique-binary-search-trees/README.md
new file mode 100644
index 0000000..8fcb9d1
--- /dev/null
+++ b/leetcode/leetcode/96-unique-binary-search-trees/README.md
@@ -0,0 +1,22 @@
+<h2><a href="https://leetcode.com/problems/unique-binary-search-trees/">96. Unique Binary Search Trees</a></h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, return <em>the number of structurally unique <strong>BST'</strong>s (binary search trees) which has exactly </em><code>n</code><em> nodes of unique values from</em> <code>1</code> <em>to</em> <code>n</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg" style="width: 600px; height: 148px;">
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 5
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 19</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/969-pancake-sorting/969-pancake-sorting.java b/leetcode/leetcode/969-pancake-sorting/969-pancake-sorting.java
new file mode 100644
index 0000000..80e8c43
--- /dev/null
+++ b/leetcode/leetcode/969-pancake-sorting/969-pancake-sorting.java
@@ -0,0 +1,33 @@
+class Solution {
+    private void swap(int [] arr, int i, int j){
+        int temp = arr[i]; 
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    private void flip(int[] arr, int i){
+        int start = 0;
+        while(start<i){
+            swap(arr,i,start);
+            i--;
+            start++;
+        }
+    }
+    public List<Integer> pancakeSort(int[] arr) {
+        List<Integer> list = new ArrayList<>();
+        int j = arr.length -1;
+        while(j!=0){
+            int max = j;
+            for(int i = 0;i<=j;i++){
+                if(arr[i]>arr[max]) max = i;
+            }
+            if(max!=j){
+                list.add(max+1);
+                list.add(j+1);
+                flip(arr,max);
+                flip(arr,j);
+            }
+            j--;
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/969-pancake-sorting/NOTES.md b/leetcode/leetcode/969-pancake-sorting/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/969-pancake-sorting/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/969-pancake-sorting/README.md b/leetcode/leetcode/969-pancake-sorting/README.md
new file mode 100644
index 0000000..c3d3106
--- /dev/null
+++ b/leetcode/leetcode/969-pancake-sorting/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/pancake-sorting/">969. Pancake Sorting</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>arr</code>, sort the array by performing a series of <strong>pancake flips</strong>.</p>
+
+<p>In one pancake flip we do the following steps:</p>
+
+<ul>
+	<li>Choose an integer <code>k</code> where <code>1 &lt;= k &lt;= arr.length</code>.</li>
+	<li>Reverse the sub-array <code>arr[0...k-1]</code> (<strong>0-indexed</strong>).</li>
+</ul>
+
+<p>For example, if <code>arr = [3,2,1,4]</code> and we performed a pancake flip choosing <code>k = 3</code>, we reverse the sub-array <code>[3,2,1]</code>, so <code>arr = [<u>1</u>,<u>2</u>,<u>3</u>,4]</code> after the pancake flip at <code>k = 3</code>.</p>
+
+<p>Return <em>an array of the </em><code>k</code><em>-values corresponding to a sequence of pancake flips that sort </em><code>arr</code>. Any valid answer that sorts the array within <code>10 * arr.length</code> flips will be judged as correct.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [3,2,4,1]
+<strong>Output:</strong> [4,2,4,3]
+<strong>Explanation: </strong>
+We perform 4 pancake flips, with k values 4, 2, 4, and 3.
+Starting state: arr = [3, 2, 4, 1]
+After 1st flip (k = 4): arr = [<u>1</u>, <u>4</u>, <u>2</u>, <u>3</u>]
+After 2nd flip (k = 2): arr = [<u>4</u>, <u>1</u>, 2, 3]
+After 3rd flip (k = 4): arr = [<u>3</u>, <u>2</u>, <u>1</u>, <u>4</u>]
+After 4th flip (k = 3): arr = [<u>1</u>, <u>2</u>, <u>3</u>, 4], which is sorted.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,3]
+<strong>Output:</strong> []
+<strong>Explanation: </strong>The input is already sorted, so there is no need to flip anything.
+Note that other answers, such as [3, 3], would also be accepted.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 100</code></li>
+	<li><code>1 &lt;= arr[i] &lt;= arr.length</code></li>
+	<li>All integers in <code>arr</code> are unique (i.e. <code>arr</code> is a permutation of the integers from <code>1</code> to <code>arr.length</code>).</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/973-k-closest-points-to-origin/973-k-closest-points-to-origin.java b/leetcode/leetcode/973-k-closest-points-to-origin/973-k-closest-points-to-origin.java
new file mode 100644
index 0000000..2bcfb3f
--- /dev/null
+++ b/leetcode/leetcode/973-k-closest-points-to-origin/973-k-closest-points-to-origin.java
@@ -0,0 +1,30 @@
+class Solution {
+    class pair implements Comparable<pair>{
+        int x;
+        int y;
+        pair(int x, int y){
+            this.x = x;
+            this.y = y;
+        }
+        public int compareTo(pair p){
+            return Double.compare(Math.sqrt(p.x*p.x + p.y*p.y) ,Math.sqrt(this.x*this.x + this.y*this.y));            
+        }
+        
+    }
+    public int[][] kClosest(int[][] points, int k) {
+        if(points.length == 1) return points;
+        PriorityQueue<pair> pq =new PriorityQueue<>();
+        for(int i = 0;i<points.length;i++){
+            pair p = new pair(points[i][0],points[i][1]);
+            pq.add(p);
+            if(pq.size()>k) pq.remove();
+        }
+        int[][] res = new int[k][2];
+        for(int i = 0;i<k;i++){
+            pair p =pq.remove();
+            res[i][0] = p.x;
+            res[i][1] = p.y;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/973-k-closest-points-to-origin/NOTES.md b/leetcode/leetcode/973-k-closest-points-to-origin/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/973-k-closest-points-to-origin/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/973-k-closest-points-to-origin/README.md b/leetcode/leetcode/973-k-closest-points-to-origin/README.md
new file mode 100644
index 0000000..3d9b267
--- /dev/null
+++ b/leetcode/leetcode/973-k-closest-points-to-origin/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/k-closest-points-to-origin/">973. K Closest Points to Origin</a></h2><h3>Medium</h3><hr><div><p>Given an array of <code>points</code> where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the <strong>X-Y</strong> plane and an integer <code>k</code>, return the <code>k</code> closest points to the origin <code>(0, 0)</code>.</p>
+
+<p>The distance between two points on the <strong>X-Y</strong> plane is the Euclidean distance (i.e., <code>√(x<sub>1</sub> - x<sub>2</sub>)<sup>2</sup> + (y<sub>1</sub> - y<sub>2</sub>)<sup>2</sup></code>).</p>
+
+<p>You may return the answer in <strong>any order</strong>. The answer is <strong>guaranteed</strong> to be <strong>unique</strong> (except for the order that it is in).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/closestplane1.jpg" style="width: 400px; height: 400px;">
+<pre><strong>Input:</strong> points = [[1,3],[-2,2]], k = 1
+<strong>Output:</strong> [[-2,2]]
+<strong>Explanation:</strong>
+The distance between (1, 3) and the origin is sqrt(10).
+The distance between (-2, 2) and the origin is sqrt(8).
+Since sqrt(8) &lt; sqrt(10), (-2, 2) is closer to the origin.
+We only want the closest k = 1 points from the origin, so the answer is just [[-2,2]].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> points = [[3,3],[5,-1],[-2,4]], k = 2
+<strong>Output:</strong> [[3,3],[-2,4]]
+<strong>Explanation:</strong> The answer [[-2,4],[3,3]] would also be accepted.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= points.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt; x<sub>i</sub>, y<sub>i</sub> &lt; 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/991-broken-calculator/991-broken-calculator.java b/leetcode/leetcode/991-broken-calculator/991-broken-calculator.java
new file mode 100644
index 0000000..2b3bb8c
--- /dev/null
+++ b/leetcode/leetcode/991-broken-calculator/991-broken-calculator.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int brokenCalc(int startValue, int target) {
+        int ans = 0;
+        while(target>startValue){
+            ans++;
+            if(target%2==1){
+                target++;
+            }else{
+                target = target/2;
+            }
+        }
+        return ans+ startValue-target;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/991-broken-calculator/NOTES.md b/leetcode/leetcode/991-broken-calculator/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/leetcode/leetcode/991-broken-calculator/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/leetcode/leetcode/991-broken-calculator/README.md b/leetcode/leetcode/991-broken-calculator/README.md
new file mode 100644
index 0000000..c8f5264
--- /dev/null
+++ b/leetcode/leetcode/991-broken-calculator/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/broken-calculator/">991. Broken Calculator</a></h2><h3>Medium</h3><hr><div><p>There is a broken calculator that has the integer <code>startValue</code> on its display initially. In one operation, you can:</p>
+
+<ul>
+	<li>multiply the number on display by <code>2</code>, or</li>
+	<li>subtract <code>1</code> from the number on display.</li>
+</ul>
+
+<p>Given two integers <code>startValue</code> and <code>target</code>, return <em>the minimum number of operations needed to display </em><code>target</code><em> on the calculator</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> startValue = 2, target = 3
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Use double operation and then decrement operation {2 -&gt; 4 -&gt; 3}.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> startValue = 5, target = 8
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Use decrement and then double {5 -&gt; 4 -&gt; 8}.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> startValue = 3, target = 10
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Use double, decrement and double {3 -&gt; 6 -&gt; 5 -&gt; 10}.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= x, y &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Binary Search - GFG/README.md b/leetcode/leetcode/Binary Search - GFG/README.md
new file mode 100644
index 0000000..f901fea
--- /dev/null
+++ b/leetcode/leetcode/Binary Search - GFG/README.md	
@@ -0,0 +1,42 @@
+# Binary Search
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a sorted array of size <strong>N</strong> and an integer <strong>K</strong>, find the position at which <strong>K</strong> is present in the array using binary search.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 5
+arr[] = {1 2 3 4 5} 
+K = 4
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 4 appears at index 3.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 5
+arr[] = {11 22 33 44 55} 
+K = 445
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> 445 is not present.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task: &nbsp;</strong><br>
+You dont need to read input or print anything. Complete the function <strong>binarysearch()</strong> which takes <strong>arr[]</strong>, <strong>N</strong> and <strong>K</strong> as input parameters and returns the index of <strong>K</strong> in the array. If <strong>K</strong> is not present in the array, return -1.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(LogN)<br>
+<strong>Expected Auxiliary Space:</strong> O(LogN) if solving recursively and O(1) otherwise.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong></span></p>
+
+<ul>
+	<li><span style="font-size:18px">1 &lt;= N &lt;= 10</span><sup><span style="font-size:15px">5</span></sup></li>
+	<li><span style="font-size:18px">1 &lt;= arr[i] &lt;= 10<sup>6</sup></span></li>
+	<li><span style="font-size:18px">1 &lt;= K &lt;= 10<sup>6</sup></span></li>
+</ul>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Binary Search - GFG/binary-search.java b/leetcode/leetcode/Binary Search - GFG/binary-search.java
new file mode 100644
index 0000000..f003c10
--- /dev/null
+++ b/leetcode/leetcode/Binary Search - GFG/binary-search.java	
@@ -0,0 +1,42 @@
+// { Driver Code Starts
+// Initial Template for Java
+
+import java.io.*;
+import java.util.*;
+
+  public class GFG {
+    public static void main(String[] args) throws IOException {
+        Scanner sc = new Scanner(System.in);
+        int T = sc.nextInt();
+        while (T > 0) {
+            int n = sc.nextInt();
+            int arr[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = sc.nextInt();
+            }
+
+            int key = sc.nextInt();
+            Solution g = new Solution();
+            System.out.println(g.binarysearch(arr, n, key));
+            T--;
+        }
+    }
+}
+// } Driver Code Ends
+
+
+// User function Template for Java
+
+class Solution {
+    int binarysearch(int arr[], int n, int k) {
+        int low = 0;
+        int high = n-1;
+        while(low<=high){
+            int mid = (low+high)/2;
+            if(arr[mid] == k) return mid;
+            else if(arr[mid]>k) high = mid - 1;
+            else low = mid+1;
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Bottom View of Binary Tree - GFG/README.md b/leetcode/leetcode/Bottom View of Binary Tree - GFG/README.md
new file mode 100644
index 0000000..2c62304
--- /dev/null
+++ b/leetcode/leetcode/Bottom View of Binary Tree - GFG/README.md	
@@ -0,0 +1,68 @@
+# Bottom View of Binary Tree
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a binary tree, print the bottom view from left to right.<br>
+A node is included in bottom view if it can be seen when we look at the tree from bottom.</span></p>
+
+<p><span style="font-size:18px">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 20<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp;&nbsp; \<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 8&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 22<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp; \&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; \<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 3&nbsp;&nbsp;&nbsp;&nbsp; &nbsp; 25<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp; \&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 10&nbsp;&nbsp;&nbsp; 14</span></p>
+
+<p><span style="font-size:18px">For the above tree, the bottom view is 5 10 3 14 25.</span><br>
+<span style="font-size:18px">If there are <strong>multiple </strong>bottom-most nodes for a horizontal distance from root, then print the later one in level traversal. For example, in the below diagram, 3 and 4 are both the bottommost nodes at horizontal distance 0, we need to print 4.</span></p>
+
+<p><span style="font-size:18px">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 20<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp;&nbsp; \<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 8&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 22<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp; \&nbsp;&nbsp; &nbsp; /&nbsp;&nbsp; \<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 3 4&nbsp;&nbsp;&nbsp;&nbsp; 25<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp; &nbsp;&nbsp;&nbsp; /&nbsp; &nbsp; \&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 10 &nbsp;&nbsp; &nbsp;&nbsp; 14</span></p>
+
+<p><span style="font-size:18px">For the above tree the output should be 5 10 4 14 25.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>       1
+&nbsp;    /   \
+&nbsp;   3     2
+<strong>Output: </strong>3 1 2<strong>
+Explanation:</strong>
+First case represents a tree with 3 nodes
+and 2 edges where root is 1, left child of
+1 is 3 and right child of 1 is 2.
+<img alt="" src="https://contribute.geeksforgeeks.org/wp-content/uploads/BT-1.jpg" class="img-responsive">
+Thus nodes of the binary tree will be
+printed as such 3 1 2.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>         10
+&nbsp;      /    \
+&nbsp;     20    30
+&nbsp;    /  \
+&nbsp;   40   60
+<strong>Output: </strong>40 20 60 30
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+This is a functional problem, you <strong>don't </strong>need to care about input, just complete the function <strong>bottomView</strong>() which takes the root node of the tree as input and returns an array&nbsp;containing the bottom view of the given tree.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(N).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= Number of nodes &lt;= 10<sup>5</sup><br>
+1 &lt;= Data of a node &lt;= 10<sup>5</sup></span></p>
+
+<p><br>
+<span style="font-size:14px"><strong>Note:&nbsp;</strong>The <strong>Input/Output</strong> format and <strong>Example</strong> given are used for the system's internal purpose, and should be used by a user for <strong>Expected Output </strong>only. As it is a function problem, hence a user should not read any input from the stdin/console. The task is to complete the function specified, and not to write the full code.</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Bottom View of Binary Tree - GFG/bottom-view-of-binary-tree.java b/leetcode/leetcode/Bottom View of Binary Tree - GFG/bottom-view-of-binary-tree.java
new file mode 100644
index 0000000..f7d7931
--- /dev/null
+++ b/leetcode/leetcode/Bottom View of Binary Tree - GFG/bottom-view-of-binary-tree.java	
@@ -0,0 +1,150 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+
+//Contributed by Sudarshan Sharma
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node
+{
+    int data; //data of the node
+    int hd; //horizontal distance of the node
+    Node left, right; //left and right references
+ 
+    // Constructor of tree node
+    public Node(int key)
+    {
+        data = key;
+        hd = Integer.MAX_VALUE;
+        left = right = null;
+    }
+}
+
+
+
+class GfG {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    static void printInorder(Node root)
+    {
+        if(root == null)
+            return;
+            
+        printInorder(root.left);
+        System.out.print(root.data+" ");
+        
+        printInorder(root.right);
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t-- > 0){
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+    	        Solution ob = new Solution();
+			    ArrayList <Integer> res = ob.bottomView(root);
+			    for (Integer num : res) System.out.print (num + " ");
+		     	System.out.println();
+	        }
+	}
+}
+
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+
+class Solution
+{
+    class pair{
+        Node root;
+        int level;
+        pair(Node root,int level){
+            this.root = root;
+            this.level = level;
+        }
+    }
+    //Function to return a list containing the bottom view of the given tree.
+    public ArrayList <Integer> bottomView(Node root)
+    {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        Queue<pair> q = new LinkedList<>();
+        int min = 0;
+        q.add(new pair(root,0));
+        while(!q.isEmpty()){
+            pair p = q.remove();
+            map.put(p.level,p.root.data);
+            if(p.root.left!=null) q.add(new pair(p.root.left,p.level - 1));
+            if(p.root.right!=null) q.add(new pair(p.root.right,p.level + 1));
+            min = Math.min(min,p.level);
+        }
+        ArrayList<Integer> list = new ArrayList<>();
+        while(map.containsKey(min)){
+            list.add(map.get(min));
+            min++;
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Buildings receiving sunlight - GFG/README.md b/leetcode/leetcode/Buildings receiving sunlight - GFG/README.md
new file mode 100644
index 0000000..19209e7
--- /dev/null
+++ b/leetcode/leetcode/Buildings receiving sunlight - GFG/README.md	
@@ -0,0 +1,58 @@
+# Buildings receiving sunlight
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given are the <strong>heights</strong> of certain Buildings which&nbsp;lie adjacent to each other. Sunlight starts falling from the left side of the buildings.&nbsp;If there is a building of a certain Height, all the buildings to the right side of it having lesser heights cannot see the sun. The task is to find the total number of such buildings that receive sunlight.</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 6
+H[] = {6, 2, 8, 4, 11, 13}
+<strong>Output:</strong>
+4
+<strong>Explanation:</strong>
+Only buildings of height 6, 8, 11 and
+13 can see the sun, hence output is 4.</span></pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 5
+H[] = {2, 5, 1, 8, 3}
+<strong>Output:</strong>
+3
+<strong>Explanation:</strong>
+Only buildings of height 2, 5 and 8
+can see the sun, hence output is 3.</span></pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 3:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 7
+H[] = {3, 4, 1, 0, 6, 2, 3}
+<strong>Output:</strong>
+3</span></pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:&nbsp;&nbsp;</strong><br>
+You don't need to read input or print anything. Your task is to complete the function <strong>longest()</strong>&nbsp;which takes the array <strong>A[]</strong> and its size <strong>N</strong><strong> </strong>as inputs and returns the desired output.</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity: </strong>O(N)<br>
+<strong>Expected Auxiliary Space: </strong>O(1)</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>5</sup><br>
+1 ≤ H<sub>i</sub> ≤ 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Buildings receiving sunlight - GFG/buildings-receiving-sunlight.java b/leetcode/leetcode/Buildings receiving sunlight - GFG/buildings-receiving-sunlight.java
new file mode 100644
index 0000000..d8c250c
--- /dev/null
+++ b/leetcode/leetcode/Buildings receiving sunlight - GFG/buildings-receiving-sunlight.java	
@@ -0,0 +1,53 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+/*package whatever //do not write package name here */
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class GFG {
+	public static void main(String[] args) throws IOException
+	{
+	        BufferedReader br =
+            new BufferedReader(new InputStreamReader(System.in));
+        int t =
+            Integer.parseInt(br.readLine().trim()); // Inputting the testcases
+        while(t-->0)
+        {
+            int n = Integer.parseInt(br.readLine().trim());
+            int arr[] = new int[n+5];
+            String inputLine[] = br.readLine().trim().split(" ");
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(inputLine[i]);
+            }
+            
+            Solution obj = new Solution();
+            System.out.println(obj.longest(arr, n));
+            
+        }
+	}
+}
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+
+
+class Solution {
+
+    public static int longest(int arr[],int n)
+    {
+        int maxTillNow = 0;
+        int res = 0;
+        for(int i = 0;i<n;i++){
+            if(arr[i]>= maxTillNow) {
+                res++;
+                maxTillNow = arr[i];
+            }
+        }
+        return res;
+    }
+}
diff --git a/leetcode/leetcode/Check for BST - GFG/README.md b/leetcode/leetcode/Check for BST - GFG/README.md
new file mode 100644
index 0000000..e42dd38
--- /dev/null
+++ b/leetcode/leetcode/Check for BST - GFG/README.md	
@@ -0,0 +1,68 @@
+# Check for BST
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given the root of a&nbsp;binary tree. Check whether it is a BST or not.<br>
+<strong>Note: </strong>We are considering that BSTs can not contain duplicate Nodes.</span><br>
+<span style="font-size:18px">A&nbsp;<strong>BST</strong>&nbsp;is defined as follows:</span></p>
+
+<ul>
+	<li>
+	<div><span style="font-size:18px">The left subtree of a node contains only nodes with keys <strong>less than</strong> the node's key.</span></div>
+	</li>
+	<li>
+	<div><span style="font-size:18px">The right subtree of a node contains only nodes with keys <strong>greater than</strong> the node's key.</span></div>
+	</li>
+	<li>
+	<div><span style="font-size:18px">Both the left and right subtrees must also be binary search trees.</span></div>
+	</li>
+</ul>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>&nbsp; &nbsp;2
+ /&nbsp; &nbsp; \
+1&nbsp; &nbsp; &nbsp; 3
+<strong>Output: </strong>1 
+<strong>Explanation: </strong></span>
+<span style="font-size:18px">The left subtree of root node contains node
+with key lesser than the root nodes key and 
+the right subtree of root node contains node 
+with key greater than the root nodes key.
+Hence, the tree is a BST.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>  2
+&nbsp;  \
+&nbsp;   7
+&nbsp;    \
+&nbsp;     6
+&nbsp;      \
+&nbsp;       5
+&nbsp;        \
+&nbsp;         9
+&nbsp;          \
+&nbsp;           2
+&nbsp;            \
+&nbsp;             6
+<strong>Output: </strong>0 
+<strong>Explanation: </strong>
+Since the node with value 7 has right subtree 
+nodes with keys less than 7, this is not a BST.
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Your task is to complete the function&nbsp;</span><span style="font-size:18px"><strong>isBST()</strong> which takes the root of the tree as a parameter and returns <strong>true</strong>&nbsp;if the given binary tree is BST, else returns <strong>false</strong>.&nbsp;</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N).<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(Height of the BST).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+0 &lt;= Number of edges &lt;= 100000</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Check for BST - GFG/check-for-bst.java b/leetcode/leetcode/Check for BST - GFG/check-for-bst.java
new file mode 100644
index 0000000..09eae6b
--- /dev/null
+++ b/leetcode/leetcode/Check for BST - GFG/check-for-bst.java	
@@ -0,0 +1,143 @@
+// { Driver Code Starts
+//Initial Template for Java
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+class GfG {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    static void printInorder(Node root)
+    {
+        if(root == null)
+            return;
+            
+        printInorder(root.left);
+        System.out.print(root.data+" ");
+        
+        printInorder(root.right);
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t > 0){
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+        	    Solution g = new Solution();
+        	    if(g.isBST(root))
+			        System.out.println(1);
+			    else
+			        System.out.println(0);
+                t--;
+            
+        }
+    }
+  
+}
+
+
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+
+public class Solution
+{
+    public class pair{
+        int min;
+        int max;
+        boolean isBST;
+        pair(int max, int min, boolean isBST){
+            this.max  = max;
+            this.min = min;
+            this.isBST = isBST;
+        }
+    }
+    //Function to check whether a Binary Tree is BST or not.
+    boolean isBST(Node root)
+    {
+        return max_min_isBST(root).isBST;
+    }
+    pair max_min_isBST(Node root){
+        if(root == null){
+            return new pair(Integer.MIN_VALUE,Integer.MAX_VALUE,true);
+        }
+        pair left = max_min_isBST(root.left);
+        pair right = max_min_isBST(root.right);
+        int currentMax = Math.max(root.data,Math.max(left.max,right.max));
+        int currentMin = Math.min(root.data,Math.min(left.min,right.min));
+        boolean isBST = left.isBST && right.isBST && root.data > left.max && root.data < right.min;
+        return new pair(currentMax,currentMin, isBST);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Check if Linked List is Palindrome - GFG/README.md b/leetcode/leetcode/Check if Linked List is Palindrome - GFG/README.md
new file mode 100644
index 0000000..f2edfb8
--- /dev/null
+++ b/leetcode/leetcode/Check if Linked List is Palindrome - GFG/README.md	
@@ -0,0 +1,36 @@
+# Check if Linked List is Palindrome
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a singly linked list of size <strong>N</strong> of integers. The task is to check if the given linked list is palindrome or not.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 3
+value[] = {1,2,1}
+<strong>Output: </strong>1<strong>
+Explanation: </strong>The given linked list is
+1 2 1 , which is a palindrome and
+Hence, the output is 1.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 4
+value[] = {1,2,3,4}
+<strong>Output: </strong>0<strong>
+Explanation: </strong>The given linked list
+is 1 2 3 4 , which is not a palindrome
+and Hence, the output is 0.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+The task is to complete the function&nbsp;<strong>isPalindrome</strong>() which takes head as reference as the only parameter and returns true or false if linked list is palindrome&nbsp;or not respectively.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity</strong>: O(N)<br>
+<strong>Expected Auxialliary Space Usage</strong>: O(1)&nbsp; (ie, you should not use the recursive stack space as well)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N&nbsp;&lt;= 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Check if Linked List is Palindrome - GFG/check-if-linked-list-is-palindrome.java b/leetcode/leetcode/Check if Linked List is Palindrome - GFG/check-if-linked-list-is-palindrome.java
new file mode 100644
index 0000000..20fec56
--- /dev/null
+++ b/leetcode/leetcode/Check if Linked List is Palindrome - GFG/check-if-linked-list-is-palindrome.java	
@@ -0,0 +1,136 @@
+// { Driver Code Starts
+import java.util.*;
+
+class Node
+{
+	int data;
+	Node next;
+	
+	Node(int d)
+	{
+		data = d;
+		next = null;
+	}
+}
+
+class Is_LinkedList_Palindrom
+{
+	 Node head;  
+	 Node tail;
+	
+	/* Function to print linked list */
+    void printList(Node head)
+    {
+        Node temp = head;
+        while (temp != null)
+        {
+           System.out.print(temp.data+" ");
+           temp = temp.next;
+        }  
+        System.out.println();
+    }
+	
+ 
+    /* Inserts a new Node at front of the list. */
+    public void addToTheLast(Node node) 
+	{
+
+		if (head == null) 
+		{
+			head = node;
+			tail = node;
+		} else 
+		{
+		    tail.next = node;
+		    tail = node;
+		}
+    }
+	
+	public static void main(String args[])
+	{
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		 
+		while(t>0)
+        {
+			int n = sc.nextInt();
+			//int k = sc.nextInt();
+			Is_LinkedList_Palindrom llist = new Is_LinkedList_Palindrom();
+			//int n=Integer.parseInt(br.readLine());
+			int a1=sc.nextInt();
+			Node head= new Node(a1);
+            Node tail = head;
+            for (int i = 1; i < n; i++) 
+			{
+				int a = sc.nextInt(); 
+			    tail.next = new Node(a);
+			    tail = tail.next;
+			}
+			
+			Solution g = new Solution();
+			if(g.isPalindrome(head) == true)
+			    System.out.println(1);
+		    else
+			    System.out.println(0);
+			t--;
+		}
+		
+	}
+}
+
+
+
+// } Driver Code Ends
+
+
+/* Structure of class Node is
+class Node
+{
+	int data;
+	Node next;
+	
+	Node(int d)
+	{
+		data = d;
+		next = null;
+	}
+}*/
+
+class Solution
+{
+    
+    Node reverse(Node head){
+        Node prev = null;
+        Node curr = head;
+        Node next = head.next;
+        while(next!=null){
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+            next = next.next;
+        }
+        curr.next = prev;
+        return curr;
+    }
+    //Function to check whether the list is palindrome.
+    boolean isPalindrome(Node head) 
+    {
+        Node slow = head;
+        Node fast = head;
+        while(fast!=null && fast.next!=null){
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        slow = reverse(slow);
+        while(head!=null && slow!=null){
+            if(head.data == slow.data){
+                head = head.next;
+                slow = slow.next;
+            }else{
+                return false;
+            }
+        }
+        return true;
+    }    
+}
+
diff --git a/leetcode/leetcode/Connect Nodes at Same Level - GFG/README.md b/leetcode/leetcode/Connect Nodes at Same Level - GFG/README.md
new file mode 100644
index 0000000..275c871
--- /dev/null
+++ b/leetcode/leetcode/Connect Nodes at Same Level - GFG/README.md	
@@ -0,0 +1,60 @@
+# Connect Nodes at Same Level
+## Medium 
+<div class="problem-statement">
+                <p></p><div class="entry-content">
+<p><span style="font-size:18px">Given a binary tree, connect the nodes that are at same level. You'll be given an addition&nbsp;<strong>nextRight&nbsp;</strong>pointer for the same.</span></p>
+
+<p><span style="font-size:18px"><strong>Initially</strong>, all the <strong>nextRight </strong>pointers point to <strong>garbage </strong>values. <strong>Your function</strong> should set these pointers to point next right for each node.</span><br>
+<span style="font-size:18px">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 10&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp; 10 ------&gt; NULL<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; / \&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; /&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; \<br>
+&nbsp;&nbsp;&nbsp;&nbsp; 3&nbsp;&nbsp; 5&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; =&gt; &nbsp;&nbsp;&nbsp; 3 ------&gt; 5 --------&gt; NULL<br>
+&nbsp;&nbsp;&nbsp; / \&nbsp; &nbsp;&nbsp; \&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp; &nbsp;&nbsp;&nbsp; /&nbsp; \&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; \<br>
+&nbsp;&nbsp; 4&nbsp;&nbsp; 1&nbsp;&nbsp; 2&nbsp;&nbsp;&nbsp;&nbsp; &nbsp; &nbsp;&nbsp; 4 --&gt; 1 -----&gt; 2 -------&gt; NULL</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>     3
+&nbsp;  /  \
+&nbsp; 1    2
+<strong>Output:
+</strong>3 1 2
+1 3 2<strong>
+Explanation:</strong>The connected tree is
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 3 ------&gt; NULL
+&nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp;&nbsp;&nbsp;\
+&nbsp;&nbsp;  1-----&gt; 2 ------ NULL</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>      10
+&nbsp;   /   \
+&nbsp;  20   30
+&nbsp; /  \
+ 40  60
+<strong>Output:
+</strong>10 20 30 40 60
+40 20 60 10 30<strong>
+Explanation:</strong>The connected tree is
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 10 ----------&gt; NULL
+&nbsp;&nbsp;&nbsp;  &nbsp; /&nbsp;&nbsp;&nbsp;&nbsp; \
+&nbsp;&nbsp;&nbsp;&nbsp; 20 ------&gt; 30 -------&gt; NULL
+&nbsp;&nbsp;/&nbsp;&nbsp;&nbsp; \
+&nbsp;40 ----&gt; 60 ----------&gt; NULL</span></pre>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong><br>
+<span style="font-size:18px">You don't have to take input. Complete the function <strong>connect()&nbsp;</strong>that takes <strong>root&nbsp;</strong>as parameter and connects the nodes at same level.</span> <span style="font-size:18px">The printing is done by the driver code. First line of the output will be level order traversal and second line will be inorder travsersal</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(N).</span></p>
+</div>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ Number of nodes ≤ 10<sup>5</sup><br>
+0 ≤ Data of a node ≤ 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Connect Nodes at Same Level - GFG/connect-nodes-at-same-level.java b/leetcode/leetcode/Connect Nodes at Same Level - GFG/connect-nodes-at-same-level.java
new file mode 100644
index 0000000..1eabd69
--- /dev/null
+++ b/leetcode/leetcode/Connect Nodes at Same Level - GFG/connect-nodes-at-same-level.java	
@@ -0,0 +1,173 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+//Initial Template for Java
+
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node nextRight;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+        nextRight = null;
+    }
+}
+
+class GfG {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    public static void printInorder(Node root)
+    {
+        if(root == null)
+            return;
+            
+        printInorder(root.left);
+        System.out.print(root.data+" ");
+        
+        printInorder(root.right);
+    }
+    
+    public static void printSpecial(Node root)
+    {
+       if (root == null)
+         return;
+    
+       Node next_root=null;
+    
+       while (root != null)
+       {
+          System.out.print(root.data+" ");
+    
+          if( root.left!=null && next_root==null )
+            next_root = root.left;
+          else if( root.right!=null && next_root==null  )
+            next_root = root.right;
+    
+          root = root.nextRight;
+       }
+       
+       printSpecial(next_root);
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t > 0){
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+        	    Solution g = new Solution();
+			    g.connect(root);
+                printSpecial(root);
+                System.out.println();
+                printInorder(root);
+                System.out.println();
+                t--;
+            
+        }
+    }
+  
+}// } Driver Code Ends
+
+
+//User function Template for Java
+
+ /*
+    Node class is Defined as follows:
+    class Node{
+        int data;
+        Node left;
+        Node right;
+        Node nextRight;
+        Node(int data){
+            this.data = data;
+            left=null;
+            right=null;
+            nextRight = null;
+        }
+    }
+    */
+    
+class Solution
+{
+    //Function to connect nodes at same level.
+    public void connect(Node root)
+    {
+        if(root==null) return;
+        Queue<Node> q = new LinkedList<>();
+        q.add(root);
+        while(!q.isEmpty()){
+            for(int i = q.size();i!=0;i--){
+                root = q.remove();
+                if(i!=1) root.nextRight = q.peek();
+                if(root.left!=null) q.add(root.left);
+                if(root.right!=null) q.add(root.right);
+            }
+        }
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Count distinct elements in every window - GFG/README.md b/leetcode/leetcode/Count distinct elements in every window - GFG/README.md
new file mode 100644
index 0000000..7fc5ab3
--- /dev/null
+++ b/leetcode/leetcode/Count distinct elements in every window - GFG/README.md	
@@ -0,0 +1,40 @@
+# Count distinct elements in every window
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array of integers and a number K. Find the count of distinct elements in every window of size K in the array.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:
+</span></strong><span style="font-size:18px">N = 7, K = 4
+A[] = {1,2,1,3,4,2,3}
+<strong>Output: </strong>3 4 4 3<strong>
+Explanation: </strong>Window 1 of size k = 4 is
+1 2 1 3. Number of distinct elements in
+this window are 3.&nbsp;
+Window 2&nbsp;of size k = 4 is&nbsp;2 1 3 4.&nbsp;</span><span style="font-size:18px">Number
+of distinct elements in this window are 4.</span>
+<span style="font-size:18px">Window 3&nbsp;of size k = 4 is&nbsp;1 3 4 2.&nbsp;</span><span style="font-size:18px">Number
+of distinct elements in this window are 4.</span>
+<span style="font-size:18px">Window 4&nbsp;of size k = 4 is&nbsp;</span><span style="font-size:18px">3 4 2 3.&nbsp;Number
+of distinct elements in this window are 3.</span>
+</pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:
+</span></strong><span style="font-size:18px">N = 3, K = 2
+A[] = {4,1,1}
+<strong>Output: </strong>2 1</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+Your task is to complete the function&nbsp;<strong>countDistinct()</strong>&nbsp;which takes the array A[], the size of the array(N) and the window size(K) as inputs and returns an array containing the count of distinct elements in every contiguous window of size K in the array A[].</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N).<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(N).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong></span><br>
+<span style="font-size:18px">1 &lt;= K&nbsp;&lt;= N&nbsp;&lt;= 10<sup>5</sup></span><br>
+<span style="font-size:18px">1 &lt;= A[i] &lt;= 10<sup>5&nbsp;</sup>, for each valid i</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Count distinct elements in every window - GFG/count-distinct-elements-in-every-window.java b/leetcode/leetcode/Count distinct elements in every window - GFG/count-distinct-elements-in-every-window.java
new file mode 100644
index 0000000..b87c78a
--- /dev/null
+++ b/leetcode/leetcode/Count distinct elements in every window - GFG/count-distinct-elements-in-every-window.java	
@@ -0,0 +1,53 @@
+// { Driver Code Starts
+import java.util.*;
+import java.io.*;
+import java.util.HashMap;
+
+class GFG
+{
+    public static void main(String args[])
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t > 0)
+        {
+            int n = sc.nextInt();
+            int k = sc.nextInt();
+            int a[] = new int[n];
+            for (int i = 0; i < n; i++) 
+                a[i] = sc.nextInt();
+            Solution g = new Solution();
+            
+            ArrayList<Integer> ans = g.countDistinct(a, n, k);
+
+            for (Integer val: ans) 
+                System.out.print(val+" "); 
+            System.out.println();
+            t--;
+        }
+    }
+}// } Driver Code Ends
+
+
+class Solution
+{
+    ArrayList<Integer> countDistinct(int A[], int n, int k)
+    {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int i = 0;i<k;i++) map.put(A[i],map.getOrDefault(A[i],0)+1);
+        ArrayList<Integer> list = new ArrayList<>();
+        int i = 0;
+        int j = k;
+        while(j<n){
+            list.add(map.size());
+            map.put(A[j],map.getOrDefault(A[j],0)+1);
+            map.put(A[i],map.get(A[i])-1);
+            if(map.get(A[i]) == 0) map.remove(A[i]);
+            i++;
+            j++;
+        }
+        list.add(map.size());
+        return list;
+    }
+}
+
diff --git a/leetcode/leetcode/Count pairs in array divisible by K - GFG/README.md b/leetcode/leetcode/Count pairs in array divisible by K - GFG/README.md
new file mode 100644
index 0000000..ac05b0a
--- /dev/null
+++ b/leetcode/leetcode/Count pairs in array divisible by K - GFG/README.md	
@@ -0,0 +1,47 @@
+# Count pairs in array divisible by K
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array&nbsp;<strong>A[]&nbsp;</strong>and positive integer&nbsp;<strong>K</strong>, the task is to count total number of pairs in the array whose sum is divisible by&nbsp;<strong>K</strong>.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input :</strong> 
+A[] = {2, 2, 1, 7, 5, 3}, K = 4
+<strong>Output :</strong> 5
+<strong>Explanation : </strong>
+There are five pairs possible whose sum
+is divisible by '4' i.e., (2, 2), 
+(1, 7), (7, 5), (1, 3) and (5, 3)</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input :</strong> 
+A[] = {5, 9, 36, 74, 52, 31, 42}, K = 3
+<strong>Output :</strong> 7 
+<strong>Explanation : </strong>
+There are seven pairs whose sum is divisible by 3, 
+i.e, (9, 36), (9,42), </span><span style="font-size:18px">(74, 52), (36, 42), (74, 31), 
+(31, 5) and (5, 52).
+</span></pre>
+
+<div><span style="font-size:18px"><strong>Your task :</strong></span></div>
+
+<div><span style="font-size:18px">You don't have to read input or print anything. Your task is to complete the function <strong>countKdivPairs()</strong> which takes the array, it's size and an integer K as input and returns the count of pairs whose sum is divisible by K.</span></div>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Expected Time Complexity :</strong> O(n)</span></div>
+
+<div><span style="font-size:18px"><strong>Expected Auxiliary Space :</strong> O(k)</span></div>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Constraints :</strong></span></div>
+
+<div><span style="font-size:18px">1 &lt;= N &lt;=10^6</span></div>
+
+<div><span style="font-size:18px">1 &lt;= A[i] &lt;= 10^6</span></div>
+
+<div><span style="font-size:18px">1 &lt;= K &lt;= 100</span></div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Count pairs in array divisible by K - GFG/count-pairs-in-array-divisible-by-k.java b/leetcode/leetcode/Count pairs in array divisible by K - GFG/count-pairs-in-array-divisible-by-k.java
new file mode 100644
index 0000000..dc0552d
--- /dev/null
+++ b/leetcode/leetcode/Count pairs in array divisible by K - GFG/count-pairs-in-array-divisible-by-k.java	
@@ -0,0 +1,47 @@
+// { Driver Code Starts
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+
+class GFG
+{
+    public static void main (String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(br.readLine().trim()); //Inputting the testcases
+		while(t-->0){
+		    
+		    int n = Integer.parseInt(br.readLine().trim());
+		    String inputLine[] = br.readLine().trim().split(" ");
+		    int arr[] = new int[n];
+		    for(int i=0; i<n; i++){
+		        arr[i] = Integer.parseInt(inputLine[i]);
+		    }
+		    
+		    int k = Integer.parseInt(br.readLine().trim());
+		    
+		    Solution ob= new Solution();
+		    System.out.println(ob.countKdivPairs(arr, n, k));
+		}
+	}
+}// } Driver Code Ends
+
+
+//User function Template for Java
+
+class Solution
+{
+    public static int countKdivPairs(int arr[], int n, int k)
+    {
+        int[] freq = new int[k];
+        for(int num: arr){
+            freq[(num%k+k)%k]++;
+        }
+        int ans = (freq[0] * (freq[0] - 1)) / 2;
+        for(int i=1;i<=k/2 && i!= k - i;i++){
+            ans+=(freq[i]*freq[k-i]);
+        }
+        if(k%2==0) ans+=(freq[k / 2] * (freq[k / 2] - 1) / 2);
+        return ans;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Detect Loop in linked list - GFG/README.md b/leetcode/leetcode/Detect Loop in linked list - GFG/README.md
new file mode 100644
index 0000000..e107c4d
--- /dev/null
+++ b/leetcode/leetcode/Detect Loop in linked list - GFG/README.md	
@@ -0,0 +1,42 @@
+# Detect Loop in linked list
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a linked list of <strong>N</strong> nodes. The task is to check if the&nbsp;linked list has a loop. Linked list can contain&nbsp;self loop.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 3
+value[] = {1,3,4}
+x = 2
+<strong>Output: </strong>True<strong>
+Explanation: </strong>In above test case N = 3.
+</span><span style="font-size:18px">The linked list with nodes N = 3 is
+given. Then value of&nbsp;x=2 is given which
+means last node is connected with xth
+node of linked list. Therefore, there
+exists a loop.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 4
+value[] = {1,8,3,4}
+x = 0
+<strong>Output: </strong>False<strong>
+Explanation: </strong>For N = 4 ,x = 0 means
+then lastNode-&gt;next = NULL, then
+the&nbsp;Linked list does not contains
+any loop.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+The task is to complete the function <strong>detectloop</strong>() which contains reference to the head as only argument. This function should return <strong>true</strong>&nbsp;if linked list contains loop, else return <strong>false</strong>.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(1)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong></span><br>
+<span style="font-size:18px">1 ≤ N ≤ 10<sup>4</sup><br>
+1 ≤ Data on Node ≤ 10<sup>3</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Detect Loop in linked list - GFG/detect-loop-in-linked-list.java b/leetcode/leetcode/Detect Loop in linked list - GFG/detect-loop-in-linked-list.java
new file mode 100644
index 0000000..15e1d0f
--- /dev/null
+++ b/leetcode/leetcode/Detect Loop in linked list - GFG/detect-loop-in-linked-list.java	
@@ -0,0 +1,92 @@
+// { Driver Code Starts
+//Initial template code for JAVA
+
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+
+class Node
+{
+    int data;
+    Node next;
+    
+    Node(int x)
+    {
+        data = x;
+        next = null;
+    }
+}
+
+class GFG
+{
+    public static void makeLoop(Node head, Node tail, int x){
+        if (x == 0) return;
+        
+        Node curr = head;
+        for(int i=1; i<x; i++)
+            curr = curr.next;
+        
+        tail.next = curr;
+    }
+    
+    public static void main (String[] args){
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t--> 0)
+        {
+            int n = sc.nextInt();
+            
+            int num = sc.nextInt();
+            Node head = new Node(num);
+            Node tail = head;
+            
+            for(int i=0; i<n-1; i++)
+            {
+                num = sc.nextInt();
+                tail.next = new Node(num);
+                tail = tail.next;
+            }
+            
+            int pos = sc.nextInt();
+            makeLoop(head, tail, pos);
+            
+            Solution x = new Solution();
+            if( x.detectLoop(head) )
+                System.out.println("True");
+            else
+                System.out.println("False");
+        }
+    }
+}
+// } Driver Code Ends
+
+
+//User function template for JAVA
+
+/* Node is defined as
+
+class Node
+{
+    int data;
+    Node next;
+    Node(int d) {data = d; next = null; }
+}
+
+*/
+
+
+class Solution {
+    //Function to check if the linked list has a loop.
+    public static boolean detectLoop(Node head){
+        // Add code here
+        Node slow = head;
+        Node fast = head;
+        while(fast!=null && fast.next!=null){
+            slow = slow.next;
+            fast = fast.next.next;
+            if(slow == fast ) return true;
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Diameter of a Binary Tree - GFG/README.md b/leetcode/leetcode/Diameter of a Binary Tree - GFG/README.md
new file mode 100644
index 0000000..b29319e
--- /dev/null
+++ b/leetcode/leetcode/Diameter of a Binary Tree - GFG/README.md	
@@ -0,0 +1,40 @@
+# Diameter of a Binary Tree
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">The diameter of a tree (sometimes called the width) is the number of nodes on the longest path between two end nodes. The diagram below shows two trees each with diameter nine, the leaves that form the ends of the longest path are shaded (note that there is more than one path in each tree of length nine, but no path longer than nine nodes).&nbsp;</span></p>
+
+<p><span style="font-size:18px"><a href="http://geeksforgeeks.org/wp-content/uploads/tree_diameter.GIF" target="_blank"><img alt="" class="aligncenter size-full wp-image-5737 img-responsive" src="https://contribute.geeksforgeeks.org/wp-content/uploads/diameter.jpg" style="height:319px; width:635px" title="tree_diameter"></a></span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>&nbsp;&nbsp;&nbsp;&nbsp;   1
+ &nbsp;&nbsp;&nbsp; /&nbsp;&nbsp;\
+ &nbsp;&nbsp; 2 &nbsp;&nbsp; 3
+<strong>Output: </strong>3</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;10
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp; \
+ &nbsp;&nbsp;&nbsp;&nbsp; 20&nbsp;&nbsp;&nbsp; 30
+ &nbsp;&nbsp; /&nbsp;&nbsp; \ 
+&nbsp;&nbsp; 40&nbsp;&nbsp; 60
+<strong>Output: </strong>4
+</span></pre>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong><br>
+<span style="font-size:18px">You need to <strong>complete </strong>the <strong>function diameter()&nbsp;</strong>that takes <strong>root&nbsp;</strong>as <strong>parameter </strong>and <strong>returns </strong>the <strong>diameter</strong>.<br>
+<br>
+<strong>Expected Time Complexity:&nbsp;</strong>O(N).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(Height of the Tree).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= Number of nodes &lt;= 10000<br>
+1 &lt;= Data of a node &lt;= 1000</span></p>
+
+<p dir="ltr">&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Diameter of a Binary Tree - GFG/diameter-of-a-binary-tree.java b/leetcode/leetcode/Diameter of a Binary Tree - GFG/diameter-of-a-binary-tree.java
new file mode 100644
index 0000000..60a1f03
--- /dev/null
+++ b/leetcode/leetcode/Diameter of a Binary Tree - GFG/diameter-of-a-binary-tree.java	
@@ -0,0 +1,143 @@
+// { Driver Code Starts
+// Initial Template for Java
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.io.*;
+import java.util.*;
+
+class Node {
+    int data;
+    Node left;
+    Node right;
+    Node(int data) {
+        this.data = data;
+        left = null;
+        right = null;
+    }
+}
+
+class GfG {
+
+    static Node buildTree(String str) {
+
+        if (str.length() == 0 || str.charAt(0) == 'N') {
+            return null;
+        }
+
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+
+        Queue<Node> queue = new LinkedList<>();
+
+        queue.add(root);
+        // Starting from the second element
+
+        int i = 1;
+        while (queue.size() > 0 && i < ip.length) {
+
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+
+            // Get the current node's value from the string
+            String currVal = ip[i];
+
+            // If the left child is not null
+            if (!currVal.equals("N")) {
+
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+
+            // For the right child
+            i++;
+            if (i >= ip.length) break;
+
+            currVal = ip[i];
+
+            // If the right child is not null
+            if (!currVal.equals("N")) {
+
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+
+        return root;
+    }
+    static void printInorder(Node root) {
+        if (root == null) return;
+
+        printInorder(root.left);
+        System.out.print(root.data + " ");
+
+        printInorder(root.right);
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br =
+            new BufferedReader(new InputStreamReader(System.in));
+
+        int t = Integer.parseInt(br.readLine());
+
+        while (t > 0) {
+            String s = br.readLine();
+            Node root = buildTree(s);
+            Solution g = new Solution();
+            System.out.println(g.diameter(root));
+            t--;
+        }
+    }
+}
+// } Driver Code Ends
+
+
+// User function Template for Java
+
+/*class Node {
+    int data;
+    Node left;
+    Node right;
+    Node(int data) {
+        this.data = data;
+        left = null;
+        right = null;
+    }
+}*/
+
+class Solution {
+    // Function to return the diameter of a Binary Tree.
+    class pair{
+        int lh;
+        int rh;
+        int dia;
+        pair(int lh, int rh, int dia){
+            this.lh = lh;
+            this.rh = rh; 
+            this.dia = dia;
+        }
+    }
+    pair helper(Node root){
+        if(root == null){
+            return new pair(0,0,0);
+        }
+        pair left = helper(root.left);
+        pair right = helper(root.right);
+        pair current = new pair(Math.max(left.lh,left.rh)+1,Math.max(right.rh,right.lh)+1,Math.max(left.dia,right.dia));
+        current.dia = Math.max(current.lh+current.rh -1,current.dia);
+        return current;
+        
+    }
+    int diameter(Node root) {
+        return helper(root).dia;
+    }
+}
diff --git a/leetcode/leetcode/Find Transition Point - GFG/README.md b/leetcode/leetcode/Find Transition Point - GFG/README.md
new file mode 100644
index 0000000..91e45a6
--- /dev/null
+++ b/leetcode/leetcode/Find Transition Point - GFG/README.md	
@@ -0,0 +1,39 @@
+# Find Transition Point
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a sorted array containing only 0s and 1s, find the transition point.&nbsp;</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 5
+arr[] = {0,0,0,1,1}
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> index 3 is the transition 
+point where 1 begins.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 4
+arr[] = {0,0,0,0}
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> Since, there is no "1",
+the answer is -1.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. The task is to complete the function <strong>transitionPoint()</strong> that takes array and N as input parameters and returns the 0 based index of the position where "0" ends and "1" begins. If array does not have any 1s, return -1. If array does not have any 0s, return 0.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(LogN)<br>
+<strong>Expected Auxiliary Space: </strong>O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 500000<br>
+0 ≤ arr[i] ≤ 1</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Find Transition Point - GFG/find-transition-point.java b/leetcode/leetcode/Find Transition Point - GFG/find-transition-point.java
new file mode 100644
index 0000000..3031a57
--- /dev/null
+++ b/leetcode/leetcode/Find Transition Point - GFG/find-transition-point.java	
@@ -0,0 +1,39 @@
+// { Driver Code Starts
+import java.util.*;
+
+class Sorted_Array {
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+        int T = sc.nextInt();
+        while (T > 0) {
+            int n = sc.nextInt();
+            int arr[] = new int[n];
+            for (int i = 0; i < n; i++) {
+                arr[i] = sc.nextInt();
+            }
+            GfG obj = new GfG();
+            System.out.println(obj.transitionPoint(arr, n));
+            T--;
+        }
+    }
+}// } Driver Code Ends
+
+
+class GfG {
+    int transitionPoint(int arr[], int n) {
+        if(arr[0] == 1) return 0;
+        if(arr[n-1] == 0) return -1;
+        int left = 0;
+        int right = n-1;
+        while(left<=right){
+            int mid = (left+right)/2;
+            if(arr[mid] == 0){
+                left = mid+1;
+            }else{
+                right = mid - 1;
+            }
+        }
+    
+        return left;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Find duplicates in an array - GFG/README.md b/leetcode/leetcode/Find duplicates in an array - GFG/README.md
new file mode 100644
index 0000000..02c6900
--- /dev/null
+++ b/leetcode/leetcode/Find duplicates in an array - GFG/README.md	
@@ -0,0 +1,38 @@
+# Find duplicates in an array
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array a[] of size N which contains elements from 0 to N-1, you need to find all the elements occurring more than once in the given array.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 4
+a[] = {0,3,1,2}
+<strong>Output: </strong>-1<strong>
+Explanation: </strong>N=4 and all elements from 0
+to (N-1 = 3) are present in the given
+array. Therefore output is -1.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 5
+a[] = {2,3,1,2,3}
+<strong>Output: </strong>2 3&nbsp;<strong>
+Explanation: </strong>2 and 3 occur more than once
+in the given array.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+Complete the function <strong>duplicates()</strong>&nbsp;which takes array a[] and n as input as parameters and returns a list of elements that occur more than once in the given array in sorted manner. If no such element is found, return list containing [-1].&nbsp;</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(n).<br>
+<strong>Expected Auxiliary Space:</strong> O(n).<br>
+Note : The extra space is only for the array to be returned.<br>
+Try and perform all operation withing the provided array.&nbsp;</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 10<sup>5</sup><br>
+0 &lt;= A[i] &lt;= N-1, for each valid i</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Find duplicates in an array - GFG/find-duplicates-in-an-array.java b/leetcode/leetcode/Find duplicates in an array - GFG/find-duplicates-in-an-array.java
new file mode 100644
index 0000000..4ae680f
--- /dev/null
+++ b/leetcode/leetcode/Find duplicates in an array - GFG/find-duplicates-in-an-array.java	
@@ -0,0 +1,41 @@
+// { Driver Code Starts
+import java.io.*;
+import java.util.*;
+
+class GFG {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            int[] a = new int[n];
+            for (int i = 0; i < n; i++) a[i] = sc.nextInt();
+            Solution g = new Solution();
+            ArrayList<Integer> ans = g.duplicates(a, n);
+            for (Integer val : ans) System.out.print(val + " ");
+            System.out.println();
+        }
+    }
+}
+// } Driver Code Ends
+
+
+class Solution {
+    public static ArrayList<Integer> duplicates(int arr[], int n) {
+        // code here
+        Set<Integer> s =  new HashSet<>();
+        Set<Integer> s1 = new HashSet<>();
+        ArrayList<Integer> list = new ArrayList<>();
+        for(int num: arr){
+            if(s1.contains(num)) continue;
+            if(s.contains(num)){
+              list.add(num);
+              s1.add(num);
+            } 
+            else s.add(num);
+        }
+        if(list.size()==0) list.add(-1);
+        Collections.sort(list);
+        return list;
+    }
+}
diff --git a/leetcode/leetcode/Finding middle element in a linked list - GFG/README.md b/leetcode/leetcode/Finding middle element in a linked list - GFG/README.md
new file mode 100644
index 0000000..502eb26
--- /dev/null
+++ b/leetcode/leetcode/Finding middle element in a linked list - GFG/README.md	
@@ -0,0 +1,37 @@
+# Finding middle element in a linked list
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a singly linked list of <strong>N</strong> nodes.<br>
+The task is to find the <strong>middle</strong>&nbsp;of the linked list. For example, if the&nbsp;linked list is<br>
+<strong>1-&gt; 2-&gt;3-&gt;4-&gt;5</strong>,<strong>&nbsp;</strong>then the middle node of the list is&nbsp;<strong>3</strong>.<br>
+If there are&nbsp;two middle nodes(in case, when&nbsp;<strong>N</strong>&nbsp;is even),&nbsp;print the <strong>second middle</strong> element.<br>
+For example, if the linked list given is <strong>1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;6</strong>, then the middle node of the list is <strong>4</strong>.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:</span></strong><strong><span style="font-size:18px">
+</span></strong><span style="font-size:18px">LinkedList: 1-&gt;2-&gt;3-&gt;4-&gt;5
+<strong>Output: </strong>3 
+<strong>Explanation:</strong> 
+Middle of linked list is 3.</span>
+</pre>
+
+<p><strong><span style="font-size:18px">Example 2:&nbsp;</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:</span></strong><strong><span style="font-size:18px">
+</span></strong><span style="font-size:18px">LinkedList: 2-&gt;4-&gt;6-&gt;7-&gt;5-&gt;1
+<strong>Output: </strong>7 
+<strong>Explanation:</strong> 
+Middle of linked list is 7.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+The task is to complete the function<span style="font-size:18px"> </span><strong>getMiddle</strong>() which takes a head reference as the only argument and should return the data at the middle node of the linked list.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 5000</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Finding middle element in a linked list - GFG/finding-middle-element-in-a-linked-list.java b/leetcode/leetcode/Finding middle element in a linked list - GFG/finding-middle-element-in-a-linked-list.java
new file mode 100644
index 0000000..68085f4
--- /dev/null
+++ b/leetcode/leetcode/Finding middle element in a linked list - GFG/finding-middle-element-in-a-linked-list.java	
@@ -0,0 +1,68 @@
+// { Driver Code Starts
+import java.util.*;
+import java.io.*;
+
+class Node{
+    int data;
+    Node next;
+    
+    Node(int x){
+        data = x;
+        next = null;
+    }
+    
+}
+class GFG{
+	static void printList(Node node) 
+	{ 
+		while (node != null) 
+		{ 
+			System.out.print(node.data + " "); 
+			node = node.next; 
+		} 
+		System.out.println(); 
+	}
+    public static void main(String args[]) throws IOException { 
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t > 0){
+        	int n = sc.nextInt();
+            Node head = new Node(sc.nextInt());
+            Node tail = head;
+            for(int i=0; i<n-1; i++)
+            {
+                tail.next = new Node(sc.nextInt());
+                tail = tail.next;
+            }
+            Solution g = new Solution();
+            int ans = g.getMiddle(head);
+            System.out.println(ans);
+            //printList(head); 
+            t--;
+        }
+    } 
+} 
+   // } Driver Code Ends
+
+
+/* Node of a linked list
+ class Node {
+   int data;
+    Node next;
+    Node(int d)  { data = d;  next = null; }
+}
+*/
+
+class Solution
+{
+    int getMiddle(Node head)
+    {
+         Node slow = head;
+         Node fast = head;
+         while(fast!=null && fast.next!=null){
+             slow = slow.next;
+             fast = fast.next.next;
+         }
+         return slow.data;
+    }
+}
diff --git a/leetcode/leetcode/GCD of two numbers - GFG/README.md b/leetcode/leetcode/GCD of two numbers - GFG/README.md
new file mode 100644
index 0000000..77e096d
--- /dev/null
+++ b/leetcode/leetcode/GCD of two numbers - GFG/README.md	
@@ -0,0 +1,32 @@
+# GCD of two numbers
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given two positive integers A and B, find GCD of A and B.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> A = 3, B = 6
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> GCD of 3 and 6 is 3</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> A = 1, B = 1
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> GCD of 1 and 1 is 1</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task: &nbsp;</strong><br>
+You don't need to read input or print anything. Complete the function <strong>gcd()</strong> which takes two positive integers as input parameters and returns an integer.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(log(min(A, B)))<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1) </span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ A, B ≤ 10<sup>9</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/GCD of two numbers - GFG/gcd-of-two-numbers.java b/leetcode/leetcode/GCD of two numbers - GFG/gcd-of-two-numbers.java
new file mode 100644
index 0000000..245c87c
--- /dev/null
+++ b/leetcode/leetcode/GCD of two numbers - GFG/gcd-of-two-numbers.java	
@@ -0,0 +1,32 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+import java.io.*;
+import java.util.*;
+class GfG
+{
+    public static void main(String args[])
+        {
+            Scanner sc = new Scanner(System.in);
+            int t = sc.nextInt();
+            while(t-->0)
+                {
+                    int A = sc.nextInt();
+                    int B = sc.nextInt();
+                    Solution ob = new Solution();
+                    System.out.println(ob.gcd(A,B));
+                }
+        }
+}    // } Driver Code Ends
+
+
+//User function Template for Java
+
+class Solution
+{
+    public int gcd(int A , int B) 
+    { 
+        if(A==0) return B;
+        return gcd(B%A,A);
+    } 
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Get minimum element from stack - GFG/README.md b/leetcode/leetcode/Get minimum element from stack - GFG/README.md
new file mode 100644
index 0000000..9534bfb
--- /dev/null
+++ b/leetcode/leetcode/Get minimum element from stack - GFG/README.md	
@@ -0,0 +1,37 @@
+# Get minimum element from stack
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">You are given <strong>N</strong>&nbsp;elements&nbsp;and your task is to Implement a Stack in which you can get minimum element in O(1) time.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>push(2)
+push(3)
+pop()
+getMin()
+push(1)
+getMin()<strong>
+Output: </strong>3 2 1<strong>
+Explanation: </strong>In the first test case for
+query&nbsp;
+push(2)&nbsp; the stack&nbsp;will be {2}
+push(3)&nbsp; the stack&nbsp;will be {2 3}
+pop()    poped element will be 3&nbsp;the
+&nbsp;        stack will be {2}
+getMin() min element will be 2&nbsp;
+push(1)  the stack&nbsp;will be {2 1}
+getMin() min element will be 1</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You are required to complete the three&nbsp;methods&nbsp;<strong>push()</strong>&nbsp;which take one argument an integer <strong>'x'</strong>&nbsp;to be pushed into the stack,&nbsp;<strong>pop()</strong>&nbsp;which returns a integer&nbsp;poped out from the stack and <strong>getMin()</strong> which returns the min element from the stack. (-1 will be returned if for&nbsp;<strong>pop() and getMin()&nbsp;</strong>the stack is empty.)</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity</strong> : O(1) for all the 3 methods.<br>
+<strong>Expected Auixilliary Space</strong> : O(1) for all the 3 methods.</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= Number of queries&nbsp;&lt;= 100<br>
+1 &lt;= values of the stack&nbsp;&lt;= 100</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Get minimum element from stack - GFG/get-minimum-element-from-stack.java b/leetcode/leetcode/Get minimum element from stack - GFG/get-minimum-element-from-stack.java
new file mode 100644
index 0000000..5788b44
--- /dev/null
+++ b/leetcode/leetcode/Get minimum element from stack - GFG/get-minimum-element-from-stack.java	
@@ -0,0 +1,88 @@
+// { Driver Code Starts
+import java.util.*;
+
+
+
+class Get_Min_From_Stack
+{
+	public static void main(String args[])
+	{
+		Scanner sc = new Scanner(System.in);
+		int T = sc.nextInt();
+		while(T>0)
+		{
+			int q = sc.nextInt();
+			GfG g = new GfG();
+			while(q>0)
+			{
+				int qt = sc.nextInt();
+				
+				if(qt == 1)
+				{
+					int att = sc.nextInt();
+					g.push(att);
+					//System.out.println(att);
+				}
+				else if(qt == 2)
+				{
+					System.out.print(g.pop()+" ");
+				}
+				else if(qt == 3)
+				{
+					System.out.print(g.getMin()+" ");
+				}
+			
+			q--;
+			}
+			System.out.println();
+		T--;
+		}
+		
+	}
+}
+
+
+// } Driver Code Ends
+
+
+class GfG
+{
+    class Node{
+        int val;
+        int min;
+        Node next;
+        Node(int val, int min, Node next){
+            this.val = val;
+            this.min = min;
+            this.next = next;
+        }
+    }
+    Node head = null;
+    /*returns min element from stack*/
+    int getMin()
+    {
+        if(head ==null) return -1;
+        return head.min;
+    }
+    
+    /*returns poped element from stack*/
+    int pop()
+    {
+        if(head == null) return -1;
+        int val = head.val;
+        head = head.next;
+        return val;
+    }
+
+    /*push element x into the stack*/
+    void push(int x)
+    {
+        if(head == null){
+            head = new Node(x,x,null);
+            return;
+        }
+        Node temp = new Node(x,Math.min(head.min,x),head);
+        head=   temp;
+    }	
+}
+
diff --git a/leetcode/leetcode/Given a linked list of 0s, 1s and 2s, sort it. - GFG/README.md b/leetcode/leetcode/Given a linked list of 0s, 1s and 2s, sort it. - GFG/README.md
new file mode 100644
index 0000000..fa626b7
--- /dev/null
+++ b/leetcode/leetcode/Given a linked list of 0s, 1s and 2s, sort it. - GFG/README.md	
@@ -0,0 +1,37 @@
+# Given a linked list of 0s, 1s and 2s, sort it.
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a linked list of <strong>N</strong>&nbsp;nodes where nodes can contain values&nbsp;<strong>0s</strong>, <strong>1s,</strong> and <strong>2s&nbsp;</strong>only. The task is to segregate <strong>0s</strong>, <strong>1s,</strong> and <strong>2s</strong>&nbsp;linked list such that all zeros segregate to head side, 2s at the end of the linked list, and 1s in the mid of 0s and 2s.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 8
+value[] = {1,2,2,1,2,0,2,2}
+<strong>Output: </strong>0 1 1 2 2 2 2 2<strong>
+Explanation: </strong>All the 0s are segregated
+to the left end of the linked list,
+2s to the right end of the list, and
+1s in between.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 4
+value[] = {2,2,0,1}
+<strong>Output: </strong>0 1 2 2<strong>
+Explanation: </strong>After arranging all the
+0s,1s and 2s in the given format,
+the output will be 0 1 2 2.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+The task is to complete the function <strong>segregate</strong>() which segregates the nodes in the linked list as asked in the problem statement and returns the head of the modified linked list. The <strong>printing </strong>is done <strong>automatically </strong>by the <strong>driver code</strong>.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 10<sup>3</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Given a linked list of 0s, 1s and 2s, sort it. - GFG/given-a-linked-list-of-0s-1s-and-2s-sort-it..java b/leetcode/leetcode/Given a linked list of 0s, 1s and 2s, sort it. - GFG/given-a-linked-list-of-0s-1s-and-2s-sort-it..java
new file mode 100644
index 0000000..0e565a4
--- /dev/null
+++ b/leetcode/leetcode/Given a linked list of 0s, 1s and 2s, sort it. - GFG/given-a-linked-list-of-0s-1s-and-2s-sort-it..java	
@@ -0,0 +1,106 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class Node
+{
+    int data;
+    Node next;
+    Node(int key)
+    {
+        data = key;
+        next = null;
+    }
+}
+
+class Driverclass
+{
+    public static void main (String[] args) 
+    {
+        Scanner sc= new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            Node head = new Node(sc.nextInt());
+            Node tail = head;
+            while(n-- > 1){
+		        tail.next = new Node(sc.nextInt());
+		        tail = tail.next;
+		    }
+		   
+		      head = new Solution().segregate(head);
+		     printList(head);
+		    System.out.println();
+        }
+    }
+    
+    public static void printList(Node head)
+    {
+        if(head == null)
+           return;
+           
+        Node temp = head;
+        while(temp != null)
+        {
+            System.out.print(temp.data + " ");
+            temp = temp.next;
+        }
+    }
+    
+    
+}
+
+
+
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+/*
+class Node
+{
+    int data;
+    Node next;
+    Node(int data)
+    {
+        this.data = data;
+        next = null;
+    }
+}
+*/
+class Solution
+{
+    //Function to sort a linked list of 0s, 1s and 2s.
+    static Node segregate(Node head)
+    {
+        Node temp = head;
+        int zeros = 0;
+        int ones = 0;
+        while(temp!=null){
+            if(temp.data == 0) zeros++;
+            else if(temp.data == 1) ones++;
+            temp = temp.next;
+        }
+        temp =head;
+        while(temp!=null){
+            if(zeros!=0){
+                temp.data = 0;
+                zeros--;
+            }else if(ones!=0){
+                temp.data= 1;
+                ones--;
+            }else temp.data = 2;
+            temp = temp.next;
+        }
+        return head;
+    }
+    
+}
+
+
diff --git a/leetcode/leetcode/Height of Binary Tree - GFG/README.md b/leetcode/leetcode/Height of Binary Tree - GFG/README.md
new file mode 100644
index 0000000..6bb8820
--- /dev/null
+++ b/leetcode/leetcode/Height of Binary Tree - GFG/README.md	
@@ -0,0 +1,39 @@
+# Height of Binary Tree
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a binary tree, find its height.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+     1
+    /  \
+   2    3
+<strong>Output:</strong> 2</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+  2
+   \
+    1
+   /
+ 3
+<strong>Output:</strong> 3   </span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Your task is to complete the function <strong>height() </strong>which takes root node of the tree as input parameter and returns an integer denoting the height of the tree. If the tree is empty, return 0.&nbsp;</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N)<br>
+<strong>Expected Auxiliary Space:</strong> O(N)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= Number of nodes &lt;= 10<sup>5</sup><br>
+1 &lt;= Data of a node &lt;= 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Height of Binary Tree - GFG/height-of-binary-tree.java b/leetcode/leetcode/Height of Binary Tree - GFG/height-of-binary-tree.java
new file mode 100644
index 0000000..6e9d929
--- /dev/null
+++ b/leetcode/leetcode/Height of Binary Tree - GFG/height-of-binary-tree.java	
@@ -0,0 +1,128 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+import java.lang.*; 
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+class GFG {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    static void printInorder(Node root){
+        if(root == null)
+            return;
+            
+        printInorder(root.left);
+        System.out.print(root.data+" ");
+        
+        printInorder(root.right);
+    }
+    
+	public static void main (String[] args) throws IOException{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int t=Integer.parseInt(br.readLine());
+
+        while(t > 0){
+            String s = br.readLine();
+	    	Node root = buildTree(s);
+	    	
+            Solution ob = new Solution();
+    		System.out.println(ob.height(root));
+            t--;
+        }
+    }
+}// } Driver Code Ends
+
+
+//User function Template for Java
+
+/* 
+class Node
+{
+    int data;
+    Node left, right;
+
+    Node(int item)
+    {
+        data = item;
+        left = right = null;
+    }
+}
+ */
+
+class Solution {
+    //Function to find the height of a binary tree.
+    int height(Node node) 
+    {
+        if(node == null) return 0;
+        return Math.max(height(node.left),height(node.right))+1;
+    }
+}
diff --git a/leetcode/leetcode/Inorder Successor in BST - GFG/README.md b/leetcode/leetcode/Inorder Successor in BST - GFG/README.md
new file mode 100644
index 0000000..d9c2abd
--- /dev/null
+++ b/leetcode/leetcode/Inorder Successor in BST - GFG/README.md	
@@ -0,0 +1,50 @@
+# Inorder Successor in BST
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a BST, and a reference to a Node x in the BST. Find the Inorder Successor of the given node in the BST.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+&nbsp;     2</strong>
+&nbsp;   /   \
+<strong>   </strong>1     3
+K(data of x) = 2
+<strong>Output: </strong>3 
+<strong>Explanation:</strong> 
+Inorder traversal : 1 2 3 
+Hence, inorder successor of 2 is 3.</span>
+</pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong><strong>            </strong> 20
+&nbsp;           /   \
+&nbsp;          8<strong>     </strong>22
+&nbsp;         / \
+&nbsp;        4   12
+&nbsp;           /<strong>  </strong>\
+&nbsp;          10   14
+K(data of x) = 8
+<strong>Output: </strong>10<strong>
+Explanation:
+</strong>Inorder traversal: 4 8 10 12 14 20 22
+Hence, successor of 8 is 10.</span></pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Your task is to complete the function</span><span style="font-size:18px">&nbsp;<strong>inOrderSuccessor()</strong>. This function takes the root node and the reference node as argument and returns the node that is inOrder successor of&nbsp;the reference node. If there is no successor, return null value.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(Height of the BST).<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(1).</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 1000, where N is number of nodes</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Inorder Successor in BST - GFG/inorder-successor-in-bst.java b/leetcode/leetcode/Inorder Successor in BST - GFG/inorder-successor-in-bst.java
new file mode 100644
index 0000000..b2ba45d
--- /dev/null
+++ b/leetcode/leetcode/Inorder Successor in BST - GFG/inorder-successor-in-bst.java	
@@ -0,0 +1,148 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node
+{
+    int data;
+    Node left;
+    Node right;
+    Node(int data)
+    {
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+class GfG {
+    
+    static Node buildTree(String str)
+    {
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+
+    public static Node search(Node root,int x){
+		if(root==null||root.data==x)
+			return root;
+		if(root.data>x)
+			return search(root.left,x);
+		return search(root.right,x);
+	}
+
+	public static void main (String[] args) throws IOException{
+            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+            
+            int t=Integer.parseInt(br.readLine());
+            
+            while(t > 0){
+                String s = br.readLine();
+                Node root = buildTree(s);
+                
+                int k=Integer.parseInt(br.readLine());
+                Node kNode = search(root,k);
+                
+                Solution g = new Solution();
+                Node x = g.inorderSuccessor(root,kNode);
+                
+                if(x==null) System.out.println("-1");
+                else System.out.println(x.data);
+                t--;
+            }
+    }
+}// } Driver Code Ends
+
+
+//User function Template for Java
+
+/*Complete the function below
+Node is as follows:
+class Node{
+	int data;
+	Node left,right;
+	Node(int d){
+		data=d;
+		left=right=null;
+	}
+}
+*/
+class Solution
+{
+    boolean check = false;
+    // returns the inorder successor of the Node x in BST (rooted at 'root')
+	public Node inorderSuccessor(Node root,Node x)
+	{
+	    if(root == null) return root;
+	    Node left = inorderSuccessor(root.left,x);
+	    if(left!=null){
+	        return left;
+	    }
+	    if(check == true){
+	        check = false;
+	        return root;
+	    }
+	    if(root.data == x.data){
+	        check  = true;
+	        return inorderSuccessor(root.right,x);
+	    }
+	    Node right = inorderSuccessor(root.right,x);
+	    if(right!=null) return right;
+	    return null;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Intersection Point in Y Shapped Linked Lists - GFG/README.md b/leetcode/leetcode/Intersection Point in Y Shapped Linked Lists - GFG/README.md
new file mode 100644
index 0000000..061e036
--- /dev/null
+++ b/leetcode/leetcode/Intersection Point in Y Shapped Linked Lists - GFG/README.md	
@@ -0,0 +1,57 @@
+# Intersection Point in Y Shapped Linked Lists
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given two singly linked lists of size <strong>N</strong> and <strong>M, </strong>write a program to get the point where two linked lists intersect each other.</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong><strong>
+</strong>LinkList1 = 3-&gt;6-&gt;9-&gt;common
+LinkList2 = 10-&gt;common
+common = 15-&gt;30-&gt;NULL
+<strong>Output: 1</strong>5
+<strong>Explanation:
+</strong><img alt="Y ShapedLinked List" class="aligncenter size-full wp-image-2753 img-responsive" src="https://contribute.geeksforgeeks.org/wp-content/uploads/linked.jpg" style="height:334px; width:388px" title="Y ShapedLinked List"></span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: 
+</strong>Linked List 1 = 4-&gt;1-&gt;common
+Linked List 2 = 5-&gt;6-&gt;1-&gt;common
+common = 8-&gt;4-&gt;5-&gt;NULL
+<strong>Output: </strong>8
+<strong>Explanation: </strong></span>
+
+<span style="font-size:18px"><strong>4              5</strong></span>
+<span style="font-size:18px"><strong>|              |</strong></span>
+<span style="font-size:18px"><strong>1              6
+</strong></span><span style="font-size:18px"><strong> \             /</strong></span>
+<span style="font-size:18px"><strong>  8   -----  1 </strong></span>
+   <strong>|</strong>
+   <strong>4</strong>
+   <strong>|
+</strong><span style="font-size:18px"><strong>  5</strong></span>
+<span style="font-size:18px"><strong>  |</strong></span>
+<span style="font-size:18px"><strong>  NULL       </strong></span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. The task is to complete the function <strong>intersetPoint</strong>() which takes the pointer to the head of linklist1(<strong>head1</strong>) and linklist2(<strong>head2</strong>) as input parameters and&nbsp;returns data value of a node where two linked lists intersect. If linked list do not merge at any point, then it should&nbsp;return <strong>-1</strong>.</span><br>
+<span style="font-size:18px"><strong>Challenge </strong>: Try to solve the problem without using any extra space.</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N+M)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(1)</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N + M ≤&nbsp;2*10<sup>5</sup><br>
+-1000&nbsp;≤&nbsp;value ≤&nbsp;1000</span></p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Intersection Point in Y Shapped Linked Lists - GFG/intersection-point-in-y-shapped-linked-lists.java b/leetcode/leetcode/Intersection Point in Y Shapped Linked Lists - GFG/intersection-point-in-y-shapped-linked-lists.java
new file mode 100644
index 0000000..ada31ce
--- /dev/null
+++ b/leetcode/leetcode/Intersection Point in Y Shapped Linked Lists - GFG/intersection-point-in-y-shapped-linked-lists.java	
@@ -0,0 +1,163 @@
+// { Driver Code Starts
+import java.util.*;
+
+
+class Node
+{
+    int data;
+    Node next;
+    Node(int d) {
+        data = d; 
+        next = null;
+    }
+}
+	
+ class LinkedList_Intersection
+{
+    Node head = null;  
+	Node tail = null;
+
+public void addToTheLast(Node node) 
+{
+
+  if (head == null) {
+   head = node;
+   tail = head;
+  } else {
+   //Node temp = head;
+   //while (temp.next != null)
+    //temp = temp.next;
+
+   //temp.next = node;
+   tail.next=node;
+   tail = node;
+  }
+}
+
+  /* Function to print linked list */
+    void printList()
+    {
+        Node temp = head;
+        while (temp != null)
+        {
+           System.out.print(temp.data+" ");
+           temp = temp.next;
+        }  
+        System.out.println();
+    }
+	
+	 
+ 
+     /* Driver program to test above functions */
+    public static void main(String args[])
+    {
+       
+         
+        /* Constructed Linked List is 1->2->3->4->5->6->
+           7->8->8->9->null */
+         Scanner sc = new Scanner(System.in);
+		 int t=sc.nextInt();
+		 
+		 while(t>0)
+         {
+			int n1 = sc.nextInt();
+			int n2 = sc.nextInt();
+			int n3 = sc.nextInt();
+			LinkedList_Intersection llist1 = new LinkedList_Intersection();
+		    LinkedList_Intersection llist2 = new LinkedList_Intersection();
+			LinkedList_Intersection llist3 = new LinkedList_Intersection();
+			
+				int a1=sc.nextInt();
+				Node head1= new Node(a1);
+				Node tail1= head1;
+				
+				for (int i = 1; i < n1; i++) 
+				{
+					int a = sc.nextInt(); 
+					tail1.next = (new Node(a));
+					tail1= tail1.next;
+				}
+			
+			
+				int b1=sc.nextInt();
+				Node head2 = new Node(b1);
+				Node tail2 = head2;
+				for (int i = 1; i < n2; i++) 
+				{
+					int b = sc.nextInt();  
+					tail2.next = (new Node(b));
+					tail2= tail2.next;
+				}
+				
+				int c1=sc.nextInt();
+				Node head3= new Node(c1);
+				tail1.next = head3;
+				tail2.next = head3;
+				Node tail3=head3;
+				for (int i = 1; i < n3; i++) 
+				{
+					int c = sc.nextInt();   
+					tail3.next = (new Node(c));
+					tail3= tail3.next;
+				}
+				
+				Intersect obj = new Intersect();
+				System.out.println(obj.intersectPoint(head1, head2));
+			t--;			
+         }
+    }
+}
+// } Driver Code Ends
+
+
+/* Node of a linked list
+ class Node {
+   int data;
+    Node next;
+    Node(int d)  { data = d;  next = null; }
+}
+ Linked List class
+class LinkedList
+{
+    Node head;  // head of list
+}*/
+
+class Intersect
+{
+    int size(Node head){
+        int res = 0;
+        Node temp = head;
+	    while(temp!=null){
+	        temp = temp.next;
+	        res++;
+	    }
+	    return res;
+    }
+    Node nthNode(Node head, int n){
+        Node temp = head;
+        while(n!=0){
+            temp = temp.next;
+            n--;
+        }
+        return temp;
+    }
+    //Function to find intersection point in Y shaped Linked Lists.
+	int intersectPoint(Node head1, Node head2)
+	{
+	    int size1 = size(head1);
+	    int size2 = size(head2);
+	    int common = Math.abs(size1-size2);
+	    if(size1>size2){
+	        head1 = nthNode(head1,common);
+	    }else if(size2>size1){
+	        head2 =  nthNode(head2,common);
+	    }
+	    while(head1!=head2){
+	        head1 = head1.next;
+	        head2 = head2.next;
+	    }
+	    return head2.data;
+	}
+}
+
+
diff --git a/leetcode/leetcode/Kadane's Algorithm - GFG/README.md b/leetcode/leetcode/Kadane's Algorithm - GFG/README.md
new file mode 100644
index 0000000..8b58152
--- /dev/null
+++ b/leetcode/leetcode/Kadane's Algorithm - GFG/README.md	
@@ -0,0 +1,44 @@
+# Kadane's Algorithm
+##  Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array <strong>Arr[]&nbsp;</strong>of <strong>N</strong> integers. Find the contiguous sub-array(containing at least one number) which has the&nbsp;maximum sum and return its sum.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 5
+Arr[] = {1,2,3,-2,5}
+<strong>Output:
+</strong>9<strong>
+Explanation:
+</strong>Max subarray sum is 9
+of elements (1, 2, 3, -2, 5) which 
+is a contiguous subarray.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 4
+Arr[] = {-1,-2,-3,-4}
+<strong>Output:
+</strong>-1<strong>
+Explanation:
+</strong>Max subarray sum is -1 
+of element (-1)</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything.&nbsp;The task is to complete the function <strong>maxSubarraySum</strong>() which takes Arr[] and N as input parameters and returns the sum of&nbsp;subarray with maximum sum.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N)<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>6</sup><br>
+-10<sup>7</sup> ≤ A[i] ≤ 10<sup>7</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Kadane's Algorithm - GFG/kadanes-algorithm.java b/leetcode/leetcode/Kadane's Algorithm - GFG/kadanes-algorithm.java
new file mode 100644
index 0000000..de94de3
--- /dev/null
+++ b/leetcode/leetcode/Kadane's Algorithm - GFG/kadanes-algorithm.java	
@@ -0,0 +1,50 @@
+// { Driver Code Starts
+import java.io.*;
+
+class Main {
+    
+	public static void main (String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int t = Integer.parseInt(br.readLine().trim()); //Inputting the testcases
+		while(t-->0){
+		    //size of array
+		    int n = Integer.parseInt(br.readLine().trim());
+		    int arr[] = new int[n];
+		    String inputLine[] = br.readLine().trim().split(" ");
+		    
+		    //adding elements
+		    for(int i=0; i<n; i++){
+		        arr[i] = Integer.parseInt(inputLine[i]);
+		    }
+		    
+		    Solution obj = new Solution();
+		    
+		    //calling maxSubarraySum() function
+		    System.out.println(obj.maxSubarraySum(arr, n));
+		}
+	}
+}
+
+// } Driver Code Ends
+
+
+class Solution{
+
+    // arr: input array
+    // n: size of array
+    //Function to find the sum of contiguous subarray with maximum sum.
+    long maxSubarraySum(int arr[], int n){
+        
+        // Your code here
+        long maxEndingHere = 0;
+        long maxSoFar = Integer.MIN_VALUE;
+        for(int num: arr){
+            maxEndingHere+=num;
+            if(maxEndingHere<num) maxEndingHere = num;
+            if(maxSoFar<maxEndingHere) maxSoFar = maxEndingHere;
+        }
+        return maxSoFar;
+    }
+    
+}
+
diff --git a/leetcode/leetcode/Largest value in each level - GFG/README.md b/leetcode/leetcode/Largest value in each level - GFG/README.md
new file mode 100644
index 0000000..baa39d3
--- /dev/null
+++ b/leetcode/leetcode/Largest value in each level - GFG/README.md	
@@ -0,0 +1,51 @@
+# Largest value in each level
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a binary tree, find the largest value in each level.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input :</span></strong>
+<span style="font-size:18px">        1
+       / \
+      2   3 </span>
+
+<span style="font-size:18px"><strong>Output :</strong> 1 3</span>
+<strong><span style="font-size:18px">Explanation : </span></strong>
+<span style="font-size:18px">There are two levels in the tree :
+</span><span style="font-size:18px">1. {1}, max = 1</span>
+<span style="font-size:18px">2. {2, 3}, max = 3</span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input :</span></strong>
+<span style="font-size:18px">        4
+       / \
+      9   2
+     / \   \
+    3   5   7 </span>
+
+<span style="font-size:18px"><strong>Output :</strong> 4 9 7</span>
+<strong><span style="font-size:18px">Explanation : </span></strong>
+<span style="font-size:18px">There are three levels in the tree:</span>
+<span style="font-size:18px">1. {4}, max = 4</span>
+<span style="font-size:18px">2. {9, 2}, max = 9</span>
+<span style="font-size:18px">3. {3, 5, 7}, max=7</span></pre>
+
+<div><strong><span style="font-size:18px">Your task :</span></strong></div>
+
+<div><span style="font-size:18px">You don't need to read input or print anything. Your task is to complete the function <strong>largestValues()</strong> which takes the root node of the tree as input and returns a vector containing the largest value in each level.&nbsp;</span></div>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Expected Time Complexity :</strong> O(n) , where n = number of nodes</span></div>
+
+<div><span style="font-size:18px"><strong>Expected Auxiliary Space :</strong> O(n) , where n = number of nodes</span></div>
+
+<div>&nbsp;</div>
+
+<div><strong><span style="font-size:18px">Constraints :&nbsp;</span></strong></div>
+
+<div><span style="font-size:18px">1 ≤&nbsp;Number of nodes ≤&nbsp;10^5</span></div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Largest value in each level - GFG/largest-value-in-each-level.java b/leetcode/leetcode/Largest value in each level - GFG/largest-value-in-each-level.java
new file mode 100644
index 0000000..ac7b64c
--- /dev/null
+++ b/leetcode/leetcode/Largest value in each level - GFG/largest-value-in-each-level.java	
@@ -0,0 +1,137 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+class Tree {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    static void printInorder(Node root)
+    {
+        if(root == null)
+            return;
+            
+        printInorder(root.left);
+        System.out.print(root.data+" ");
+        
+        printInorder(root.right);
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t > 0){
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+    	    	
+                Solution g = new Solution();
+               ArrayList<Integer> ans = g.largestValues(root);
+               
+                for(int i=0;i<ans.size();i++)
+                    System.out.print(ans.get(i)+" ");
+                    
+                System.out.println();
+        	
+                t--;
+            
+        }
+    }
+}
+
+
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+class Solution
+{
+    public ArrayList<Integer> largestValues(Node root)
+    {
+        ArrayList<Integer> list = new ArrayList<>();
+        Queue<Node> q = new LinkedList<>();
+        q.add(root);
+        while(!q.isEmpty()){
+            int max = Integer.MIN_VALUE;
+            for(int i = q.size();i!=0;i--){
+                root = q.remove();
+                max = Math.max(max,root.data);
+                if(root.left!=null) q.add(root.left);
+                if(root.right!=null) q.add(root.right);
+            }
+            list.add(max);
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Left View of Binary Tree - GFG/README.md b/leetcode/leetcode/Left View of Binary Tree - GFG/README.md
new file mode 100644
index 0000000..d4fb5ae
--- /dev/null
+++ b/leetcode/leetcode/Left View of Binary Tree - GFG/README.md	
@@ -0,0 +1,42 @@
+# Left View of Binary Tree
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a Binary Tree, print Left view of it. Left view of a Binary Tree is set of nodes visible when tree is visited from Left side. The task is to complete the function <strong>leftView()</strong>, which accepts root of the tree as argument.</span></p>
+
+<p><span style="font-size:18px">Left view of following tree is 1 2 4 8.</span></p>
+
+<p><span style="font-size:18px">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 1<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp;&nbsp;&nbsp; \<br>
+&nbsp;&nbsp;&nbsp;&nbsp; 2&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 3<br>
+&nbsp;&nbsp; /&nbsp;&nbsp; &nbsp; \ &nbsp;&nbsp; /&nbsp;&nbsp;&nbsp; \<br>
+&nbsp; 4&nbsp;&nbsp;&nbsp;&nbsp; 5&nbsp;&nbsp; 6&nbsp;&nbsp;&nbsp; 7<br>
+&nbsp;&nbsp; \<br>
+&nbsp;&nbsp;&nbsp;&nbsp; 8&nbsp; &nbsp;</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>&nbsp;  1
+&nbsp;/&nbsp; \
+3&nbsp; &nbsp; 2
+<strong>Output: </strong>1 3<strong>
+</strong></span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong><img alt="" src="https://media.geeksforgeeks.org/wp-content/cdn-uploads/20190221103723/leftview.jpg" style="height:272px; width:285px" class="img-responsive">
+<strong>Output: </strong>10 20 40
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You just have to <strong>complete </strong>the function <strong>leftView() </strong>that prints the left view. The newline is automatically appended by the driver code.</span><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(Height of the Tree).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+0 &lt;= Number of nodes &lt;= 100<br>
+1 &lt;= Data of a node &lt;= 1000</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Left View of Binary Tree - GFG/left-view-of-binary-tree.java b/leetcode/leetcode/Left View of Binary Tree - GFG/left-view-of-binary-tree.java
new file mode 100644
index 0000000..2d19e95
--- /dev/null
+++ b/leetcode/leetcode/Left View of Binary Tree - GFG/left-view-of-binary-tree.java	
@@ -0,0 +1,141 @@
+// { Driver Code Starts
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+class GfG {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    static void printInorder(Node root)
+    {
+        if(root == null)
+            return;
+            
+        printInorder(root.left);
+        System.out.print(root.data+" ");
+        
+        printInorder(root.right);
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t > 0){
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+        	    Tree g = new Tree();
+    			ArrayList<Integer> result = g.leftView(root);
+    			for(int value : result){
+    			    System.out.print(value + " ");
+    			}
+    			System.out.println();
+                t--;
+        }
+    }
+}
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+/* A Binary Tree node
+class Node
+{
+    int data;
+    Node left, right;
+
+    Node(int item)
+    {
+        data = item;
+        left = right = null;
+    }
+}*/
+class Tree
+{
+    //Function to return list containing elements of left view of binary tree.
+    ArrayList<Integer> leftView(Node root)
+    {
+        ArrayList<Integer> list = new ArrayList<>();
+        if(root == null) return list;
+        Queue<Node> q = new LinkedList<>();
+        q.add(root);
+        while(!q.isEmpty()){
+            list.add(q.peek().data);
+            for(int i = q.size();i>0;i--){
+                Node front = q.remove();
+                if(front.left!=null) q.add(front.left);
+                if(front.right!=null) q.add(front.right);
+          }
+      }
+      return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Level order traversal in spiral form - GFG/README.md b/leetcode/leetcode/Level order traversal in spiral form - GFG/README.md
new file mode 100644
index 0000000..a63b472
--- /dev/null
+++ b/leetcode/leetcode/Level order traversal in spiral form - GFG/README.md	
@@ -0,0 +1,40 @@
+# Level order traversal in spiral form
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Complete the function to find spiral order traversal of a tree. For below tree, function should return 1, 2, 3, 4, 5, 6, 7.<br>
+<br>
+<br>
+<strong>&nbsp;<img alt="" src="https://contribute.geeksforgeeks.org/wp-content/uploads/level.jpg" style="height:290px; width:539px" class="img-responsive"></strong></span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1
+ &nbsp;&nbsp; /&nbsp;&nbsp; \
+ &nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;&nbsp; 2
+<strong>Output:</strong>1 3 2<strong>
+</strong></span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 10
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp;&nbsp;&nbsp; \
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 20&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;30
+ &nbsp;&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp;&nbsp; \
+ &nbsp;&nbsp; 40&nbsp;&nbsp;&nbsp;&nbsp; 60
+<strong>Output: </strong>10 20 30 60 40&nbsp;
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+The task is to complete the function <strong>findSpiral</strong>()&nbsp;which takes&nbsp;<strong>root&nbsp;</strong>node as input parameter&nbsp;and returns&nbsp;the elements in spiral form of level order traversal as a list. The newline is automatically appended by the driver code.<br>
+<strong>Expected Time Complexity:&nbsp;</strong>O(N).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(N).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+0 &lt;= Number of nodes &lt;= 10<sup>5</sup><br>
+0 &lt;= Data of a node &lt;= 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Level order traversal in spiral form - GFG/level-order-traversal-in-spiral-form.java b/leetcode/leetcode/Level order traversal in spiral form - GFG/level-order-traversal-in-spiral-form.java
new file mode 100644
index 0000000..486bee5
--- /dev/null
+++ b/leetcode/leetcode/Level order traversal in spiral form - GFG/level-order-traversal-in-spiral-form.java	
@@ -0,0 +1,163 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+
+
+//Initial Template for Java
+
+//Contributed by Sudarshan Sharma
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+
+class GfG {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    void inOrder(Node node) {
+        if (node == null) {
+            return;
+        }
+ 
+        inOrder(node.left);
+        System.out.print(node.data + " ");
+ 
+        inOrder(node.right);
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t-- > 0){
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+                Spiral g = new Spiral();
+                ArrayList<Integer> result = g.findSpiral(root);
+                for(int value : result)
+                System.out.print(value + " ");
+			    System.out.println();
+    	        
+	        }
+	}
+}
+
+
+
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+
+/*
+// A Binary Tree node
+class Node
+{
+    int data;
+    Node left, right;
+
+    Node(int item)
+    {
+        data = item;
+        left = right = null;
+    }
+}
+*/
+
+class Spiral
+{
+    //Function to return a list containing the level order 
+    //traversal in spiral form.	
+    ArrayList<Integer> findSpiral(Node root) 
+    {
+        ArrayList<Integer> list = new ArrayList<>();
+        if(root == null) return list;
+        Queue<Node> q = new LinkedList<>();
+        q.add(root);
+        boolean isRotated = true;
+        while(!q.isEmpty()){
+            int size = list.size();
+            for(int i = q.size();i!=0;i--){
+                root = q.remove();
+                if(isRotated){
+                    list.add(size,root.data);
+                }else{
+                    list.add(root.data);
+                }
+                if(root.left!=null) q.add(root.left);
+                if(root.right!=null) q.add(root.right);
+            }
+            isRotated = !isRotated;
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Lowest Common Ancestor in a Binary Tree - GFG/README.md b/leetcode/leetcode/Lowest Common Ancestor in a Binary Tree - GFG/README.md
new file mode 100644
index 0000000..e42b152
--- /dev/null
+++ b/leetcode/leetcode/Lowest Common Ancestor in a Binary Tree - GFG/README.md	
@@ -0,0 +1,40 @@
+# Lowest Common Ancestor in a Binary Tree
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px"><span style="font-family:arial,helvetica,sans-serif">Given a Binary Tree with all <strong>unique</strong> values and two nodes value,&nbsp;<strong>n1</strong> and <strong>n2</strong>. The task is to find the<strong>&nbsp;lowest common ancestor</strong> of the given two nodes. We may assume that either both n1 and n2 are present in the tree or none of them are&nbsp;present. </span></span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>n1 = 2 , n2 = 3  
+&nbsp;      1 
+&nbsp;     / \ 
+&nbsp;    2   3
+<strong>Output: </strong><span style="font-family:arial,helvetica,sans-serif">1
+</span><strong>Explanation:
+</strong></span><span style="font-size:18px">LCA of 2 and 3 is 1.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>n1 = 3 , n2 = 4
+           5    
+      &nbsp;   /    
+      &nbsp;  2  
+      &nbsp; / \  
+      &nbsp;3   4
+<strong>Output: </strong><span style="font-family:arial,helvetica,sans-serif">2
+</span><strong>Explanation:
+</strong>LCA of 3 and 4 is 2.<strong> </strong></span></pre>
+
+<p><span style="font-size:18px"><span style="font-family:arial,helvetica,sans-serif"><strong>Your Task:</strong><br>
+You don't have to read, input, or print anything. Your task is to complete the function <strong>lca()&nbsp;</strong>that takes nodes, <strong>n1, and n2</strong> as parameters and returns the&nbsp;<strong>LCA </strong>node as output. Otherwise, return a node with a value of&nbsp;<strong>-1</strong> if both <strong>n1 </strong>and <strong>n2 </strong>are not present in the tree.</span></span></p>
+
+<p><span style="font-size:18px"><span style="font-family:arial,helvetica,sans-serif"><strong>Expected Time Complexity:</strong>O(N).<br>
+<strong>Expected Auxiliary Space:</strong>O(Height of Tree).</span></span></p>
+
+<p><span style="font-size:18px"><span style="font-family:arial,helvetica,sans-serif"><strong>Constraints:</strong><br>
+1 ≤ Number of nodes ≤ 10<sup>5</sup><br>
+1 ≤ Data of a node ≤ 10<sup>5</sup></span></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Lowest Common Ancestor in a Binary Tree - GFG/lowest-common-ancestor-in-a-binary-tree.java b/leetcode/leetcode/Lowest Common Ancestor in a Binary Tree - GFG/lowest-common-ancestor-in-a-binary-tree.java
new file mode 100644
index 0000000..449765e
--- /dev/null
+++ b/leetcode/leetcode/Lowest Common Ancestor in a Binary Tree - GFG/lowest-common-ancestor-in-a-binary-tree.java	
@@ -0,0 +1,135 @@
+// { Driver Code Starts
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+class GfG {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    static void printInorder(Node root)
+    {
+        if(root == null)
+            return;
+            
+        printInorder(root.left);
+        System.out.print(root.data+" ");
+        
+        printInorder(root.right);
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t-- > 0){
+	            String input[] = br.readLine().trim().split(" ");
+                int a = Integer.parseInt(input[0]);
+                int b = Integer.parseInt(input[1]);
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+                Solution g = new Solution();
+                Node k = g.lca(root,a,b);
+    			System.out.println(k.data);
+    	        
+	        }
+	}
+}
+// } Driver Code Ends
+
+
+/* A Binary Tree node
+class Node
+{
+    int data;
+    Node left, right;
+
+    Node(int item)
+    {
+        data = item;
+        left = right = null;
+    }
+}*/
+
+class Solution
+{
+    //Function to return the lowest common ancestor in a Binary Tree.
+	Node lca(Node root, int n1,int n2)
+	{
+		if(root == null) return null;
+		if(root.data == n1 || root.data == n2) return root;
+		Node left = lca(root.left,n1,n2);
+		Node right = lca(root.right,n1,n2);
+		if(left==null) return right;
+		if(right == null) return left;
+		return root;
+	}
+}
+
diff --git a/leetcode/leetcode/Max Sum Subarray of size K - GFG/README.md b/leetcode/leetcode/Max Sum Subarray of size K - GFG/README.md
new file mode 100644
index 0000000..a5f7ebc
--- /dev/null
+++ b/leetcode/leetcode/Max Sum Subarray of size K - GFG/README.md	
@@ -0,0 +1,51 @@
+# Max Sum Subarray of size K
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array of integers Arr of size <strong>N</strong> and a number <strong>K</strong>. Return&nbsp;the maximum sum of a subarray of size K.</span></p>
+
+<p>&nbsp;</p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:</span></strong>
+<span style="font-size:18px">N = 4, K = 2
+Arr = [100, 200, 300, 400]</span>
+<strong><span style="font-size:18px">Output:</span></strong>
+<span style="font-size:18px">700</span>
+<strong><span style="font-size:18px">Explanation:</span></strong>
+<span style="font-size:18px">Arr<sub>3 </sub> + Arr<sub>4</sub> =700,</span>
+<span style="font-size:18px">which is maximum.</span></pre>
+
+<p>&nbsp;</p>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:</span></strong>
+<span style="font-size:18px">N = 4, K = 4</span>
+<span style="font-size:18px">Arr = [100, 200, 300, 400]</span>
+<strong><span style="font-size:18px">Output:</span></strong>
+<span style="font-size:18px">1000</span>
+<strong><span style="font-size:18px">Explanation:</span></strong>
+<span style="font-size:18px">Arr<sub>1</sub> + Arr<sub>2</sub> + Arr<sub>3 </sub> 
++ Arr<sub>4</sub> =1000,</span>
+<span style="font-size:18px">which is maximum.</span></pre>
+
+<p>&nbsp;</p>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong></p>
+
+<p><span style="font-size:18px">You don't need to read input or print anything. Your task is to complete the function maximumSumSubarray() which takes the integer k, vector Arr with size N,&nbsp;containing the elements of the array and returns the&nbsp;maximum sum of a subarray of size K.</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span><br>
+&nbsp;</p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1&lt;=N&lt;=10<sup>5</sup><br>
+1&lt;=K&lt;=N</span><br>
+&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Max Sum Subarray of size K - GFG/max-sum-subarray-of-size-k.java b/leetcode/leetcode/Max Sum Subarray of size K - GFG/max-sum-subarray-of-size-k.java
new file mode 100644
index 0000000..7e98293
--- /dev/null
+++ b/leetcode/leetcode/Max Sum Subarray of size K - GFG/max-sum-subarray-of-size-k.java	
@@ -0,0 +1,53 @@
+// { Driver Code Starts
+//Initial Template for Java
+import java.io.*;
+import java.util.*;
+
+class GFG
+{
+    public static void main(String args[])throws IOException
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-- > 0)
+        {
+            
+            int N=sc.nextInt();
+            int K=sc.nextInt();
+            ArrayList<Integer> Arr = new ArrayList<Integer>(N); 
+  
+            // Appending new elements at 
+            // the end of the list 
+            for (int i = 0; i < N; i++) {
+                int x = sc.nextInt();
+                Arr.add(x); 
+            }
+
+            Solution ob = new Solution();
+            System.out.println(ob.maximumSumSubarray(K,Arr,N));
+        }
+    }
+}
+// } Driver Code Ends
+
+
+//User function Template for Java
+class Solution{
+    static int maximumSumSubarray(int k, ArrayList<Integer> Arr,int N){
+        int i = 0;
+        int sum = 0;
+        while(i<k){
+            sum+=Arr.get(i);
+            i++;
+        }
+        i = 0;
+        int max = sum;
+        while(i+k<N){
+            sum+=Arr.get(i+k);
+            sum-=Arr.get(i);
+            max = Math.max(max,sum);
+            i++;
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Maximum no of 1's row - GFG/README.md b/leetcode/leetcode/Maximum no of 1's row - GFG/README.md
new file mode 100644
index 0000000..22bb56c
--- /dev/null
+++ b/leetcode/leetcode/Maximum no of 1's row - GFG/README.md	
@@ -0,0 +1,43 @@
+# Maximum no of 1's row
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a boolean 2D array, where each row is sorted. Find the row with the maximum number of 1s.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 3, M = 4
+Mat[] = {{0 1 1 1},
+         {0 0 1 1},
+&nbsp;        {0 0 1 1}}
+<strong>Output:</strong> 0
+<strong>Explanation</strong>: Row 0 has 3 ones whereas
+rows 1 and 2 have just 2 ones.
+</span>
+</pre>
+
+<p><span style="font-size:18px">​<strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong>: 
+N = 2, M = 2
+Mat[] = {{0 1},
+&nbsp;        {1 1}}
+<strong>Output:</strong> 1
+<strong>Explanation</strong>: Row 1 has 2 ones whereas
+row 0 has just a single one. </span>
+</pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Your task is to complete the function&nbsp;<strong>maxOnes ()&nbsp;</strong>which takes a 2D array Mat[][] and its dimensions N&nbsp;and M&nbsp;as inputs and returns the row index with the maximum number of 1s (0-based index). If there are multiple rows with the maximum number of ones, then return the row with the smaller index.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(NLogM).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1).</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N, M &lt;= 40<br>
+0 &lt;= M[ ][ ] &lt;= 1</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Maximum no of 1's row - GFG/maximum-no-of-1s-row.java b/leetcode/leetcode/Maximum no of 1's row - GFG/maximum-no-of-1s-row.java
new file mode 100644
index 0000000..cf36338
--- /dev/null
+++ b/leetcode/leetcode/Maximum no of 1's row - GFG/maximum-no-of-1s-row.java	
@@ -0,0 +1,59 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+import java.io.*;
+import java.util.*;
+class GfG
+{
+    public static void main (String[] args)
+    {
+        
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            int m = sc.nextInt();
+            int [][]arr = new int[n][m];
+            
+            for (int i = 0; i < n; ++i)
+                for (int j = 0; j < m; ++j)
+                    arr[i][j] = sc.nextInt ();
+
+    		System.out.println (new Sol().maxOnes (arr, n, m));
+        }
+        
+    }
+}// } Driver Code Ends
+
+
+//User function Template for Java
+
+class Sol
+{
+    public static int maxOnes (int Mat[][], int N, int M)
+    {
+        int max = 0;
+        int maxRow = 0;
+        for(int i = 0;i<N;i++){
+            int low = 0;
+            int high = M -1;
+            int ans = -1;
+            while(low<=high){
+                int mid = (low+high)/2;
+                if(Mat[i][mid] == 1){
+                    ans = mid;
+                    high = mid - 1;
+                }else{
+                    low = mid+1;
+                }
+            }
+            if(ans!=-1 && max<M-ans){
+                max = M - ans;
+                maxRow = i;
+            }
+        }
+        return maxRow;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Minimum Operations - GFG/README.md b/leetcode/leetcode/Minimum Operations - GFG/README.md
new file mode 100644
index 0000000..3eaa5d7
--- /dev/null
+++ b/leetcode/leetcode/Minimum Operations - GFG/README.md	
@@ -0,0 +1,43 @@
+# Minimum Operations
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a number N.&nbsp;Find the minimum number of operations required to reach <strong>N</strong>&nbsp;starting from <strong>0</strong>. You have 2 operations available:</span></p>
+
+<ul>
+	<li><span style="font-size:18px">Double the number </span></li>
+	<li><span style="font-size:18px">Add one to the number</span></li>
+</ul>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 8
+<strong>Output:</strong> 4
+<strong>Explanation</strong>: 0 + 1 = 1, 1 + 1 = 2,
+2 * 2 = 4, 4 * 2 = 8
+</span></pre>
+
+<p><br>
+<span style="font-size:18px">​<strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong>: 
+N = 7
+<strong>Output:</strong> 5
+<strong>Explanation</strong>: 0 + 1 = 1, 1 + 1 = 2,
+1 + 2 = 3, 3 * 2 = 6, 6 + 1 = 7
+</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Your task is to complete the function&nbsp;<strong>minOperation()&nbsp;</strong>which accepts an integer N and return number of minimum operations required to reach N from 0.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(LogN)<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N&nbsp;&lt;= 10<sup>6</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Minimum Operations - GFG/minimum-operations.java b/leetcode/leetcode/Minimum Operations - GFG/minimum-operations.java
new file mode 100644
index 0000000..b50c835
--- /dev/null
+++ b/leetcode/leetcode/Minimum Operations - GFG/minimum-operations.java	
@@ -0,0 +1,40 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+import java.io.*;
+import java.util.*;
+class GfG
+{
+    public static void main(String args[])
+        {
+            Scanner sc = new Scanner(System.in);
+            int t = sc.nextInt();
+            while(t-->0)
+                {
+                    int n = sc.nextInt();
+                    Solution ob = new Solution();
+                    System.out.println(ob.minOperation(n));
+                }
+        }
+}    // } Driver Code Ends
+
+
+//User function Template for Java
+
+
+class Solution
+{
+    public int minOperation(int n)
+    {
+        int res = 0;
+        while(n!=0){
+            if(n%2==0){
+                n = n/2;
+            }else{
+                n--;
+            }
+            res++;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Missing number in array - GFG/README.md b/leetcode/leetcode/Missing number in array - GFG/README.md
new file mode 100644
index 0000000..a2a6de2
--- /dev/null
+++ b/leetcode/leetcode/Missing number in array - GFG/README.md	
@@ -0,0 +1,34 @@
+# Missing number in array
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array of size&nbsp;<strong>N-1</strong>&nbsp;such that it only contains distinct integers in the range of&nbsp;<strong>1&nbsp;to N</strong>. Find the missing element.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 5
+A[] = {1,2,3,5}
+<strong>Output: </strong>4</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 10
+A[] = {6,1,2,8,3,4,7,10,5}
+<strong>Output: </strong>9</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task :</strong><br>
+You don't need to read input or print anything.&nbsp;Complete the function&nbsp;<strong>MissingNumber()&nbsp;</strong>that takes array and N as input &nbsp;parameters and returns the value of the missing number.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>6</sup><br>
+1 ≤ A[i] ≤ 10<sup>6</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Missing number in array - GFG/missing-number-in-array.java b/leetcode/leetcode/Missing number in array - GFG/missing-number-in-array.java
new file mode 100644
index 0000000..8819c87
--- /dev/null
+++ b/leetcode/leetcode/Missing number in array - GFG/missing-number-in-array.java	
@@ -0,0 +1,35 @@
+// { Driver Code Starts
+// Initial Template for Java
+
+import java.io.*;
+import java.util.*;
+
+class GFG {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br =
+            new BufferedReader(new InputStreamReader(System.in));
+
+        int t = Integer.parseInt(br.readLine().trim());
+        while (t-- > 0) {
+            int n = Integer.parseInt(br.readLine().trim());
+            String[] str = br.readLine().trim().split(" ");
+            int[] array = new int[n - 1];
+            for (int i = 0; i < n - 1; i++) {
+                array[i] = Integer.parseInt(str[i]);
+            }
+            Solution sln = new Solution();
+            System.out.println(sln.MissingNumber(array, n));
+        }
+    }
+}// } Driver Code Ends
+
+
+// User function Template for Java
+
+class Solution {
+    int MissingNumber(int array[], int n) {
+        long sum = n*(n+1)/2;
+        for(int num: array) sum-=num;
+        return (int)sum;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Move all zeroes to end of array - GFG/README.md b/leetcode/leetcode/Move all zeroes to end of array - GFG/README.md
new file mode 100644
index 0000000..9982a4e
--- /dev/null
+++ b/leetcode/leetcode/Move all zeroes to end of array - GFG/README.md	
@@ -0,0 +1,41 @@
+# Move all zeroes to end of array
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array <strong>arr[]</strong> of <strong>N</strong> positive integers. Push all the zero’s of the given array to the right&nbsp;end of the array&nbsp;while maitaining the order of non-zero elements.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 5
+Arr[] = {3, 5, 0, 0, 4}
+<strong>Output:</strong> 3 5 4 0 0
+<strong>Explanation:</strong> The non-zero elements
+preserve their order while the 0
+elements are moved to the right.
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 4
+Arr[] = {0, 0, 0, 4}
+<strong>Output:</strong> 4 0 0 0
+<strong>Explanation:</strong>&nbsp;4 is the only non-zero
+element and it gets moved to the left.
+</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Complete the function <strong>pushZerosToEnd()</strong>&nbsp;which takes the&nbsp;array <strong>arr[] </strong>and its size&nbsp;<strong>n</strong>&nbsp;as input parameters&nbsp;and modifies arr[] in-place such that all the zeroes are moved to the&nbsp;right.&nbsp;&nbsp;</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N&nbsp;≤ 10<sup>5</sup><br>
+0 ≤ arr<sub>i</sub> ≤ 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Move all zeroes to end of array - GFG/move-all-zeroes-to-end-of-array.java b/leetcode/leetcode/Move all zeroes to end of array - GFG/move-all-zeroes-to-end-of-array.java
new file mode 100644
index 0000000..57b9238
--- /dev/null
+++ b/leetcode/leetcode/Move all zeroes to end of array - GFG/move-all-zeroes-to-end-of-array.java	
@@ -0,0 +1,49 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class Main {
+
+    public static void main(String[] args) throws Exception {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int tc = Integer.parseInt(br.readLine());
+        while (tc-- > 0) {
+            int n = Integer.parseInt(br.readLine());
+            int[] arr = new int[n];
+            String[] inputLine = br.readLine().split(" ");
+            for (int i = 0; i < n; i++) {
+                arr[i] = Integer.parseInt(inputLine[i]);
+            }
+
+            new Solution().pushZerosToEnd(arr, n);
+            for (int i = 0; i < n; i++) {
+                System.out.print(arr[i] + " ");
+            }
+            System.out.println();
+        }
+    }
+}// } Driver Code Ends
+
+
+//User function Template for Java
+
+class Solution {
+    void swap(int[] arr, int i, int j){
+        int temp =arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    } 
+    void pushZerosToEnd(int[] arr, int n) {
+        int zerosTillNow = 0;
+        for(int i = 0;i<n;i++){
+            if(arr[i] == 0) zerosTillNow++;
+            else{
+                swap(arr,i,i-zerosTillNow);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Peak element - GFG/README.md b/leetcode/leetcode/Peak element - GFG/README.md
new file mode 100644
index 0000000..d4c7941
--- /dev/null
+++ b/leetcode/leetcode/Peak element - GFG/README.md	
@@ -0,0 +1,48 @@
+# Peak element
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">An element is called a peak element if its value&nbsp;is not smaller than the value of&nbsp;its adjacent elements(if they exists).<br>
+Given an array <strong>arr[]</strong> of size&nbsp;<strong>N</strong>,&nbsp;find the index of any one of its&nbsp;peak elements.<br>
+<strong>Note:&nbsp;</strong>The generated output will always be&nbsp;1 if the index that you&nbsp;return is correct. Otherwise output will be 0.&nbsp;</span></p>
+
+<p><br>
+<strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:
+</span></strong><span style="font-size:18px">N = 3
+arr[] = {1,2,3}
+Output: 2
+Explanation: index 2 is 3.
+It is the peak element as it is 
+greater than its neighbour 2.</span>
+</pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:
+</span></strong><span style="font-size:18px">N = 2
+arr[] = {3,4}
+<strong>Output: </strong>1<strong>
+Explanation: </strong>4 (at index 1) is the 
+peak element as it is greater than 
+its only neighbour element 3.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong><br>
+<span style="font-size:18px">You don't have to read&nbsp;input or print anything. Complete the function <strong>peakElement</strong>() which takes the array arr[] and its size N as input parameters and return the&nbsp;index of any one of its peak elements.<br>
+<br>
+Can you solve the problem in expected time complexity?</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(log N)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>5</sup><br>
+1 ≤ A[] ≤ 10<sup>6</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Peak element - GFG/peak-element.java b/leetcode/leetcode/Peak element - GFG/peak-element.java
new file mode 100644
index 0000000..8ef561d
--- /dev/null
+++ b/leetcode/leetcode/Peak element - GFG/peak-element.java	
@@ -0,0 +1,63 @@
+// { Driver Code Starts
+import java.util.*;
+class PeakElement{
+	public static void main(String[] args){
+		Scanner sc=new Scanner(System.in);
+		int t=sc.nextInt();
+		while(t-->0){
+			int n=sc.nextInt();
+			int[] a=new int[n];
+		    int[] tmp=new int[n];
+			for(int i=0;i<n;i++){
+				a[i]=sc.nextInt();
+				tmp[i] = a[i];
+			}
+		    
+		    int f=0;
+			int A=(new Solution()).peakElement(tmp,n);
+			
+			if(A<0 && A>=n)
+			    System.out.println(0);
+			else
+			{
+    			if(n==1 && A==0)
+    			    f=1;
+    			else if(A==0 && a[0]>=a[1])
+    			    f=1;
+    			else if(A==n-1 && a[n-1]>=a[n-2])
+    			    f=1;
+    			else if(A >= 0 && A < n && a[A] >=a[A+1] && a[A]>= a[A-1])
+    			    f=1;
+    			else
+    			    f=0;
+			    System.out.println(f);
+			}
+		}
+	}
+}// } Driver Code Ends
+
+
+/*Complete the function below*/
+
+class Solution
+{
+	// Function to find the peak element
+	// arr[]: input array
+	// n: size of array a[]
+	public int peakElement(int[] arr,int n)
+    {
+        if(n == 1) return 0;
+      int low = 0;
+      int high = n - 1;
+      if(arr[0] > arr[1]) return 0;
+      if(arr[high]>arr[high-1]) return high;
+      while(low<=high){
+          int mid = (low+high)/2;
+          if(arr[mid]<arr[mid+1]) low = mid+1;
+          else if(arr[mid]<arr[mid-1]) high = mid-1;
+          else return mid;
+          
+      }
+      return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/README.md b/leetcode/leetcode/README.md
new file mode 100644
index 0000000..32c0319
--- /dev/null
+++ b/leetcode/leetcode/README.md
@@ -0,0 +1,836 @@
+# LeetCode
+Collection of LeetCode questions to ace the coding interview! - Created using [LeetHub](https://github.com/QasimWani/LeetHub).
+
+# My Leetcode profile:- <a href="https://leetcode.com/devn007">Here</a>
+
+<!---LeetCode Topics Start-->
+# LeetCode Topics
+## Array
+|  |
+| ------- |
+| [0001-two-sum](https://github.com/Devn913/LeetCode/tree/master/0001-two-sum) |
+| [0011-container-with-most-water](https://github.com/Devn913/LeetCode/tree/master/0011-container-with-most-water) |
+| [0015-3sum](https://github.com/Devn913/LeetCode/tree/master/0015-3sum) |
+| [0016-3sum-closest](https://github.com/Devn913/LeetCode/tree/master/0016-3sum-closest) |
+| [0033-search-in-rotated-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0033-search-in-rotated-sorted-array) |
+| [0034-find-first-and-last-position-of-element-in-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0034-find-first-and-last-position-of-element-in-sorted-array) |
+| [0039-combination-sum](https://github.com/Devn913/LeetCode/tree/master/0039-combination-sum) |
+| [0040-combination-sum-ii](https://github.com/Devn913/LeetCode/tree/master/0040-combination-sum-ii) |
+| [0045-jump-game-ii](https://github.com/Devn913/LeetCode/tree/master/0045-jump-game-ii) |
+| [0046-permutations](https://github.com/Devn913/LeetCode/tree/master/0046-permutations) |
+| [0048-rotate-image](https://github.com/Devn913/LeetCode/tree/master/0048-rotate-image) |
+| [0049-group-anagrams](https://github.com/Devn913/LeetCode/tree/master/0049-group-anagrams) |
+| [0053-maximum-subarray](https://github.com/Devn913/LeetCode/tree/master/0053-maximum-subarray) |
+| [0055-jump-game](https://github.com/Devn913/LeetCode/tree/master/0055-jump-game) |
+| [0056-merge-intervals](https://github.com/Devn913/LeetCode/tree/master/0056-merge-intervals) |
+| [0063-unique-paths-ii](https://github.com/Devn913/LeetCode/tree/master/0063-unique-paths-ii) |
+| [0064-minimum-path-sum](https://github.com/Devn913/LeetCode/tree/master/0064-minimum-path-sum) |
+| [0073-set-matrix-zeroes](https://github.com/Devn913/LeetCode/tree/master/0073-set-matrix-zeroes) |
+| [0075-sort-colors](https://github.com/Devn913/LeetCode/tree/master/0075-sort-colors) |
+| [0078-subsets](https://github.com/Devn913/LeetCode/tree/master/0078-subsets) |
+| [0088-merge-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0088-merge-sorted-array) |
+| [0106-construct-binary-tree-from-inorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0106-construct-binary-tree-from-inorder-and-postorder-traversal) |
+| [0108-convert-sorted-array-to-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0108-convert-sorted-array-to-binary-search-tree) |
+| [0118-pascals-triangle](https://github.com/Devn913/LeetCode/tree/master/0118-pascals-triangle) |
+| [0120-triangle](https://github.com/Devn913/LeetCode/tree/master/0120-triangle) |
+| [0121-best-time-to-buy-and-sell-stock](https://github.com/Devn913/LeetCode/tree/master/0121-best-time-to-buy-and-sell-stock) |
+| [0128-longest-consecutive-sequence](https://github.com/Devn913/LeetCode/tree/master/0128-longest-consecutive-sequence) |
+| [0149-max-points-on-a-line](https://github.com/Devn913/LeetCode/tree/master/0149-max-points-on-a-line) |
+| [0152-maximum-product-subarray](https://github.com/Devn913/LeetCode/tree/master/0152-maximum-product-subarray) |
+| [0153-find-minimum-in-rotated-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0153-find-minimum-in-rotated-sorted-array) |
+| [0162-find-peak-element](https://github.com/Devn913/LeetCode/tree/master/0162-find-peak-element) |
+| [0167-two-sum-ii-input-array-is-sorted](https://github.com/Devn913/LeetCode/tree/master/0167-two-sum-ii-input-array-is-sorted) |
+| [0169-majority-element](https://github.com/Devn913/LeetCode/tree/master/0169-majority-element) |
+| [0198-house-robber](https://github.com/Devn913/LeetCode/tree/master/0198-house-robber) |
+| [0200-number-of-islands](https://github.com/Devn913/LeetCode/tree/master/0200-number-of-islands) |
+| [0209-minimum-size-subarray-sum](https://github.com/Devn913/LeetCode/tree/master/0209-minimum-size-subarray-sum) |
+| [0213-house-robber-ii](https://github.com/Devn913/LeetCode/tree/master/0213-house-robber-ii) |
+| [0215-kth-largest-element-in-an-array](https://github.com/Devn913/LeetCode/tree/master/0215-kth-largest-element-in-an-array) |
+| [0217-contains-duplicate](https://github.com/Devn913/LeetCode/tree/master/0217-contains-duplicate) |
+| [0229-majority-element-ii](https://github.com/Devn913/LeetCode/tree/master/0229-majority-element-ii) |
+| [0238-product-of-array-except-self](https://github.com/Devn913/LeetCode/tree/master/0238-product-of-array-except-self) |
+| [0239-sliding-window-maximum](https://github.com/Devn913/LeetCode/tree/master/0239-sliding-window-maximum) |
+| [0268-missing-number](https://github.com/Devn913/LeetCode/tree/master/0268-missing-number) |
+| [0287-find-the-duplicate-number](https://github.com/Devn913/LeetCode/tree/master/0287-find-the-duplicate-number) |
+| [0300-longest-increasing-subsequence](https://github.com/Devn913/LeetCode/tree/master/0300-longest-increasing-subsequence) |
+| [0303-range-sum-query-immutable](https://github.com/Devn913/LeetCode/tree/master/0303-range-sum-query-immutable) |
+| [0322-coin-change](https://github.com/Devn913/LeetCode/tree/master/0322-coin-change) |
+| [0347-top-k-frequent-elements](https://github.com/Devn913/LeetCode/tree/master/0347-top-k-frequent-elements) |
+| [0416-partition-equal-subset-sum](https://github.com/Devn913/LeetCode/tree/master/0416-partition-equal-subset-sum) |
+| [0435-non-overlapping-intervals](https://github.com/Devn913/LeetCode/tree/master/0435-non-overlapping-intervals) |
+| [0480-sliding-window-median](https://github.com/Devn913/LeetCode/tree/master/0480-sliding-window-median) |
+| [0485-max-consecutive-ones](https://github.com/Devn913/LeetCode/tree/master/0485-max-consecutive-ones) |
+| [0503-next-greater-element-ii](https://github.com/Devn913/LeetCode/tree/master/0503-next-greater-element-ii) |
+| [0525-contiguous-array](https://github.com/Devn913/LeetCode/tree/master/0525-contiguous-array) |
+| [0540-single-element-in-a-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0540-single-element-in-a-sorted-array) |
+| [0560-subarray-sum-equals-k](https://github.com/Devn913/LeetCode/tree/master/0560-subarray-sum-equals-k) |
+| [0713-subarray-product-less-than-k](https://github.com/Devn913/LeetCode/tree/master/0713-subarray-product-less-than-k) |
+| [0735-asteroid-collision](https://github.com/Devn913/LeetCode/tree/master/0735-asteroid-collision) |
+| [0739-daily-temperatures](https://github.com/Devn913/LeetCode/tree/master/0739-daily-temperatures) |
+| [0907-koko-eating-bananas](https://github.com/Devn913/LeetCode/tree/master/0907-koko-eating-bananas) |
+| [0925-construct-binary-tree-from-preorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0925-construct-binary-tree-from-preorder-and-postorder-traversal) |
+| [0954-maximum-sum-circular-subarray](https://github.com/Devn913/LeetCode/tree/master/0954-maximum-sum-circular-subarray) |
+| [0966-binary-subarrays-with-sum](https://github.com/Devn913/LeetCode/tree/master/0966-binary-subarrays-with-sum) |
+| [0967-minimum-falling-path-sum](https://github.com/Devn913/LeetCode/tree/master/0967-minimum-falling-path-sum) |
+| [1014-k-closest-points-to-origin](https://github.com/Devn913/LeetCode/tree/master/1014-k-closest-points-to-origin) |
+| [1034-subarrays-with-k-different-integers](https://github.com/Devn913/LeetCode/tree/master/1034-subarrays-with-k-different-integers) |
+| [1050-construct-binary-search-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1050-construct-binary-search-tree-from-preorder-traversal) |
+| [1056-capacity-to-ship-packages-within-d-days](https://github.com/Devn913/LeetCode/tree/master/1056-capacity-to-ship-packages-within-d-days) |
+| [1224-minimum-falling-path-sum-ii](https://github.com/Devn913/LeetCode/tree/master/1224-minimum-falling-path-sum-ii) |
+| [1335-maximum-candies-allocated-to-k-children](https://github.com/Devn913/LeetCode/tree/master/1335-maximum-candies-allocated-to-k-children) |
+| [1421-find-numbers-with-even-number-of-digits](https://github.com/Devn913/LeetCode/tree/master/1421-find-numbers-with-even-number-of-digits) |
+| [1631-number-of-sub-arrays-with-odd-sum](https://github.com/Devn913/LeetCode/tree/master/1631-number-of-sub-arrays-with-odd-sum) |
+| [1849-maximum-absolute-sum-of-any-subarray](https://github.com/Devn913/LeetCode/tree/master/1849-maximum-absolute-sum-of-any-subarray) |
+| [1983-maximum-population-year](https://github.com/Devn913/LeetCode/tree/master/1983-maximum-population-year) |
+| [2048-build-array-from-permutation](https://github.com/Devn913/LeetCode/tree/master/2048-build-array-from-permutation) |
+| [2107-find-unique-binary-string](https://github.com/Devn913/LeetCode/tree/master/2107-find-unique-binary-string) |
+| [2160-minimum-operations-to-make-a-uni-value-grid](https://github.com/Devn913/LeetCode/tree/master/2160-minimum-operations-to-make-a-uni-value-grid) |
+| [2220-find-all-possible-recipes-from-given-supplies](https://github.com/Devn913/LeetCode/tree/master/2220-find-all-possible-recipes-from-given-supplies) |
+| [2255-minimum-swaps-to-group-all-1s-together-ii](https://github.com/Devn913/LeetCode/tree/master/2255-minimum-swaps-to-group-all-1s-together-ii) |
+| [2265-partition-array-according-to-given-pivot](https://github.com/Devn913/LeetCode/tree/master/2265-partition-array-according-to-given-pivot) |
+| [2307-replace-non-coprime-numbers-in-array](https://github.com/Devn913/LeetCode/tree/master/2307-replace-non-coprime-numbers-in-array) |
+| [2308-divide-array-into-equal-pairs](https://github.com/Devn913/LeetCode/tree/master/2308-divide-array-into-equal-pairs) |
+| [2324-find-triangular-sum-of-an-array](https://github.com/Devn913/LeetCode/tree/master/2324-find-triangular-sum-of-an-array) |
+| [2394-count-subarrays-with-score-less-than-k](https://github.com/Devn913/LeetCode/tree/master/2394-count-subarrays-with-score-less-than-k) |
+| [2429-design-a-food-rating-system](https://github.com/Devn913/LeetCode/tree/master/2429-design-a-food-rating-system) |
+| [2448-count-number-of-bad-pairs](https://github.com/Devn913/LeetCode/tree/master/2448-count-number-of-bad-pairs) |
+| [2478-longest-nice-subarray](https://github.com/Devn913/LeetCode/tree/master/2478-longest-nice-subarray) |
+| [2551-apply-operations-to-an-array](https://github.com/Devn913/LeetCode/tree/master/2551-apply-operations-to-an-array) |
+| [2564-most-profitable-path-in-a-tree](https://github.com/Devn913/LeetCode/tree/master/2564-most-profitable-path-in-a-tree) |
+| [2588-maximum-number-of-points-from-grid-queries](https://github.com/Devn913/LeetCode/tree/master/2588-maximum-number-of-points-from-grid-queries) |
+| [2614-maximum-count-of-positive-integer-and-negative-integer](https://github.com/Devn913/LeetCode/tree/master/2614-maximum-count-of-positive-integer-and-negative-integer) |
+| [2665-minimum-time-to-repair-cars](https://github.com/Devn913/LeetCode/tree/master/2665-minimum-time-to-repair-cars) |
+| [2681-put-marbles-in-bags](https://github.com/Devn913/LeetCode/tree/master/2681-put-marbles-in-bags) |
+| [2690-house-robber-iv](https://github.com/Devn913/LeetCode/tree/master/2690-house-robber-iv) |
+| [2707-merge-two-2d-arrays-by-summing-values](https://github.com/Devn913/LeetCode/tree/master/2707-merge-two-2d-arrays-by-summing-values) |
+| [2888-minimum-index-of-a-valid-split](https://github.com/Devn913/LeetCode/tree/master/2888-minimum-index-of-a-valid-split) |
+| [3001-apply-operations-to-maximize-score](https://github.com/Devn913/LeetCode/tree/master/3001-apply-operations-to-maximize-score) |
+| [3213-count-subarrays-where-max-element-appears-at-least-k-times](https://github.com/Devn913/LeetCode/tree/master/3213-count-subarrays-where-max-element-appears-at-least-k-times) |
+| [3227-find-missing-and-repeated-values](https://github.com/Devn913/LeetCode/tree/master/3227-find-missing-and-repeated-values) |
+| [3242-count-elements-with-maximum-frequency](https://github.com/Devn913/LeetCode/tree/master/3242-count-elements-with-maximum-frequency) |
+| [3332-minimum-operations-to-exceed-threshold-value-ii](https://github.com/Devn913/LeetCode/tree/master/3332-minimum-operations-to-exceed-threshold-value-ii) |
+| [3348-minimum-cost-walk-in-weighted-graph](https://github.com/Devn913/LeetCode/tree/master/3348-minimum-cost-walk-in-weighted-graph) |
+| [3372-longest-strictly-increasing-or-strictly-decreasing-subarray](https://github.com/Devn913/LeetCode/tree/master/3372-longest-strictly-increasing-or-strictly-decreasing-subarray) |
+| [3398-make-a-square-with-the-same-color](https://github.com/Devn913/LeetCode/tree/master/3398-make-a-square-with-the-same-color) |
+| [3430-count-days-without-meetings](https://github.com/Devn913/LeetCode/tree/master/3430-count-days-without-meetings) |
+| [3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i](https://github.com/Devn913/LeetCode/tree/master/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i) |
+| [3483-alternating-groups-ii](https://github.com/Devn913/LeetCode/tree/master/3483-alternating-groups-ii) |
+| [3501-delete-nodes-from-linked-list-present-in-array](https://github.com/Devn913/LeetCode/tree/master/3501-delete-nodes-from-linked-list-present-in-array) |
+| [3541-report-spam-message](https://github.com/Devn913/LeetCode/tree/master/3541-report-spam-message) |
+| [3643-zero-array-transformation-ii](https://github.com/Devn913/LeetCode/tree/master/3643-zero-array-transformation-ii) |
+| [3657-check-if-grid-can-be-cut-into-sections](https://github.com/Devn913/LeetCode/tree/master/3657-check-if-grid-can-be-cut-into-sections) |
+## Binary Search
+|  |
+| ------- |
+| [0033-search-in-rotated-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0033-search-in-rotated-sorted-array) |
+| [0034-find-first-and-last-position-of-element-in-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0034-find-first-and-last-position-of-element-in-sorted-array) |
+| [0069-sqrtx](https://github.com/Devn913/LeetCode/tree/master/0069-sqrtx) |
+| [0153-find-minimum-in-rotated-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0153-find-minimum-in-rotated-sorted-array) |
+| [0162-find-peak-element](https://github.com/Devn913/LeetCode/tree/master/0162-find-peak-element) |
+| [0167-two-sum-ii-input-array-is-sorted](https://github.com/Devn913/LeetCode/tree/master/0167-two-sum-ii-input-array-is-sorted) |
+| [0209-minimum-size-subarray-sum](https://github.com/Devn913/LeetCode/tree/master/0209-minimum-size-subarray-sum) |
+| [0268-missing-number](https://github.com/Devn913/LeetCode/tree/master/0268-missing-number) |
+| [0287-find-the-duplicate-number](https://github.com/Devn913/LeetCode/tree/master/0287-find-the-duplicate-number) |
+| [0300-longest-increasing-subsequence](https://github.com/Devn913/LeetCode/tree/master/0300-longest-increasing-subsequence) |
+| [0374-guess-number-higher-or-lower](https://github.com/Devn913/LeetCode/tree/master/0374-guess-number-higher-or-lower) |
+| [0540-single-element-in-a-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0540-single-element-in-a-sorted-array) |
+| [0713-subarray-product-less-than-k](https://github.com/Devn913/LeetCode/tree/master/0713-subarray-product-less-than-k) |
+| [0907-koko-eating-bananas](https://github.com/Devn913/LeetCode/tree/master/0907-koko-eating-bananas) |
+| [1056-capacity-to-ship-packages-within-d-days](https://github.com/Devn913/LeetCode/tree/master/1056-capacity-to-ship-packages-within-d-days) |
+| [1335-maximum-candies-allocated-to-k-children](https://github.com/Devn913/LeetCode/tree/master/1335-maximum-candies-allocated-to-k-children) |
+| [2394-count-subarrays-with-score-less-than-k](https://github.com/Devn913/LeetCode/tree/master/2394-count-subarrays-with-score-less-than-k) |
+| [2614-maximum-count-of-positive-integer-and-negative-integer](https://github.com/Devn913/LeetCode/tree/master/2614-maximum-count-of-positive-integer-and-negative-integer) |
+| [2665-minimum-time-to-repair-cars](https://github.com/Devn913/LeetCode/tree/master/2665-minimum-time-to-repair-cars) |
+| [2690-house-robber-iv](https://github.com/Devn913/LeetCode/tree/master/2690-house-robber-iv) |
+| [3643-zero-array-transformation-ii](https://github.com/Devn913/LeetCode/tree/master/3643-zero-array-transformation-ii) |
+## Hash Table
+|  |
+| ------- |
+| [0001-two-sum](https://github.com/Devn913/LeetCode/tree/master/0001-two-sum) |
+| [0003-longest-substring-without-repeating-characters](https://github.com/Devn913/LeetCode/tree/master/0003-longest-substring-without-repeating-characters) |
+| [0013-roman-to-integer](https://github.com/Devn913/LeetCode/tree/master/0013-roman-to-integer) |
+| [0049-group-anagrams](https://github.com/Devn913/LeetCode/tree/master/0049-group-anagrams) |
+| [0073-set-matrix-zeroes](https://github.com/Devn913/LeetCode/tree/master/0073-set-matrix-zeroes) |
+| [0076-minimum-window-substring](https://github.com/Devn913/LeetCode/tree/master/0076-minimum-window-substring) |
+| [0106-construct-binary-tree-from-inorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0106-construct-binary-tree-from-inorder-and-postorder-traversal) |
+| [0128-longest-consecutive-sequence](https://github.com/Devn913/LeetCode/tree/master/0128-longest-consecutive-sequence) |
+| [0133-clone-graph](https://github.com/Devn913/LeetCode/tree/master/0133-clone-graph) |
+| [0138-copy-list-with-random-pointer](https://github.com/Devn913/LeetCode/tree/master/0138-copy-list-with-random-pointer) |
+| [0141-linked-list-cycle](https://github.com/Devn913/LeetCode/tree/master/0141-linked-list-cycle) |
+| [0142-linked-list-cycle-ii](https://github.com/Devn913/LeetCode/tree/master/0142-linked-list-cycle-ii) |
+| [0149-max-points-on-a-line](https://github.com/Devn913/LeetCode/tree/master/0149-max-points-on-a-line) |
+| [0160-intersection-of-two-linked-lists](https://github.com/Devn913/LeetCode/tree/master/0160-intersection-of-two-linked-lists) |
+| [0169-majority-element](https://github.com/Devn913/LeetCode/tree/master/0169-majority-element) |
+| [0187-repeated-dna-sequences](https://github.com/Devn913/LeetCode/tree/master/0187-repeated-dna-sequences) |
+| [0217-contains-duplicate](https://github.com/Devn913/LeetCode/tree/master/0217-contains-duplicate) |
+| [0229-majority-element-ii](https://github.com/Devn913/LeetCode/tree/master/0229-majority-element-ii) |
+| [0268-missing-number](https://github.com/Devn913/LeetCode/tree/master/0268-missing-number) |
+| [0347-top-k-frequent-elements](https://github.com/Devn913/LeetCode/tree/master/0347-top-k-frequent-elements) |
+| [0424-longest-repeating-character-replacement](https://github.com/Devn913/LeetCode/tree/master/0424-longest-repeating-character-replacement) |
+| [0451-sort-characters-by-frequency](https://github.com/Devn913/LeetCode/tree/master/0451-sort-characters-by-frequency) |
+| [0480-sliding-window-median](https://github.com/Devn913/LeetCode/tree/master/0480-sliding-window-median) |
+| [0525-contiguous-array](https://github.com/Devn913/LeetCode/tree/master/0525-contiguous-array) |
+| [0560-subarray-sum-equals-k](https://github.com/Devn913/LeetCode/tree/master/0560-subarray-sum-equals-k) |
+| [0768-partition-labels](https://github.com/Devn913/LeetCode/tree/master/0768-partition-labels) |
+| [0925-construct-binary-tree-from-preorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0925-construct-binary-tree-from-preorder-and-postorder-traversal) |
+| [0966-binary-subarrays-with-sum](https://github.com/Devn913/LeetCode/tree/master/0966-binary-subarrays-with-sum) |
+| [1029-vertical-order-traversal-of-a-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1029-vertical-order-traversal-of-a-binary-tree) |
+| [1034-subarrays-with-k-different-integers](https://github.com/Devn913/LeetCode/tree/master/1034-subarrays-with-k-different-integers) |
+| [1387-find-elements-in-a-contaminated-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1387-find-elements-in-a-contaminated-binary-tree) |
+| [1460-number-of-substrings-containing-all-three-characters](https://github.com/Devn913/LeetCode/tree/master/1460-number-of-substrings-containing-all-three-characters) |
+| [2107-find-unique-binary-string](https://github.com/Devn913/LeetCode/tree/master/2107-find-unique-binary-string) |
+| [2174-next-greater-numerically-balanced-number](https://github.com/Devn913/LeetCode/tree/master/2174-next-greater-numerically-balanced-number) |
+| [2220-find-all-possible-recipes-from-given-supplies](https://github.com/Devn913/LeetCode/tree/master/2220-find-all-possible-recipes-from-given-supplies) |
+| [2308-divide-array-into-equal-pairs](https://github.com/Devn913/LeetCode/tree/master/2308-divide-array-into-equal-pairs) |
+| [2427-first-letter-to-appear-twice](https://github.com/Devn913/LeetCode/tree/master/2427-first-letter-to-appear-twice) |
+| [2429-design-a-food-rating-system](https://github.com/Devn913/LeetCode/tree/master/2429-design-a-food-rating-system) |
+| [2448-count-number-of-bad-pairs](https://github.com/Devn913/LeetCode/tree/master/2448-count-number-of-bad-pairs) |
+| [2461-amount-of-time-for-binary-tree-to-be-infected](https://github.com/Devn913/LeetCode/tree/master/2461-amount-of-time-for-binary-tree-to-be-infected) |
+| [2707-merge-two-2d-arrays-by-summing-values](https://github.com/Devn913/LeetCode/tree/master/2707-merge-two-2d-arrays-by-summing-values) |
+| [2888-minimum-index-of-a-valid-split](https://github.com/Devn913/LeetCode/tree/master/2888-minimum-index-of-a-valid-split) |
+| [3227-find-missing-and-repeated-values](https://github.com/Devn913/LeetCode/tree/master/3227-find-missing-and-repeated-values) |
+| [3242-count-elements-with-maximum-frequency](https://github.com/Devn913/LeetCode/tree/master/3242-count-elements-with-maximum-frequency) |
+| [3501-delete-nodes-from-linked-list-present-in-array](https://github.com/Devn913/LeetCode/tree/master/3501-delete-nodes-from-linked-list-present-in-array) |
+| [3541-report-spam-message](https://github.com/Devn913/LeetCode/tree/master/3541-report-spam-message) |
+| [3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii](https://github.com/Devn913/LeetCode/tree/master/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii) |
+## Matrix
+|  |
+| ------- |
+| [0048-rotate-image](https://github.com/Devn913/LeetCode/tree/master/0048-rotate-image) |
+| [0063-unique-paths-ii](https://github.com/Devn913/LeetCode/tree/master/0063-unique-paths-ii) |
+| [0064-minimum-path-sum](https://github.com/Devn913/LeetCode/tree/master/0064-minimum-path-sum) |
+| [0073-set-matrix-zeroes](https://github.com/Devn913/LeetCode/tree/master/0073-set-matrix-zeroes) |
+| [0200-number-of-islands](https://github.com/Devn913/LeetCode/tree/master/0200-number-of-islands) |
+| [0967-minimum-falling-path-sum](https://github.com/Devn913/LeetCode/tree/master/0967-minimum-falling-path-sum) |
+| [1224-minimum-falling-path-sum-ii](https://github.com/Devn913/LeetCode/tree/master/1224-minimum-falling-path-sum-ii) |
+| [2160-minimum-operations-to-make-a-uni-value-grid](https://github.com/Devn913/LeetCode/tree/master/2160-minimum-operations-to-make-a-uni-value-grid) |
+| [2588-maximum-number-of-points-from-grid-queries](https://github.com/Devn913/LeetCode/tree/master/2588-maximum-number-of-points-from-grid-queries) |
+| [3227-find-missing-and-repeated-values](https://github.com/Devn913/LeetCode/tree/master/3227-find-missing-and-repeated-values) |
+| [3398-make-a-square-with-the-same-color](https://github.com/Devn913/LeetCode/tree/master/3398-make-a-square-with-the-same-color) |
+## Dynamic Programming
+|  |
+| ------- |
+| [0045-jump-game-ii](https://github.com/Devn913/LeetCode/tree/master/0045-jump-game-ii) |
+| [0053-maximum-subarray](https://github.com/Devn913/LeetCode/tree/master/0053-maximum-subarray) |
+| [0055-jump-game](https://github.com/Devn913/LeetCode/tree/master/0055-jump-game) |
+| [0062-unique-paths](https://github.com/Devn913/LeetCode/tree/master/0062-unique-paths) |
+| [0063-unique-paths-ii](https://github.com/Devn913/LeetCode/tree/master/0063-unique-paths-ii) |
+| [0064-minimum-path-sum](https://github.com/Devn913/LeetCode/tree/master/0064-minimum-path-sum) |
+| [0070-climbing-stairs](https://github.com/Devn913/LeetCode/tree/master/0070-climbing-stairs) |
+| [0118-pascals-triangle](https://github.com/Devn913/LeetCode/tree/master/0118-pascals-triangle) |
+| [0120-triangle](https://github.com/Devn913/LeetCode/tree/master/0120-triangle) |
+| [0121-best-time-to-buy-and-sell-stock](https://github.com/Devn913/LeetCode/tree/master/0121-best-time-to-buy-and-sell-stock) |
+| [0124-binary-tree-maximum-path-sum](https://github.com/Devn913/LeetCode/tree/master/0124-binary-tree-maximum-path-sum) |
+| [0131-palindrome-partitioning](https://github.com/Devn913/LeetCode/tree/master/0131-palindrome-partitioning) |
+| [0152-maximum-product-subarray](https://github.com/Devn913/LeetCode/tree/master/0152-maximum-product-subarray) |
+| [0198-house-robber](https://github.com/Devn913/LeetCode/tree/master/0198-house-robber) |
+| [0213-house-robber-ii](https://github.com/Devn913/LeetCode/tree/master/0213-house-robber-ii) |
+| [0300-longest-increasing-subsequence](https://github.com/Devn913/LeetCode/tree/master/0300-longest-increasing-subsequence) |
+| [0322-coin-change](https://github.com/Devn913/LeetCode/tree/master/0322-coin-change) |
+| [0337-house-robber-iii](https://github.com/Devn913/LeetCode/tree/master/0337-house-robber-iii) |
+| [0338-counting-bits](https://github.com/Devn913/LeetCode/tree/master/0338-counting-bits) |
+| [0416-partition-equal-subset-sum](https://github.com/Devn913/LeetCode/tree/master/0416-partition-equal-subset-sum) |
+| [0435-non-overlapping-intervals](https://github.com/Devn913/LeetCode/tree/master/0435-non-overlapping-intervals) |
+| [0516-longest-palindromic-subsequence](https://github.com/Devn913/LeetCode/tree/master/0516-longest-palindromic-subsequence) |
+| [0954-maximum-sum-circular-subarray](https://github.com/Devn913/LeetCode/tree/master/0954-maximum-sum-circular-subarray) |
+| [0967-minimum-falling-path-sum](https://github.com/Devn913/LeetCode/tree/master/0967-minimum-falling-path-sum) |
+| [1170-shortest-common-supersequence](https://github.com/Devn913/LeetCode/tree/master/1170-shortest-common-supersequence) |
+| [1224-minimum-falling-path-sum-ii](https://github.com/Devn913/LeetCode/tree/master/1224-minimum-falling-path-sum-ii) |
+| [1250-longest-common-subsequence](https://github.com/Devn913/LeetCode/tree/master/1250-longest-common-subsequence) |
+| [1631-number-of-sub-arrays-with-odd-sum](https://github.com/Devn913/LeetCode/tree/master/1631-number-of-sub-arrays-with-odd-sum) |
+| [1849-maximum-absolute-sum-of-any-subarray](https://github.com/Devn913/LeetCode/tree/master/1849-maximum-absolute-sum-of-any-subarray) |
+| [2090-number-of-ways-to-arrive-at-destination](https://github.com/Devn913/LeetCode/tree/master/2090-number-of-ways-to-arrive-at-destination) |
+## Divide and Conquer
+|  |
+| ------- |
+| [0023-merge-k-sorted-lists](https://github.com/Devn913/LeetCode/tree/master/0023-merge-k-sorted-lists) |
+| [0053-maximum-subarray](https://github.com/Devn913/LeetCode/tree/master/0053-maximum-subarray) |
+| [0106-construct-binary-tree-from-inorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0106-construct-binary-tree-from-inorder-and-postorder-traversal) |
+| [0108-convert-sorted-array-to-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0108-convert-sorted-array-to-binary-search-tree) |
+| [0169-majority-element](https://github.com/Devn913/LeetCode/tree/master/0169-majority-element) |
+| [0191-number-of-1-bits](https://github.com/Devn913/LeetCode/tree/master/0191-number-of-1-bits) |
+| [0215-kth-largest-element-in-an-array](https://github.com/Devn913/LeetCode/tree/master/0215-kth-largest-element-in-an-array) |
+| [0347-top-k-frequent-elements](https://github.com/Devn913/LeetCode/tree/master/0347-top-k-frequent-elements) |
+| [0925-construct-binary-tree-from-preorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0925-construct-binary-tree-from-preorder-and-postorder-traversal) |
+| [0954-maximum-sum-circular-subarray](https://github.com/Devn913/LeetCode/tree/master/0954-maximum-sum-circular-subarray) |
+| [1014-k-closest-points-to-origin](https://github.com/Devn913/LeetCode/tree/master/1014-k-closest-points-to-origin) |
+## Two Pointers
+|  |
+| ------- |
+| [0011-container-with-most-water](https://github.com/Devn913/LeetCode/tree/master/0011-container-with-most-water) |
+| [0015-3sum](https://github.com/Devn913/LeetCode/tree/master/0015-3sum) |
+| [0016-3sum-closest](https://github.com/Devn913/LeetCode/tree/master/0016-3sum-closest) |
+| [0061-rotate-list](https://github.com/Devn913/LeetCode/tree/master/0061-rotate-list) |
+| [0075-sort-colors](https://github.com/Devn913/LeetCode/tree/master/0075-sort-colors) |
+| [0082-remove-duplicates-from-sorted-list-ii](https://github.com/Devn913/LeetCode/tree/master/0082-remove-duplicates-from-sorted-list-ii) |
+| [0088-merge-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0088-merge-sorted-array) |
+| [0141-linked-list-cycle](https://github.com/Devn913/LeetCode/tree/master/0141-linked-list-cycle) |
+| [0142-linked-list-cycle-ii](https://github.com/Devn913/LeetCode/tree/master/0142-linked-list-cycle-ii) |
+| [0143-reorder-list](https://github.com/Devn913/LeetCode/tree/master/0143-reorder-list) |
+| [0160-intersection-of-two-linked-lists](https://github.com/Devn913/LeetCode/tree/master/0160-intersection-of-two-linked-lists) |
+| [0167-two-sum-ii-input-array-is-sorted](https://github.com/Devn913/LeetCode/tree/master/0167-two-sum-ii-input-array-is-sorted) |
+| [0234-palindrome-linked-list](https://github.com/Devn913/LeetCode/tree/master/0234-palindrome-linked-list) |
+| [0287-find-the-duplicate-number](https://github.com/Devn913/LeetCode/tree/master/0287-find-the-duplicate-number) |
+| [0768-partition-labels](https://github.com/Devn913/LeetCode/tree/master/0768-partition-labels) |
+| [0908-middle-of-the-linked-list](https://github.com/Devn913/LeetCode/tree/master/0908-middle-of-the-linked-list) |
+| [2216-delete-the-middle-node-of-a-linked-list](https://github.com/Devn913/LeetCode/tree/master/2216-delete-the-middle-node-of-a-linked-list) |
+| [2265-partition-array-according-to-given-pivot](https://github.com/Devn913/LeetCode/tree/master/2265-partition-array-according-to-given-pivot) |
+| [2551-apply-operations-to-an-array](https://github.com/Devn913/LeetCode/tree/master/2551-apply-operations-to-an-array) |
+| [2588-maximum-number-of-points-from-grid-queries](https://github.com/Devn913/LeetCode/tree/master/2588-maximum-number-of-points-from-grid-queries) |
+| [2707-merge-two-2d-arrays-by-summing-values](https://github.com/Devn913/LeetCode/tree/master/2707-merge-two-2d-arrays-by-summing-values) |
+## Sorting
+|  |
+| ------- |
+| [0015-3sum](https://github.com/Devn913/LeetCode/tree/master/0015-3sum) |
+| [0016-3sum-closest](https://github.com/Devn913/LeetCode/tree/master/0016-3sum-closest) |
+| [0049-group-anagrams](https://github.com/Devn913/LeetCode/tree/master/0049-group-anagrams) |
+| [0056-merge-intervals](https://github.com/Devn913/LeetCode/tree/master/0056-merge-intervals) |
+| [0075-sort-colors](https://github.com/Devn913/LeetCode/tree/master/0075-sort-colors) |
+| [0088-merge-sorted-array](https://github.com/Devn913/LeetCode/tree/master/0088-merge-sorted-array) |
+| [0169-majority-element](https://github.com/Devn913/LeetCode/tree/master/0169-majority-element) |
+| [0215-kth-largest-element-in-an-array](https://github.com/Devn913/LeetCode/tree/master/0215-kth-largest-element-in-an-array) |
+| [0217-contains-duplicate](https://github.com/Devn913/LeetCode/tree/master/0217-contains-duplicate) |
+| [0229-majority-element-ii](https://github.com/Devn913/LeetCode/tree/master/0229-majority-element-ii) |
+| [0268-missing-number](https://github.com/Devn913/LeetCode/tree/master/0268-missing-number) |
+| [0347-top-k-frequent-elements](https://github.com/Devn913/LeetCode/tree/master/0347-top-k-frequent-elements) |
+| [0435-non-overlapping-intervals](https://github.com/Devn913/LeetCode/tree/master/0435-non-overlapping-intervals) |
+| [0451-sort-characters-by-frequency](https://github.com/Devn913/LeetCode/tree/master/0451-sort-characters-by-frequency) |
+| [1014-k-closest-points-to-origin](https://github.com/Devn913/LeetCode/tree/master/1014-k-closest-points-to-origin) |
+| [1029-vertical-order-traversal-of-a-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1029-vertical-order-traversal-of-a-binary-tree) |
+| [2160-minimum-operations-to-make-a-uni-value-grid](https://github.com/Devn913/LeetCode/tree/master/2160-minimum-operations-to-make-a-uni-value-grid) |
+| [2588-maximum-number-of-points-from-grid-queries](https://github.com/Devn913/LeetCode/tree/master/2588-maximum-number-of-points-from-grid-queries) |
+| [2681-put-marbles-in-bags](https://github.com/Devn913/LeetCode/tree/master/2681-put-marbles-in-bags) |
+| [2887-sort-vowels-in-a-string](https://github.com/Devn913/LeetCode/tree/master/2887-sort-vowels-in-a-string) |
+| [2888-minimum-index-of-a-valid-split](https://github.com/Devn913/LeetCode/tree/master/2888-minimum-index-of-a-valid-split) |
+| [3001-apply-operations-to-maximize-score](https://github.com/Devn913/LeetCode/tree/master/3001-apply-operations-to-maximize-score) |
+| [3430-count-days-without-meetings](https://github.com/Devn913/LeetCode/tree/master/3430-count-days-without-meetings) |
+| [3657-check-if-grid-can-be-cut-into-sections](https://github.com/Devn913/LeetCode/tree/master/3657-check-if-grid-can-be-cut-into-sections) |
+## Tree
+|  |
+| ------- |
+| [0094-binary-tree-inorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0094-binary-tree-inorder-traversal) |
+| [0098-validate-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0098-validate-binary-search-tree) |
+| [0100-same-tree](https://github.com/Devn913/LeetCode/tree/master/0100-same-tree) |
+| [0102-binary-tree-level-order-traversal](https://github.com/Devn913/LeetCode/tree/master/0102-binary-tree-level-order-traversal) |
+| [0103-binary-tree-zigzag-level-order-traversal](https://github.com/Devn913/LeetCode/tree/master/0103-binary-tree-zigzag-level-order-traversal) |
+| [0104-maximum-depth-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0104-maximum-depth-of-binary-tree) |
+| [0106-construct-binary-tree-from-inorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0106-construct-binary-tree-from-inorder-and-postorder-traversal) |
+| [0108-convert-sorted-array-to-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0108-convert-sorted-array-to-binary-search-tree) |
+| [0110-balanced-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0110-balanced-binary-tree) |
+| [0112-path-sum](https://github.com/Devn913/LeetCode/tree/master/0112-path-sum) |
+| [0114-flatten-binary-tree-to-linked-list](https://github.com/Devn913/LeetCode/tree/master/0114-flatten-binary-tree-to-linked-list) |
+| [0116-populating-next-right-pointers-in-each-node](https://github.com/Devn913/LeetCode/tree/master/0116-populating-next-right-pointers-in-each-node) |
+| [0124-binary-tree-maximum-path-sum](https://github.com/Devn913/LeetCode/tree/master/0124-binary-tree-maximum-path-sum) |
+| [0144-binary-tree-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0144-binary-tree-preorder-traversal) |
+| [0145-binary-tree-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0145-binary-tree-postorder-traversal) |
+| [0199-binary-tree-right-side-view](https://github.com/Devn913/LeetCode/tree/master/0199-binary-tree-right-side-view) |
+| [0226-invert-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0226-invert-binary-tree) |
+| [0230-kth-smallest-element-in-a-bst](https://github.com/Devn913/LeetCode/tree/master/0230-kth-smallest-element-in-a-bst) |
+| [0235-lowest-common-ancestor-of-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0235-lowest-common-ancestor-of-a-binary-search-tree) |
+| [0236-lowest-common-ancestor-of-a-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0236-lowest-common-ancestor-of-a-binary-tree) |
+| [0257-binary-tree-paths](https://github.com/Devn913/LeetCode/tree/master/0257-binary-tree-paths) |
+| [0337-house-robber-iii](https://github.com/Devn913/LeetCode/tree/master/0337-house-robber-iii) |
+| [0404-sum-of-left-leaves](https://github.com/Devn913/LeetCode/tree/master/0404-sum-of-left-leaves) |
+| [0513-find-bottom-left-tree-value](https://github.com/Devn913/LeetCode/tree/master/0513-find-bottom-left-tree-value) |
+| [0543-diameter-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0543-diameter-of-binary-tree) |
+| [0637-average-of-levels-in-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0637-average-of-levels-in-binary-tree) |
+| [0783-search-in-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0783-search-in-a-binary-search-tree) |
+| [0784-insert-into-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0784-insert-into-a-binary-search-tree) |
+| [0925-construct-binary-tree-from-preorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0925-construct-binary-tree-from-preorder-and-postorder-traversal) |
+| [0988-flip-equivalent-binary-trees](https://github.com/Devn913/LeetCode/tree/master/0988-flip-equivalent-binary-trees) |
+| [1029-vertical-order-traversal-of-a-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1029-vertical-order-traversal-of-a-binary-tree) |
+| [1030-smallest-string-starting-from-leaf](https://github.com/Devn913/LeetCode/tree/master/1030-smallest-string-starting-from-leaf) |
+| [1050-construct-binary-search-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1050-construct-binary-search-tree-from-preorder-traversal) |
+| [1093-recover-a-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1093-recover-a-tree-from-preorder-traversal) |
+| [1387-find-elements-in-a-contaminated-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1387-find-elements-in-a-contaminated-binary-tree) |
+| [2461-amount-of-time-for-binary-tree-to-be-infected](https://github.com/Devn913/LeetCode/tree/master/2461-amount-of-time-for-binary-tree-to-be-infected) |
+| [2493-reverse-odd-levels-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/2493-reverse-odd-levels-of-binary-tree) |
+| [2564-most-profitable-path-in-a-tree](https://github.com/Devn913/LeetCode/tree/master/2564-most-profitable-path-in-a-tree) |
+## Depth-First Search
+|  |
+| ------- |
+| [0094-binary-tree-inorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0094-binary-tree-inorder-traversal) |
+| [0098-validate-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0098-validate-binary-search-tree) |
+| [0100-same-tree](https://github.com/Devn913/LeetCode/tree/master/0100-same-tree) |
+| [0104-maximum-depth-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0104-maximum-depth-of-binary-tree) |
+| [0110-balanced-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0110-balanced-binary-tree) |
+| [0112-path-sum](https://github.com/Devn913/LeetCode/tree/master/0112-path-sum) |
+| [0114-flatten-binary-tree-to-linked-list](https://github.com/Devn913/LeetCode/tree/master/0114-flatten-binary-tree-to-linked-list) |
+| [0116-populating-next-right-pointers-in-each-node](https://github.com/Devn913/LeetCode/tree/master/0116-populating-next-right-pointers-in-each-node) |
+| [0124-binary-tree-maximum-path-sum](https://github.com/Devn913/LeetCode/tree/master/0124-binary-tree-maximum-path-sum) |
+| [0133-clone-graph](https://github.com/Devn913/LeetCode/tree/master/0133-clone-graph) |
+| [0144-binary-tree-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0144-binary-tree-preorder-traversal) |
+| [0145-binary-tree-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0145-binary-tree-postorder-traversal) |
+| [0199-binary-tree-right-side-view](https://github.com/Devn913/LeetCode/tree/master/0199-binary-tree-right-side-view) |
+| [0200-number-of-islands](https://github.com/Devn913/LeetCode/tree/master/0200-number-of-islands) |
+| [0226-invert-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0226-invert-binary-tree) |
+| [0230-kth-smallest-element-in-a-bst](https://github.com/Devn913/LeetCode/tree/master/0230-kth-smallest-element-in-a-bst) |
+| [0235-lowest-common-ancestor-of-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0235-lowest-common-ancestor-of-a-binary-search-tree) |
+| [0236-lowest-common-ancestor-of-a-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0236-lowest-common-ancestor-of-a-binary-tree) |
+| [0257-binary-tree-paths](https://github.com/Devn913/LeetCode/tree/master/0257-binary-tree-paths) |
+| [0337-house-robber-iii](https://github.com/Devn913/LeetCode/tree/master/0337-house-robber-iii) |
+| [0404-sum-of-left-leaves](https://github.com/Devn913/LeetCode/tree/master/0404-sum-of-left-leaves) |
+| [0513-find-bottom-left-tree-value](https://github.com/Devn913/LeetCode/tree/master/0513-find-bottom-left-tree-value) |
+| [0543-diameter-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0543-diameter-of-binary-tree) |
+| [0637-average-of-levels-in-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0637-average-of-levels-in-binary-tree) |
+| [0820-find-eventual-safe-states](https://github.com/Devn913/LeetCode/tree/master/0820-find-eventual-safe-states) |
+| [0988-flip-equivalent-binary-trees](https://github.com/Devn913/LeetCode/tree/master/0988-flip-equivalent-binary-trees) |
+| [1029-vertical-order-traversal-of-a-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1029-vertical-order-traversal-of-a-binary-tree) |
+| [1030-smallest-string-starting-from-leaf](https://github.com/Devn913/LeetCode/tree/master/1030-smallest-string-starting-from-leaf) |
+| [1093-recover-a-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1093-recover-a-tree-from-preorder-traversal) |
+| [1387-find-elements-in-a-contaminated-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1387-find-elements-in-a-contaminated-binary-tree) |
+| [2461-amount-of-time-for-binary-tree-to-be-infected](https://github.com/Devn913/LeetCode/tree/master/2461-amount-of-time-for-binary-tree-to-be-infected) |
+| [2493-reverse-odd-levels-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/2493-reverse-odd-levels-of-binary-tree) |
+| [2564-most-profitable-path-in-a-tree](https://github.com/Devn913/LeetCode/tree/master/2564-most-profitable-path-in-a-tree) |
+| [2793-count-the-number-of-complete-components](https://github.com/Devn913/LeetCode/tree/master/2793-count-the-number-of-complete-components) |
+## Binary Tree
+|  |
+| ------- |
+| [0094-binary-tree-inorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0094-binary-tree-inorder-traversal) |
+| [0098-validate-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0098-validate-binary-search-tree) |
+| [0100-same-tree](https://github.com/Devn913/LeetCode/tree/master/0100-same-tree) |
+| [0102-binary-tree-level-order-traversal](https://github.com/Devn913/LeetCode/tree/master/0102-binary-tree-level-order-traversal) |
+| [0103-binary-tree-zigzag-level-order-traversal](https://github.com/Devn913/LeetCode/tree/master/0103-binary-tree-zigzag-level-order-traversal) |
+| [0104-maximum-depth-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0104-maximum-depth-of-binary-tree) |
+| [0106-construct-binary-tree-from-inorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0106-construct-binary-tree-from-inorder-and-postorder-traversal) |
+| [0108-convert-sorted-array-to-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0108-convert-sorted-array-to-binary-search-tree) |
+| [0110-balanced-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0110-balanced-binary-tree) |
+| [0112-path-sum](https://github.com/Devn913/LeetCode/tree/master/0112-path-sum) |
+| [0114-flatten-binary-tree-to-linked-list](https://github.com/Devn913/LeetCode/tree/master/0114-flatten-binary-tree-to-linked-list) |
+| [0116-populating-next-right-pointers-in-each-node](https://github.com/Devn913/LeetCode/tree/master/0116-populating-next-right-pointers-in-each-node) |
+| [0124-binary-tree-maximum-path-sum](https://github.com/Devn913/LeetCode/tree/master/0124-binary-tree-maximum-path-sum) |
+| [0144-binary-tree-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0144-binary-tree-preorder-traversal) |
+| [0145-binary-tree-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0145-binary-tree-postorder-traversal) |
+| [0199-binary-tree-right-side-view](https://github.com/Devn913/LeetCode/tree/master/0199-binary-tree-right-side-view) |
+| [0226-invert-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0226-invert-binary-tree) |
+| [0230-kth-smallest-element-in-a-bst](https://github.com/Devn913/LeetCode/tree/master/0230-kth-smallest-element-in-a-bst) |
+| [0235-lowest-common-ancestor-of-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0235-lowest-common-ancestor-of-a-binary-search-tree) |
+| [0236-lowest-common-ancestor-of-a-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0236-lowest-common-ancestor-of-a-binary-tree) |
+| [0257-binary-tree-paths](https://github.com/Devn913/LeetCode/tree/master/0257-binary-tree-paths) |
+| [0337-house-robber-iii](https://github.com/Devn913/LeetCode/tree/master/0337-house-robber-iii) |
+| [0404-sum-of-left-leaves](https://github.com/Devn913/LeetCode/tree/master/0404-sum-of-left-leaves) |
+| [0513-find-bottom-left-tree-value](https://github.com/Devn913/LeetCode/tree/master/0513-find-bottom-left-tree-value) |
+| [0543-diameter-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0543-diameter-of-binary-tree) |
+| [0637-average-of-levels-in-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0637-average-of-levels-in-binary-tree) |
+| [0783-search-in-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0783-search-in-a-binary-search-tree) |
+| [0784-insert-into-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0784-insert-into-a-binary-search-tree) |
+| [0925-construct-binary-tree-from-preorder-and-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0925-construct-binary-tree-from-preorder-and-postorder-traversal) |
+| [0988-flip-equivalent-binary-trees](https://github.com/Devn913/LeetCode/tree/master/0988-flip-equivalent-binary-trees) |
+| [1029-vertical-order-traversal-of-a-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1029-vertical-order-traversal-of-a-binary-tree) |
+| [1030-smallest-string-starting-from-leaf](https://github.com/Devn913/LeetCode/tree/master/1030-smallest-string-starting-from-leaf) |
+| [1050-construct-binary-search-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1050-construct-binary-search-tree-from-preorder-traversal) |
+| [1093-recover-a-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1093-recover-a-tree-from-preorder-traversal) |
+| [1387-find-elements-in-a-contaminated-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1387-find-elements-in-a-contaminated-binary-tree) |
+| [2461-amount-of-time-for-binary-tree-to-be-infected](https://github.com/Devn913/LeetCode/tree/master/2461-amount-of-time-for-binary-tree-to-be-infected) |
+| [2493-reverse-odd-levels-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/2493-reverse-odd-levels-of-binary-tree) |
+## Math
+|  |
+| ------- |
+| [0013-roman-to-integer](https://github.com/Devn913/LeetCode/tree/master/0013-roman-to-integer) |
+| [0029-divide-two-integers](https://github.com/Devn913/LeetCode/tree/master/0029-divide-two-integers) |
+| [0048-rotate-image](https://github.com/Devn913/LeetCode/tree/master/0048-rotate-image) |
+| [0050-powx-n](https://github.com/Devn913/LeetCode/tree/master/0050-powx-n) |
+| [0062-unique-paths](https://github.com/Devn913/LeetCode/tree/master/0062-unique-paths) |
+| [0069-sqrtx](https://github.com/Devn913/LeetCode/tree/master/0069-sqrtx) |
+| [0070-climbing-stairs](https://github.com/Devn913/LeetCode/tree/master/0070-climbing-stairs) |
+| [0149-max-points-on-a-line](https://github.com/Devn913/LeetCode/tree/master/0149-max-points-on-a-line) |
+| [0268-missing-number](https://github.com/Devn913/LeetCode/tree/master/0268-missing-number) |
+| [0326-power-of-three](https://github.com/Devn913/LeetCode/tree/master/0326-power-of-three) |
+| [0342-power-of-four](https://github.com/Devn913/LeetCode/tree/master/0342-power-of-four) |
+| [1014-k-closest-points-to-origin](https://github.com/Devn913/LeetCode/tree/master/1014-k-closest-points-to-origin) |
+| [1421-find-numbers-with-even-number-of-digits](https://github.com/Devn913/LeetCode/tree/master/1421-find-numbers-with-even-number-of-digits) |
+| [1631-number-of-sub-arrays-with-odd-sum](https://github.com/Devn913/LeetCode/tree/master/1631-number-of-sub-arrays-with-odd-sum) |
+| [1642-water-bottles](https://github.com/Devn913/LeetCode/tree/master/1642-water-bottles) |
+| [1889-check-if-number-is-a-sum-of-powers-of-three](https://github.com/Devn913/LeetCode/tree/master/1889-check-if-number-is-a-sum-of-powers-of-three) |
+| [2160-minimum-operations-to-make-a-uni-value-grid](https://github.com/Devn913/LeetCode/tree/master/2160-minimum-operations-to-make-a-uni-value-grid) |
+| [2174-next-greater-numerically-balanced-number](https://github.com/Devn913/LeetCode/tree/master/2174-next-greater-numerically-balanced-number) |
+| [2307-replace-non-coprime-numbers-in-array](https://github.com/Devn913/LeetCode/tree/master/2307-replace-non-coprime-numbers-in-array) |
+| [2324-find-triangular-sum-of-an-array](https://github.com/Devn913/LeetCode/tree/master/2324-find-triangular-sum-of-an-array) |
+| [2448-count-number-of-bad-pairs](https://github.com/Devn913/LeetCode/tree/master/2448-count-number-of-bad-pairs) |
+| [2610-closest-prime-numbers-in-range](https://github.com/Devn913/LeetCode/tree/master/2610-closest-prime-numbers-in-range) |
+| [2649-count-total-number-of-colored-cells](https://github.com/Devn913/LeetCode/tree/master/2649-count-total-number-of-colored-cells) |
+| [3001-apply-operations-to-maximize-score](https://github.com/Devn913/LeetCode/tree/master/3001-apply-operations-to-maximize-score) |
+| [3172-divisible-and-non-divisible-sums-difference](https://github.com/Devn913/LeetCode/tree/master/3172-divisible-and-non-divisible-sums-difference) |
+| [3201-distribute-candies-among-children-ii](https://github.com/Devn913/LeetCode/tree/master/3201-distribute-candies-among-children-ii) |
+| [3227-find-missing-and-repeated-values](https://github.com/Devn913/LeetCode/tree/master/3227-find-missing-and-repeated-values) |
+## Bit Manipulation
+|  |
+| ------- |
+| [0029-divide-two-integers](https://github.com/Devn913/LeetCode/tree/master/0029-divide-two-integers) |
+| [0078-subsets](https://github.com/Devn913/LeetCode/tree/master/0078-subsets) |
+| [0187-repeated-dna-sequences](https://github.com/Devn913/LeetCode/tree/master/0187-repeated-dna-sequences) |
+| [0191-number-of-1-bits](https://github.com/Devn913/LeetCode/tree/master/0191-number-of-1-bits) |
+| [0201-bitwise-and-of-numbers-range](https://github.com/Devn913/LeetCode/tree/master/0201-bitwise-and-of-numbers-range) |
+| [0268-missing-number](https://github.com/Devn913/LeetCode/tree/master/0268-missing-number) |
+| [0287-find-the-duplicate-number](https://github.com/Devn913/LeetCode/tree/master/0287-find-the-duplicate-number) |
+| [0338-counting-bits](https://github.com/Devn913/LeetCode/tree/master/0338-counting-bits) |
+| [0342-power-of-four](https://github.com/Devn913/LeetCode/tree/master/0342-power-of-four) |
+| [2308-divide-array-into-equal-pairs](https://github.com/Devn913/LeetCode/tree/master/2308-divide-array-into-equal-pairs) |
+| [2427-first-letter-to-appear-twice](https://github.com/Devn913/LeetCode/tree/master/2427-first-letter-to-appear-twice) |
+| [2478-longest-nice-subarray](https://github.com/Devn913/LeetCode/tree/master/2478-longest-nice-subarray) |
+| [3348-minimum-cost-walk-in-weighted-graph](https://github.com/Devn913/LeetCode/tree/master/3348-minimum-cost-walk-in-weighted-graph) |
+| [3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i](https://github.com/Devn913/LeetCode/tree/master/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i) |
+## Recursion
+|  |
+| ------- |
+| [0021-merge-two-sorted-lists](https://github.com/Devn913/LeetCode/tree/master/0021-merge-two-sorted-lists) |
+| [0025-reverse-nodes-in-k-group](https://github.com/Devn913/LeetCode/tree/master/0025-reverse-nodes-in-k-group) |
+| [0050-powx-n](https://github.com/Devn913/LeetCode/tree/master/0050-powx-n) |
+| [0143-reorder-list](https://github.com/Devn913/LeetCode/tree/master/0143-reorder-list) |
+| [0206-reverse-linked-list](https://github.com/Devn913/LeetCode/tree/master/0206-reverse-linked-list) |
+| [0234-palindrome-linked-list](https://github.com/Devn913/LeetCode/tree/master/0234-palindrome-linked-list) |
+| [0326-power-of-three](https://github.com/Devn913/LeetCode/tree/master/0326-power-of-three) |
+| [0342-power-of-four](https://github.com/Devn913/LeetCode/tree/master/0342-power-of-four) |
+## Counting
+|  |
+| ------- |
+| [0169-majority-element](https://github.com/Devn913/LeetCode/tree/master/0169-majority-element) |
+| [0229-majority-element-ii](https://github.com/Devn913/LeetCode/tree/master/0229-majority-element-ii) |
+| [0347-top-k-frequent-elements](https://github.com/Devn913/LeetCode/tree/master/0347-top-k-frequent-elements) |
+| [0451-sort-characters-by-frequency](https://github.com/Devn913/LeetCode/tree/master/0451-sort-characters-by-frequency) |
+| [1034-subarrays-with-k-different-integers](https://github.com/Devn913/LeetCode/tree/master/1034-subarrays-with-k-different-integers) |
+| [1983-maximum-population-year](https://github.com/Devn913/LeetCode/tree/master/1983-maximum-population-year) |
+| [2174-next-greater-numerically-balanced-number](https://github.com/Devn913/LeetCode/tree/master/2174-next-greater-numerically-balanced-number) |
+| [2308-divide-array-into-equal-pairs](https://github.com/Devn913/LeetCode/tree/master/2308-divide-array-into-equal-pairs) |
+| [2427-first-letter-to-appear-twice](https://github.com/Devn913/LeetCode/tree/master/2427-first-letter-to-appear-twice) |
+| [2448-count-number-of-bad-pairs](https://github.com/Devn913/LeetCode/tree/master/2448-count-number-of-bad-pairs) |
+| [2614-maximum-count-of-positive-integer-and-negative-integer](https://github.com/Devn913/LeetCode/tree/master/2614-maximum-count-of-positive-integer-and-negative-integer) |
+| [3242-count-elements-with-maximum-frequency](https://github.com/Devn913/LeetCode/tree/master/3242-count-elements-with-maximum-frequency) |
+## Combinatorics
+|  |
+| ------- |
+| [0062-unique-paths](https://github.com/Devn913/LeetCode/tree/master/0062-unique-paths) |
+| [2324-find-triangular-sum-of-an-array](https://github.com/Devn913/LeetCode/tree/master/2324-find-triangular-sum-of-an-array) |
+| [3201-distribute-candies-among-children-ii](https://github.com/Devn913/LeetCode/tree/master/3201-distribute-candies-among-children-ii) |
+## Stack
+|  |
+| ------- |
+| [0020-valid-parentheses](https://github.com/Devn913/LeetCode/tree/master/0020-valid-parentheses) |
+| [0094-binary-tree-inorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0094-binary-tree-inorder-traversal) |
+| [0114-flatten-binary-tree-to-linked-list](https://github.com/Devn913/LeetCode/tree/master/0114-flatten-binary-tree-to-linked-list) |
+| [0143-reorder-list](https://github.com/Devn913/LeetCode/tree/master/0143-reorder-list) |
+| [0144-binary-tree-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0144-binary-tree-preorder-traversal) |
+| [0145-binary-tree-postorder-traversal](https://github.com/Devn913/LeetCode/tree/master/0145-binary-tree-postorder-traversal) |
+| [0155-min-stack](https://github.com/Devn913/LeetCode/tree/master/0155-min-stack) |
+| [0225-implement-stack-using-queues](https://github.com/Devn913/LeetCode/tree/master/0225-implement-stack-using-queues) |
+| [0232-implement-queue-using-stacks](https://github.com/Devn913/LeetCode/tree/master/0232-implement-queue-using-stacks) |
+| [0234-palindrome-linked-list](https://github.com/Devn913/LeetCode/tree/master/0234-palindrome-linked-list) |
+| [0402-remove-k-digits](https://github.com/Devn913/LeetCode/tree/master/0402-remove-k-digits) |
+| [0503-next-greater-element-ii](https://github.com/Devn913/LeetCode/tree/master/0503-next-greater-element-ii) |
+| [0735-asteroid-collision](https://github.com/Devn913/LeetCode/tree/master/0735-asteroid-collision) |
+| [0739-daily-temperatures](https://github.com/Devn913/LeetCode/tree/master/0739-daily-temperatures) |
+| [0937-online-stock-span](https://github.com/Devn913/LeetCode/tree/master/0937-online-stock-span) |
+| [1050-construct-binary-search-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1050-construct-binary-search-tree-from-preorder-traversal) |
+| [2021-remove-all-occurrences-of-a-substring](https://github.com/Devn913/LeetCode/tree/master/2021-remove-all-occurrences-of-a-substring) |
+| [2307-replace-non-coprime-numbers-in-array](https://github.com/Devn913/LeetCode/tree/master/2307-replace-non-coprime-numbers-in-array) |
+| [3001-apply-operations-to-maximize-score](https://github.com/Devn913/LeetCode/tree/master/3001-apply-operations-to-maximize-score) |
+| [3447-clear-digits](https://github.com/Devn913/LeetCode/tree/master/3447-clear-digits) |
+## Design
+|  |
+| ------- |
+| [0155-min-stack](https://github.com/Devn913/LeetCode/tree/master/0155-min-stack) |
+| [0225-implement-stack-using-queues](https://github.com/Devn913/LeetCode/tree/master/0225-implement-stack-using-queues) |
+| [0232-implement-queue-using-stacks](https://github.com/Devn913/LeetCode/tree/master/0232-implement-queue-using-stacks) |
+| [0303-range-sum-query-immutable](https://github.com/Devn913/LeetCode/tree/master/0303-range-sum-query-immutable) |
+| [0838-design-linked-list](https://github.com/Devn913/LeetCode/tree/master/0838-design-linked-list) |
+| [0937-online-stock-span](https://github.com/Devn913/LeetCode/tree/master/0937-online-stock-span) |
+| [1387-find-elements-in-a-contaminated-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1387-find-elements-in-a-contaminated-binary-tree) |
+| [2429-design-a-food-rating-system](https://github.com/Devn913/LeetCode/tree/master/2429-design-a-food-rating-system) |
+## Monotonic Stack
+|  |
+| ------- |
+| [0402-remove-k-digits](https://github.com/Devn913/LeetCode/tree/master/0402-remove-k-digits) |
+| [0503-next-greater-element-ii](https://github.com/Devn913/LeetCode/tree/master/0503-next-greater-element-ii) |
+| [0739-daily-temperatures](https://github.com/Devn913/LeetCode/tree/master/0739-daily-temperatures) |
+| [0937-online-stock-span](https://github.com/Devn913/LeetCode/tree/master/0937-online-stock-span) |
+| [1050-construct-binary-search-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1050-construct-binary-search-tree-from-preorder-traversal) |
+| [3001-apply-operations-to-maximize-score](https://github.com/Devn913/LeetCode/tree/master/3001-apply-operations-to-maximize-score) |
+## Data Stream
+|  |
+| ------- |
+| [0937-online-stock-span](https://github.com/Devn913/LeetCode/tree/master/0937-online-stock-span) |
+## Breadth-First Search
+|  |
+| ------- |
+| [0100-same-tree](https://github.com/Devn913/LeetCode/tree/master/0100-same-tree) |
+| [0102-binary-tree-level-order-traversal](https://github.com/Devn913/LeetCode/tree/master/0102-binary-tree-level-order-traversal) |
+| [0103-binary-tree-zigzag-level-order-traversal](https://github.com/Devn913/LeetCode/tree/master/0103-binary-tree-zigzag-level-order-traversal) |
+| [0104-maximum-depth-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0104-maximum-depth-of-binary-tree) |
+| [0112-path-sum](https://github.com/Devn913/LeetCode/tree/master/0112-path-sum) |
+| [0116-populating-next-right-pointers-in-each-node](https://github.com/Devn913/LeetCode/tree/master/0116-populating-next-right-pointers-in-each-node) |
+| [0133-clone-graph](https://github.com/Devn913/LeetCode/tree/master/0133-clone-graph) |
+| [0199-binary-tree-right-side-view](https://github.com/Devn913/LeetCode/tree/master/0199-binary-tree-right-side-view) |
+| [0200-number-of-islands](https://github.com/Devn913/LeetCode/tree/master/0200-number-of-islands) |
+| [0226-invert-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0226-invert-binary-tree) |
+| [0322-coin-change](https://github.com/Devn913/LeetCode/tree/master/0322-coin-change) |
+| [0404-sum-of-left-leaves](https://github.com/Devn913/LeetCode/tree/master/0404-sum-of-left-leaves) |
+| [0513-find-bottom-left-tree-value](https://github.com/Devn913/LeetCode/tree/master/0513-find-bottom-left-tree-value) |
+| [0637-average-of-levels-in-binary-tree](https://github.com/Devn913/LeetCode/tree/master/0637-average-of-levels-in-binary-tree) |
+| [0820-find-eventual-safe-states](https://github.com/Devn913/LeetCode/tree/master/0820-find-eventual-safe-states) |
+| [1029-vertical-order-traversal-of-a-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1029-vertical-order-traversal-of-a-binary-tree) |
+| [1387-find-elements-in-a-contaminated-binary-tree](https://github.com/Devn913/LeetCode/tree/master/1387-find-elements-in-a-contaminated-binary-tree) |
+| [2461-amount-of-time-for-binary-tree-to-be-infected](https://github.com/Devn913/LeetCode/tree/master/2461-amount-of-time-for-binary-tree-to-be-infected) |
+| [2493-reverse-odd-levels-of-binary-tree](https://github.com/Devn913/LeetCode/tree/master/2493-reverse-odd-levels-of-binary-tree) |
+| [2564-most-profitable-path-in-a-tree](https://github.com/Devn913/LeetCode/tree/master/2564-most-profitable-path-in-a-tree) |
+| [2588-maximum-number-of-points-from-grid-queries](https://github.com/Devn913/LeetCode/tree/master/2588-maximum-number-of-points-from-grid-queries) |
+| [2793-count-the-number-of-complete-components](https://github.com/Devn913/LeetCode/tree/master/2793-count-the-number-of-complete-components) |
+## Union Find
+|  |
+| ------- |
+| [0128-longest-consecutive-sequence](https://github.com/Devn913/LeetCode/tree/master/0128-longest-consecutive-sequence) |
+| [0200-number-of-islands](https://github.com/Devn913/LeetCode/tree/master/0200-number-of-islands) |
+| [2588-maximum-number-of-points-from-grid-queries](https://github.com/Devn913/LeetCode/tree/master/2588-maximum-number-of-points-from-grid-queries) |
+| [2793-count-the-number-of-complete-components](https://github.com/Devn913/LeetCode/tree/master/2793-count-the-number-of-complete-components) |
+| [3348-minimum-cost-walk-in-weighted-graph](https://github.com/Devn913/LeetCode/tree/master/3348-minimum-cost-walk-in-weighted-graph) |
+## Graph
+|  |
+| ------- |
+| [0133-clone-graph](https://github.com/Devn913/LeetCode/tree/master/0133-clone-graph) |
+| [0820-find-eventual-safe-states](https://github.com/Devn913/LeetCode/tree/master/0820-find-eventual-safe-states) |
+| [2090-number-of-ways-to-arrive-at-destination](https://github.com/Devn913/LeetCode/tree/master/2090-number-of-ways-to-arrive-at-destination) |
+| [2220-find-all-possible-recipes-from-given-supplies](https://github.com/Devn913/LeetCode/tree/master/2220-find-all-possible-recipes-from-given-supplies) |
+| [2564-most-profitable-path-in-a-tree](https://github.com/Devn913/LeetCode/tree/master/2564-most-profitable-path-in-a-tree) |
+| [2793-count-the-number-of-complete-components](https://github.com/Devn913/LeetCode/tree/master/2793-count-the-number-of-complete-components) |
+| [3348-minimum-cost-walk-in-weighted-graph](https://github.com/Devn913/LeetCode/tree/master/3348-minimum-cost-walk-in-weighted-graph) |
+## Topological Sort
+|  |
+| ------- |
+| [0820-find-eventual-safe-states](https://github.com/Devn913/LeetCode/tree/master/0820-find-eventual-safe-states) |
+| [2090-number-of-ways-to-arrive-at-destination](https://github.com/Devn913/LeetCode/tree/master/2090-number-of-ways-to-arrive-at-destination) |
+| [2220-find-all-possible-recipes-from-given-supplies](https://github.com/Devn913/LeetCode/tree/master/2220-find-all-possible-recipes-from-given-supplies) |
+## Prefix Sum
+|  |
+| ------- |
+| [0209-minimum-size-subarray-sum](https://github.com/Devn913/LeetCode/tree/master/0209-minimum-size-subarray-sum) |
+| [0238-product-of-array-except-self](https://github.com/Devn913/LeetCode/tree/master/0238-product-of-array-except-self) |
+| [0303-range-sum-query-immutable](https://github.com/Devn913/LeetCode/tree/master/0303-range-sum-query-immutable) |
+| [0525-contiguous-array](https://github.com/Devn913/LeetCode/tree/master/0525-contiguous-array) |
+| [0560-subarray-sum-equals-k](https://github.com/Devn913/LeetCode/tree/master/0560-subarray-sum-equals-k) |
+| [0713-subarray-product-less-than-k](https://github.com/Devn913/LeetCode/tree/master/0713-subarray-product-less-than-k) |
+| [0966-binary-subarrays-with-sum](https://github.com/Devn913/LeetCode/tree/master/0966-binary-subarrays-with-sum) |
+| [1631-number-of-sub-arrays-with-odd-sum](https://github.com/Devn913/LeetCode/tree/master/1631-number-of-sub-arrays-with-odd-sum) |
+| [1983-maximum-population-year](https://github.com/Devn913/LeetCode/tree/master/1983-maximum-population-year) |
+| [2394-count-subarrays-with-score-less-than-k](https://github.com/Devn913/LeetCode/tree/master/2394-count-subarrays-with-score-less-than-k) |
+| [3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i](https://github.com/Devn913/LeetCode/tree/master/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i) |
+| [3643-zero-array-transformation-ii](https://github.com/Devn913/LeetCode/tree/master/3643-zero-array-transformation-ii) |
+## Enumeration
+|  |
+| ------- |
+| [2174-next-greater-numerically-balanced-number](https://github.com/Devn913/LeetCode/tree/master/2174-next-greater-numerically-balanced-number) |
+| [3201-distribute-candies-among-children-ii](https://github.com/Devn913/LeetCode/tree/master/3201-distribute-candies-among-children-ii) |
+| [3398-make-a-square-with-the-same-color](https://github.com/Devn913/LeetCode/tree/master/3398-make-a-square-with-the-same-color) |
+## Linked List
+|  |
+| ------- |
+| [0021-merge-two-sorted-lists](https://github.com/Devn913/LeetCode/tree/master/0021-merge-two-sorted-lists) |
+| [0023-merge-k-sorted-lists](https://github.com/Devn913/LeetCode/tree/master/0023-merge-k-sorted-lists) |
+| [0025-reverse-nodes-in-k-group](https://github.com/Devn913/LeetCode/tree/master/0025-reverse-nodes-in-k-group) |
+| [0061-rotate-list](https://github.com/Devn913/LeetCode/tree/master/0061-rotate-list) |
+| [0082-remove-duplicates-from-sorted-list-ii](https://github.com/Devn913/LeetCode/tree/master/0082-remove-duplicates-from-sorted-list-ii) |
+| [0083-remove-duplicates-from-sorted-list](https://github.com/Devn913/LeetCode/tree/master/0083-remove-duplicates-from-sorted-list) |
+| [0092-reverse-linked-list-ii](https://github.com/Devn913/LeetCode/tree/master/0092-reverse-linked-list-ii) |
+| [0114-flatten-binary-tree-to-linked-list](https://github.com/Devn913/LeetCode/tree/master/0114-flatten-binary-tree-to-linked-list) |
+| [0116-populating-next-right-pointers-in-each-node](https://github.com/Devn913/LeetCode/tree/master/0116-populating-next-right-pointers-in-each-node) |
+| [0138-copy-list-with-random-pointer](https://github.com/Devn913/LeetCode/tree/master/0138-copy-list-with-random-pointer) |
+| [0141-linked-list-cycle](https://github.com/Devn913/LeetCode/tree/master/0141-linked-list-cycle) |
+| [0142-linked-list-cycle-ii](https://github.com/Devn913/LeetCode/tree/master/0142-linked-list-cycle-ii) |
+| [0143-reorder-list](https://github.com/Devn913/LeetCode/tree/master/0143-reorder-list) |
+| [0160-intersection-of-two-linked-lists](https://github.com/Devn913/LeetCode/tree/master/0160-intersection-of-two-linked-lists) |
+| [0206-reverse-linked-list](https://github.com/Devn913/LeetCode/tree/master/0206-reverse-linked-list) |
+| [0234-palindrome-linked-list](https://github.com/Devn913/LeetCode/tree/master/0234-palindrome-linked-list) |
+| [0328-odd-even-linked-list](https://github.com/Devn913/LeetCode/tree/master/0328-odd-even-linked-list) |
+| [0725-split-linked-list-in-parts](https://github.com/Devn913/LeetCode/tree/master/0725-split-linked-list-in-parts) |
+| [0838-design-linked-list](https://github.com/Devn913/LeetCode/tree/master/0838-design-linked-list) |
+| [0908-middle-of-the-linked-list](https://github.com/Devn913/LeetCode/tree/master/0908-middle-of-the-linked-list) |
+| [2216-delete-the-middle-node-of-a-linked-list](https://github.com/Devn913/LeetCode/tree/master/2216-delete-the-middle-node-of-a-linked-list) |
+| [3501-delete-nodes-from-linked-list-present-in-array](https://github.com/Devn913/LeetCode/tree/master/3501-delete-nodes-from-linked-list-present-in-array) |
+## Backtracking
+|  |
+| ------- |
+| [0039-combination-sum](https://github.com/Devn913/LeetCode/tree/master/0039-combination-sum) |
+| [0040-combination-sum-ii](https://github.com/Devn913/LeetCode/tree/master/0040-combination-sum-ii) |
+| [0046-permutations](https://github.com/Devn913/LeetCode/tree/master/0046-permutations) |
+| [0078-subsets](https://github.com/Devn913/LeetCode/tree/master/0078-subsets) |
+| [0131-palindrome-partitioning](https://github.com/Devn913/LeetCode/tree/master/0131-palindrome-partitioning) |
+| [0257-binary-tree-paths](https://github.com/Devn913/LeetCode/tree/master/0257-binary-tree-paths) |
+| [1030-smallest-string-starting-from-leaf](https://github.com/Devn913/LeetCode/tree/master/1030-smallest-string-starting-from-leaf) |
+| [2107-find-unique-binary-string](https://github.com/Devn913/LeetCode/tree/master/2107-find-unique-binary-string) |
+| [2174-next-greater-numerically-balanced-number](https://github.com/Devn913/LeetCode/tree/master/2174-next-greater-numerically-balanced-number) |
+## Interactive
+|  |
+| ------- |
+| [0374-guess-number-higher-or-lower](https://github.com/Devn913/LeetCode/tree/master/0374-guess-number-higher-or-lower) |
+## String
+|  |
+| ------- |
+| [0003-longest-substring-without-repeating-characters](https://github.com/Devn913/LeetCode/tree/master/0003-longest-substring-without-repeating-characters) |
+| [0013-roman-to-integer](https://github.com/Devn913/LeetCode/tree/master/0013-roman-to-integer) |
+| [0020-valid-parentheses](https://github.com/Devn913/LeetCode/tree/master/0020-valid-parentheses) |
+| [0038-count-and-say](https://github.com/Devn913/LeetCode/tree/master/0038-count-and-say) |
+| [0049-group-anagrams](https://github.com/Devn913/LeetCode/tree/master/0049-group-anagrams) |
+| [0076-minimum-window-substring](https://github.com/Devn913/LeetCode/tree/master/0076-minimum-window-substring) |
+| [0131-palindrome-partitioning](https://github.com/Devn913/LeetCode/tree/master/0131-palindrome-partitioning) |
+| [0187-repeated-dna-sequences](https://github.com/Devn913/LeetCode/tree/master/0187-repeated-dna-sequences) |
+| [0257-binary-tree-paths](https://github.com/Devn913/LeetCode/tree/master/0257-binary-tree-paths) |
+| [0402-remove-k-digits](https://github.com/Devn913/LeetCode/tree/master/0402-remove-k-digits) |
+| [0424-longest-repeating-character-replacement](https://github.com/Devn913/LeetCode/tree/master/0424-longest-repeating-character-replacement) |
+| [0451-sort-characters-by-frequency](https://github.com/Devn913/LeetCode/tree/master/0451-sort-characters-by-frequency) |
+| [0516-longest-palindromic-subsequence](https://github.com/Devn913/LeetCode/tree/master/0516-longest-palindromic-subsequence) |
+| [0768-partition-labels](https://github.com/Devn913/LeetCode/tree/master/0768-partition-labels) |
+| [1030-smallest-string-starting-from-leaf](https://github.com/Devn913/LeetCode/tree/master/1030-smallest-string-starting-from-leaf) |
+| [1093-recover-a-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1093-recover-a-tree-from-preorder-traversal) |
+| [1170-shortest-common-supersequence](https://github.com/Devn913/LeetCode/tree/master/1170-shortest-common-supersequence) |
+| [1250-longest-common-subsequence](https://github.com/Devn913/LeetCode/tree/master/1250-longest-common-subsequence) |
+| [1460-number-of-substrings-containing-all-three-characters](https://github.com/Devn913/LeetCode/tree/master/1460-number-of-substrings-containing-all-three-characters) |
+| [1652-minimum-suffix-flips](https://github.com/Devn913/LeetCode/tree/master/1652-minimum-suffix-flips) |
+| [2021-remove-all-occurrences-of-a-substring](https://github.com/Devn913/LeetCode/tree/master/2021-remove-all-occurrences-of-a-substring) |
+| [2107-find-unique-binary-string](https://github.com/Devn913/LeetCode/tree/master/2107-find-unique-binary-string) |
+| [2220-find-all-possible-recipes-from-given-supplies](https://github.com/Devn913/LeetCode/tree/master/2220-find-all-possible-recipes-from-given-supplies) |
+| [2260-divide-a-string-into-groups-of-size-k](https://github.com/Devn913/LeetCode/tree/master/2260-divide-a-string-into-groups-of-size-k) |
+| [2427-first-letter-to-appear-twice](https://github.com/Devn913/LeetCode/tree/master/2427-first-letter-to-appear-twice) |
+| [2429-design-a-food-rating-system](https://github.com/Devn913/LeetCode/tree/master/2429-design-a-food-rating-system) |
+| [2463-minimum-recolors-to-get-k-consecutive-black-blocks](https://github.com/Devn913/LeetCode/tree/master/2463-minimum-recolors-to-get-k-consecutive-black-blocks) |
+| [2887-sort-vowels-in-a-string](https://github.com/Devn913/LeetCode/tree/master/2887-sort-vowels-in-a-string) |
+| [3447-clear-digits](https://github.com/Devn913/LeetCode/tree/master/3447-clear-digits) |
+| [3541-report-spam-message](https://github.com/Devn913/LeetCode/tree/master/3541-report-spam-message) |
+| [3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii](https://github.com/Devn913/LeetCode/tree/master/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii) |
+## Simulation
+|  |
+| ------- |
+| [0735-asteroid-collision](https://github.com/Devn913/LeetCode/tree/master/0735-asteroid-collision) |
+| [1642-water-bottles](https://github.com/Devn913/LeetCode/tree/master/1642-water-bottles) |
+| [2021-remove-all-occurrences-of-a-substring](https://github.com/Devn913/LeetCode/tree/master/2021-remove-all-occurrences-of-a-substring) |
+| [2048-build-array-from-permutation](https://github.com/Devn913/LeetCode/tree/master/2048-build-array-from-permutation) |
+| [2260-divide-a-string-into-groups-of-size-k](https://github.com/Devn913/LeetCode/tree/master/2260-divide-a-string-into-groups-of-size-k) |
+| [2265-partition-array-according-to-given-pivot](https://github.com/Devn913/LeetCode/tree/master/2265-partition-array-according-to-given-pivot) |
+| [2324-find-triangular-sum-of-an-array](https://github.com/Devn913/LeetCode/tree/master/2324-find-triangular-sum-of-an-array) |
+| [2551-apply-operations-to-an-array](https://github.com/Devn913/LeetCode/tree/master/2551-apply-operations-to-an-array) |
+| [3332-minimum-operations-to-exceed-threshold-value-ii](https://github.com/Devn913/LeetCode/tree/master/3332-minimum-operations-to-exceed-threshold-value-ii) |
+| [3447-clear-digits](https://github.com/Devn913/LeetCode/tree/master/3447-clear-digits) |
+## Heap (Priority Queue)
+|  |
+| ------- |
+| [0023-merge-k-sorted-lists](https://github.com/Devn913/LeetCode/tree/master/0023-merge-k-sorted-lists) |
+| [0215-kth-largest-element-in-an-array](https://github.com/Devn913/LeetCode/tree/master/0215-kth-largest-element-in-an-array) |
+| [0239-sliding-window-maximum](https://github.com/Devn913/LeetCode/tree/master/0239-sliding-window-maximum) |
+| [0347-top-k-frequent-elements](https://github.com/Devn913/LeetCode/tree/master/0347-top-k-frequent-elements) |
+| [0451-sort-characters-by-frequency](https://github.com/Devn913/LeetCode/tree/master/0451-sort-characters-by-frequency) |
+| [0480-sliding-window-median](https://github.com/Devn913/LeetCode/tree/master/0480-sliding-window-median) |
+| [1014-k-closest-points-to-origin](https://github.com/Devn913/LeetCode/tree/master/1014-k-closest-points-to-origin) |
+| [2429-design-a-food-rating-system](https://github.com/Devn913/LeetCode/tree/master/2429-design-a-food-rating-system) |
+| [2588-maximum-number-of-points-from-grid-queries](https://github.com/Devn913/LeetCode/tree/master/2588-maximum-number-of-points-from-grid-queries) |
+| [2681-put-marbles-in-bags](https://github.com/Devn913/LeetCode/tree/master/2681-put-marbles-in-bags) |
+| [3332-minimum-operations-to-exceed-threshold-value-ii](https://github.com/Devn913/LeetCode/tree/master/3332-minimum-operations-to-exceed-threshold-value-ii) |
+## Binary Search Tree
+|  |
+| ------- |
+| [0098-validate-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0098-validate-binary-search-tree) |
+| [0108-convert-sorted-array-to-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0108-convert-sorted-array-to-binary-search-tree) |
+| [0230-kth-smallest-element-in-a-bst](https://github.com/Devn913/LeetCode/tree/master/0230-kth-smallest-element-in-a-bst) |
+| [0235-lowest-common-ancestor-of-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0235-lowest-common-ancestor-of-a-binary-search-tree) |
+| [0783-search-in-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0783-search-in-a-binary-search-tree) |
+| [0784-insert-into-a-binary-search-tree](https://github.com/Devn913/LeetCode/tree/master/0784-insert-into-a-binary-search-tree) |
+| [1050-construct-binary-search-tree-from-preorder-traversal](https://github.com/Devn913/LeetCode/tree/master/1050-construct-binary-search-tree-from-preorder-traversal) |
+## Queue
+|  |
+| ------- |
+| [0225-implement-stack-using-queues](https://github.com/Devn913/LeetCode/tree/master/0225-implement-stack-using-queues) |
+| [0232-implement-queue-using-stacks](https://github.com/Devn913/LeetCode/tree/master/0232-implement-queue-using-stacks) |
+| [0239-sliding-window-maximum](https://github.com/Devn913/LeetCode/tree/master/0239-sliding-window-maximum) |
+| [0954-maximum-sum-circular-subarray](https://github.com/Devn913/LeetCode/tree/master/0954-maximum-sum-circular-subarray) |
+| [3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i](https://github.com/Devn913/LeetCode/tree/master/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i) |
+## Monotonic Queue
+|  |
+| ------- |
+| [0239-sliding-window-maximum](https://github.com/Devn913/LeetCode/tree/master/0239-sliding-window-maximum) |
+| [0954-maximum-sum-circular-subarray](https://github.com/Devn913/LeetCode/tree/master/0954-maximum-sum-circular-subarray) |
+## Greedy
+|  |
+| ------- |
+| [0011-container-with-most-water](https://github.com/Devn913/LeetCode/tree/master/0011-container-with-most-water) |
+| [0045-jump-game-ii](https://github.com/Devn913/LeetCode/tree/master/0045-jump-game-ii) |
+| [0055-jump-game](https://github.com/Devn913/LeetCode/tree/master/0055-jump-game) |
+| [0402-remove-k-digits](https://github.com/Devn913/LeetCode/tree/master/0402-remove-k-digits) |
+| [0435-non-overlapping-intervals](https://github.com/Devn913/LeetCode/tree/master/0435-non-overlapping-intervals) |
+| [0768-partition-labels](https://github.com/Devn913/LeetCode/tree/master/0768-partition-labels) |
+| [1652-minimum-suffix-flips](https://github.com/Devn913/LeetCode/tree/master/1652-minimum-suffix-flips) |
+| [2681-put-marbles-in-bags](https://github.com/Devn913/LeetCode/tree/master/2681-put-marbles-in-bags) |
+| [3001-apply-operations-to-maximize-score](https://github.com/Devn913/LeetCode/tree/master/3001-apply-operations-to-maximize-score) |
+## Sliding Window
+|  |
+| ------- |
+| [0003-longest-substring-without-repeating-characters](https://github.com/Devn913/LeetCode/tree/master/0003-longest-substring-without-repeating-characters) |
+| [0076-minimum-window-substring](https://github.com/Devn913/LeetCode/tree/master/0076-minimum-window-substring) |
+| [0187-repeated-dna-sequences](https://github.com/Devn913/LeetCode/tree/master/0187-repeated-dna-sequences) |
+| [0209-minimum-size-subarray-sum](https://github.com/Devn913/LeetCode/tree/master/0209-minimum-size-subarray-sum) |
+| [0239-sliding-window-maximum](https://github.com/Devn913/LeetCode/tree/master/0239-sliding-window-maximum) |
+| [0424-longest-repeating-character-replacement](https://github.com/Devn913/LeetCode/tree/master/0424-longest-repeating-character-replacement) |
+| [0480-sliding-window-median](https://github.com/Devn913/LeetCode/tree/master/0480-sliding-window-median) |
+| [0713-subarray-product-less-than-k](https://github.com/Devn913/LeetCode/tree/master/0713-subarray-product-less-than-k) |
+| [0966-binary-subarrays-with-sum](https://github.com/Devn913/LeetCode/tree/master/0966-binary-subarrays-with-sum) |
+| [1034-subarrays-with-k-different-integers](https://github.com/Devn913/LeetCode/tree/master/1034-subarrays-with-k-different-integers) |
+| [1460-number-of-substrings-containing-all-three-characters](https://github.com/Devn913/LeetCode/tree/master/1460-number-of-substrings-containing-all-three-characters) |
+| [2255-minimum-swaps-to-group-all-1s-together-ii](https://github.com/Devn913/LeetCode/tree/master/2255-minimum-swaps-to-group-all-1s-together-ii) |
+| [2394-count-subarrays-with-score-less-than-k](https://github.com/Devn913/LeetCode/tree/master/2394-count-subarrays-with-score-less-than-k) |
+| [2463-minimum-recolors-to-get-k-consecutive-black-blocks](https://github.com/Devn913/LeetCode/tree/master/2463-minimum-recolors-to-get-k-consecutive-black-blocks) |
+| [2478-longest-nice-subarray](https://github.com/Devn913/LeetCode/tree/master/2478-longest-nice-subarray) |
+| [3213-count-subarrays-where-max-element-appears-at-least-k-times](https://github.com/Devn913/LeetCode/tree/master/3213-count-subarrays-where-max-element-appears-at-least-k-times) |
+| [3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i](https://github.com/Devn913/LeetCode/tree/master/3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i) |
+| [3483-alternating-groups-ii](https://github.com/Devn913/LeetCode/tree/master/3483-alternating-groups-ii) |
+| [3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii](https://github.com/Devn913/LeetCode/tree/master/3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii) |
+## Bucket Sort
+|  |
+| ------- |
+| [0347-top-k-frequent-elements](https://github.com/Devn913/LeetCode/tree/master/0347-top-k-frequent-elements) |
+| [0451-sort-characters-by-frequency](https://github.com/Devn913/LeetCode/tree/master/0451-sort-characters-by-frequency) |
+## Quickselect
+|  |
+| ------- |
+| [0215-kth-largest-element-in-an-array](https://github.com/Devn913/LeetCode/tree/master/0215-kth-largest-element-in-an-array) |
+| [0347-top-k-frequent-elements](https://github.com/Devn913/LeetCode/tree/master/0347-top-k-frequent-elements) |
+| [1014-k-closest-points-to-origin](https://github.com/Devn913/LeetCode/tree/master/1014-k-closest-points-to-origin) |
+## Database
+|  |
+| ------- |
+| [0584-find-customer-referee](https://github.com/Devn913/LeetCode/tree/master/0584-find-customer-referee) |
+| [1258-article-views-i](https://github.com/Devn913/LeetCode/tree/master/1258-article-views-i) |
+| [1509-replace-employee-id-with-the-unique-identifier](https://github.com/Devn913/LeetCode/tree/master/1509-replace-employee-id-with-the-unique-identifier) |
+| [1724-customer-who-visited-but-did-not-make-any-transactions](https://github.com/Devn913/LeetCode/tree/master/1724-customer-who-visited-but-did-not-make-any-transactions) |
+| [1827-invalid-tweets](https://github.com/Devn913/LeetCode/tree/master/1827-invalid-tweets) |
+| [1908-recyclable-and-low-fat-products](https://github.com/Devn913/LeetCode/tree/master/1908-recyclable-and-low-fat-products) |
+## Number Theory
+|  |
+| ------- |
+| [2307-replace-non-coprime-numbers-in-array](https://github.com/Devn913/LeetCode/tree/master/2307-replace-non-coprime-numbers-in-array) |
+| [2610-closest-prime-numbers-in-range](https://github.com/Devn913/LeetCode/tree/master/2610-closest-prime-numbers-in-range) |
+| [3001-apply-operations-to-maximize-score](https://github.com/Devn913/LeetCode/tree/master/3001-apply-operations-to-maximize-score) |
+## Shortest Path
+|  |
+| ------- |
+| [2090-number-of-ways-to-arrive-at-destination](https://github.com/Devn913/LeetCode/tree/master/2090-number-of-ways-to-arrive-at-destination) |
+## Rolling Hash
+|  |
+| ------- |
+| [0187-repeated-dna-sequences](https://github.com/Devn913/LeetCode/tree/master/0187-repeated-dna-sequences) |
+## Hash Function
+|  |
+| ------- |
+| [0187-repeated-dna-sequences](https://github.com/Devn913/LeetCode/tree/master/0187-repeated-dna-sequences) |
+## Memoization
+|  |
+| ------- |
+| [0070-climbing-stairs](https://github.com/Devn913/LeetCode/tree/master/0070-climbing-stairs) |
+## Geometry
+|  |
+| ------- |
+| [0149-max-points-on-a-line](https://github.com/Devn913/LeetCode/tree/master/0149-max-points-on-a-line) |
+| [1014-k-closest-points-to-origin](https://github.com/Devn913/LeetCode/tree/master/1014-k-closest-points-to-origin) |
+## Merge Sort
+|  |
+| ------- |
+| [0023-merge-k-sorted-lists](https://github.com/Devn913/LeetCode/tree/master/0023-merge-k-sorted-lists) |
+## Ordered Set
+|  |
+| ------- |
+| [2429-design-a-food-rating-system](https://github.com/Devn913/LeetCode/tree/master/2429-design-a-food-rating-system) |
+<!---LeetCode Topics End-->
\ No newline at end of file
diff --git a/leetcode/leetcode/Rearrange a linked list - GFG/README.md b/leetcode/leetcode/Rearrange a linked list - GFG/README.md
new file mode 100644
index 0000000..87bd66f
--- /dev/null
+++ b/leetcode/leetcode/Rearrange a linked list - GFG/README.md	
@@ -0,0 +1,40 @@
+# Rearrange a linked list
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a singly linked list, the task is to rearrange it in a way that all odd position nodes are together and all even positions node are together.<br>
+Assume the first element to be at position 1 followed by second element at position 2 and so on.<br>
+<strong>Note: </strong>You should place all odd positioned nodes first and then the even positioned ones. (considering 1 based indexing). Also, the relative order of odd positioned nodes and even positioned nodes should be maintained.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>LinkedList: 1-&gt;2-&gt;3-&gt;4
+<strong>Output: </strong>1 3 2 4 
+<strong>Explanation: </strong>
+Odd elements are 1, 3 and even elements are 
+2, 4. Hence, resultant linked list is 
+1-&gt;3-&gt;2-&gt;4.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>LinkedList: 1-&gt;2-&gt;3-&gt;4-&gt;5
+<strong>Output: </strong>1 3 5 2 4 
+<strong>Explanation:</strong> 
+Odd elements are 1, 3, 5 and even elements are
+2, 4. Hence, resultant linked list is
+​1-&gt;3-&gt;5-&gt;2-&gt;4.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+The task is to complete the function&nbsp;<strong>rearrangeEvenOdd</strong>() which rearranges the nodes in the linked list as required and doesn't return <strong>anything</strong>.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ Size of the linked list&nbsp;≤ 10<sup>4</sup><br>
+0 ≤ value of linked list ≤ 10<sup>3</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Rearrange a linked list - GFG/rearrange-a-linked-list.java b/leetcode/leetcode/Rearrange a linked list - GFG/rearrange-a-linked-list.java
new file mode 100644
index 0000000..16518b2
--- /dev/null
+++ b/leetcode/leetcode/Rearrange a linked list - GFG/rearrange-a-linked-list.java	
@@ -0,0 +1,81 @@
+// { Driver Code Starts
+import java.util.*;
+import java.io.*;
+
+class Node{
+    int data;
+    Node next;
+    
+    Node(int x){
+        data = x;
+        next = null;
+    }
+    
+}
+class GFG{
+	static void printList(Node node) 
+	{ 
+		while (node != null) 
+		{ 
+			System.out.print(node.data + " "); 
+			node = node.next; 
+		} 
+		System.out.println(); 
+	}
+    public static void main(String args[]) throws IOException { 
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t > 0){
+        	int n = sc.nextInt();
+            Node head = new Node(sc.nextInt());
+            Node tail = head;
+            for(int i=0; i<n-1; i++)
+            {
+                tail.next = new Node(sc.nextInt());
+                tail = tail.next;
+            }
+            new Solution().rearrangeEvenOdd(head);
+            printList(head); 
+            t--;
+        }
+    } 
+} 
+// } Driver Code Ends
+
+
+/*
+
+class Node {
+
+    int data;
+    Node next;
+
+    Node(int d) {
+        data = d;
+        next = null;
+    }
+}
+This is method only submission.
+You only need to complete the below method.
+*/
+class Solution
+{
+
+   // Should rearrange given linked list such that all even
+   // positioned Nodes are before odd positioned.
+   // Returns nothing
+    void rearrangeEvenOdd(Node head)
+    {
+          if(head == null || head.next == null) return;
+          Node head2 = head.next;
+          Node temp = head;
+          Node temp2 = head.next;
+          while(temp2!=null && temp2.next!=null && temp!=null){
+              temp.next = temp2.next;
+              temp2.next = temp2.next.next;
+              temp = temp.next;
+              temp2 = temp2.next;
+          }
+          temp.next = head2;
+    }
+}
diff --git a/leetcode/leetcode/Remove loop in Linked List - GFG/README.md b/leetcode/leetcode/Remove loop in Linked List - GFG/README.md
new file mode 100644
index 0000000..ce0df8f
--- /dev/null
+++ b/leetcode/leetcode/Remove loop in Linked List - GFG/README.md	
@@ -0,0 +1,67 @@
+# Remove loop in Linked List
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a linked list of <strong>N</strong> nodes such that it may contain a loop. </span></p>
+
+<blockquote>
+<p><span style="font-size:18px">A loop here means that the last node of the link list is connected to the node at position X. If the link list does not have any loop, X=0.</span></p>
+</blockquote>
+
+<p><span style="font-size:18px">Remove the loop from the linked list, if it is present. </span>&nbsp;</p>
+
+<p><br>
+<strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:
+</span></strong><span style="font-size:18px">N = 3
+value[] = {1,3,4}
+X = 2
+<strong>Output: </strong>1<strong>
+Explanation: </strong>The link list looks like<strong>
+</strong>1 -&gt; 3 -&gt; 4
+     ^    |
+     |____|    
+A loop is present. If you remove it 
+successfully, the answer will be 1. </span>
+</pre>
+
+<p><br>
+<strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:
+</span></strong><span style="font-size:18px">N = 4
+value[] = {1,8,3,4}
+X = 0
+<strong>Output: </strong>1<strong>
+Explanation: </strong>The&nbsp;Linked list does not 
+contains any loop. </span></pre>
+
+<p><br>
+<strong><span style="font-size:18px">Example 3:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:
+</span></strong><span style="font-size:18px">N = 4
+value[] = {1,2,3,4}
+X = 1
+<strong>Output: </strong>1<strong>
+Explanation: </strong>The link list looks like<strong> 
+</strong>1 -&gt; 2 -&gt; 3 -&gt; 4
+|______________|
+A loop is present. 
+If you remove it successfully, 
+the answer will be 1. </span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your&nbsp;Task:</strong><br>
+You don't need to read input or print anything.&nbsp;Your task is to&nbsp;complete the function <strong>removeLoop</strong>() which takes the&nbsp;head of the linked list as the input parameter. Simply remove the loop in the list (if present) without disconnecting any nodes from the list.<br>
+<strong>Note: </strong>The generated output&nbsp;will be&nbsp;<strong>1&nbsp;</strong>if your submitted code is correct.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected time complexity:</strong> O(N)</span><br>
+<span style="font-size:18px"><strong>Expected auxiliary space:&nbsp;</strong>O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>4</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Remove loop in Linked List - GFG/remove-loop-in-linked-list.java b/leetcode/leetcode/Remove loop in Linked List - GFG/remove-loop-in-linked-list.java
new file mode 100644
index 0000000..eab028b
--- /dev/null
+++ b/leetcode/leetcode/Remove loop in Linked List - GFG/remove-loop-in-linked-list.java	
@@ -0,0 +1,131 @@
+// { Driver Code Starts
+// driver code
+
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+
+class Node
+{
+    int data;
+    Node next;
+}
+
+class GFG
+{
+    public static Node newNode(int data){
+        Node temp = new Node();
+        temp.data = data;
+        temp.next = null;
+        return temp;
+    }
+    
+    public static void makeLoop(Node head, int x){
+        if (x == 0)
+            return;
+        Node curr = head;
+        Node last = head;
+
+        int currentPosition = 1;
+        while (currentPosition < x)
+        {
+            curr = curr.next;
+            currentPosition++;
+        }
+        
+        while (last.next != null)
+            last = last.next;
+        last.next = curr;
+    }
+    
+    public static boolean detectLoop(Node head){
+        Node hare = head.next;
+        Node tortoise = head;
+        while( hare != tortoise )
+        {
+            if(hare==null || hare.next==null) return false;
+            hare = hare.next.next;
+            tortoise = tortoise.next;
+        }
+        return true;
+    }
+    
+    public static int length(Node head){
+        int ret=0;
+        while(head!=null)
+        {
+            ret += 1;
+            head = head.next;
+        }
+        return ret;
+    }
+    
+    public static void main (String[] args){
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while(t--> 0)
+        {
+            int n = sc.nextInt();
+            
+            int num = sc.nextInt();
+            Node head = newNode(num);
+            Node tail = head;
+            
+            for(int i=0; i<n-1; i++)
+            {
+                num = sc.nextInt();
+                tail.next = newNode(num);
+                tail = tail.next;
+            }
+            
+            int pos = sc.nextInt();
+            makeLoop(head, pos);
+            
+            Solution x = new Solution();
+            x.removeLoop(head);
+            
+            if( detectLoop(head) || length(head)!=n )
+                System.out.println("0");
+            else
+                System.out.println("1");
+        }
+    }
+}
+// } Driver Code Ends
+
+
+/*
+class Node
+{
+    int data;
+    Node next;
+}
+*/
+
+class Solution
+{
+    //Function to remove a loop in the linked list.
+    public static void removeLoop(Node head){
+        // code here
+        // remove the loop without losing any nodes
+        Node slow = head;
+        Node fast = head;
+        Node prev = null;
+        while(fast!=null && fast.next!=null){
+            prev = slow;
+            slow = slow.next;
+            fast = fast.next.next;
+            if(slow == fast){
+                slow = head;
+                while(slow!=fast){
+                    prev = fast;
+                    slow = slow.next;
+                    fast = fast.next;
+                }
+                prev.next = null;
+                
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Rotate Array - GFG/README.md b/leetcode/leetcode/Rotate Array - GFG/README.md
new file mode 100644
index 0000000..002de89
--- /dev/null
+++ b/leetcode/leetcode/Rotate Array - GFG/README.md	
@@ -0,0 +1,43 @@
+# Rotate Array
+## Easy
+<div class="problems_problem_content__Xm_eO"><p><span style="font-size:18px">Given an unsorted array <strong>arr[]</strong> of size <strong>N.</strong>&nbsp;Rotate the array to the left (counter-clockwise direction) by <strong>D</strong> steps, where&nbsp;<strong>D</strong>&nbsp;is a positive integer.&nbsp;</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 5, D = 2
+arr[] = {1,2,3,4,5}
+<strong>Output: </strong>3 4 5 1 2<strong>
+</strong><strong>Explanation: </strong>1 2 3 4 5&nbsp; when rotated
+by 2 elements, it becomes 3 4 5 1 2.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 10, D = 3
+arr[] = {2,4,6,8,10,12,14,16,18,20}
+<strong>Output: </strong>8 10 12 14 16 18 20 2 4 6<strong>
+Explanation: </strong>2 4 6 8 10 12 14 16 18 20&nbsp;
+when rotated by 3 elements, it becomes 
+8 10 12 14 16 18 20 2 4 6.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your&nbsp;Task:</strong><br>
+Complete the function <strong>rotateArr</strong>() which takes the array, D and N as input parameters and&nbsp;rotates the array by D elements. The array must be modified in-place without using extra space.&nbsp;</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N)<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1)</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 10</span><sup><span style="font-size:15px">6</span></sup><br>
+<span style="font-size:18px">1 &lt;= D &lt;= 10<sup>6</sup></span><br>
+<span style="font-size:18px">0 &lt;=&nbsp;arr[i] &lt;= 10</span><sup>5</sup></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Rotate Array - GFG/rotate-array.c b/leetcode/leetcode/Rotate Array - GFG/rotate-array.c
new file mode 100644
index 0000000..f5fe3a0
--- /dev/null
+++ b/leetcode/leetcode/Rotate Array - GFG/rotate-array.c	
@@ -0,0 +1,58 @@
+//{ Driver Code Starts
+#include<stdio.h>
+
+
+// } Driver Code Ends
+//User function Template for C
+
+//Function to rotate an array by d elements in counter-clockwise direction.
+void swap(int arr[], int i, int j){
+    int temp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = temp;
+}
+void reverse(int arr[], int start, int end){
+    while(start<end){
+        swap(arr,start++,end--);
+    }
+}
+
+void rotateArr(int arr[], int d, int n){
+    if(d == n) return;
+    if(d>n) d = d%n;
+    reverse(arr,0,n-1);
+    reverse(arr,0,n-d-1);
+    reverse(arr,n-d,n-1);
+}
+
+//{ Driver Code Starts.
+
+int main() {
+	int t;
+	//taking testcases
+	scanf("%d",&t);
+	
+	while(t--){
+	    int n, d;
+	    
+	    //input n and d
+	    scanf("%d%d",&n, &d);
+	    
+	    int arr[n];
+	    
+	    //inserting elements in the array
+	    for(int i = 0; i < n; i++){
+	        scanf("%d",&arr[i]);
+	    }
+	    //calling rotateArr() function
+	    rotateArr(arr, d,n);
+	    
+	    //printing the elements of the array
+	    for(int i =0;i<n;i++){
+	        printf("%d ",arr[i]);
+	    }
+	    printf("\n");
+	}
+	return 0;
+}
+// } Driver Code Ends
\ No newline at end of file
diff --git a/leetcode/leetcode/Rotate a Linked List - GFG/README.md b/leetcode/leetcode/Rotate a Linked List - GFG/README.md
new file mode 100644
index 0000000..4b5be96
--- /dev/null
+++ b/leetcode/leetcode/Rotate a Linked List - GFG/README.md	
@@ -0,0 +1,39 @@
+# Rotate a Linked List
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a singly linked list of size <strong>N</strong>. The task is to <strong>left-shift</strong> the linked list by <strong>k</strong> nodes, where <strong>k</strong> is a given positive integer smaller than or equal to length of the linked list. </span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 5
+value[] = {2, 4, 7, 8, 9}
+k = 3
+<strong>Output: </strong>8 9 2 4 7<strong>
+Explanation:</strong></span>
+<span style="font-size:18px"><strong>Rotate 1:&nbsp;</strong>4 -&gt; 7 -&gt; 8 -&gt; 9 -&gt; 2</span>
+<span style="font-size:18px"><strong>Rotate 2:</strong>&nbsp;7&nbsp;-&gt; 8&nbsp;-&gt; 9&nbsp;-&gt; 2&nbsp;-&gt; 4</span>
+<span style="font-size:18px"><strong>Rotate 3:</strong>&nbsp;8&nbsp;-&gt; 9&nbsp;-&gt; 2&nbsp;-&gt; 4&nbsp;-&gt; 7</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 8
+value[] = {1, 2, 3, 4, 5, 6, 7, 8}
+k = 4
+<strong>Output: </strong>5 6 7 8 1 2 3 4</span>
+</pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Your task is to complete the function <strong>rotate</strong>() which takes a&nbsp;<strong>head </strong>reference as the <strong>first argument </strong>and <strong>k</strong> as the <strong>second argument,&nbsp;</strong>and returns the head of the rotated linked list.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 10<sup>3</sup><br>
+1 &lt;= k &lt;= N</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Rotate a Linked List - GFG/rotate-a-linked-list.java b/leetcode/leetcode/Rotate a Linked List - GFG/rotate-a-linked-list.java
new file mode 100644
index 0000000..994110a
--- /dev/null
+++ b/leetcode/leetcode/Rotate a Linked List - GFG/rotate-a-linked-list.java	
@@ -0,0 +1,92 @@
+// { Driver Code Starts
+import java.util.*;
+class Node {
+    int data;
+    Node next;
+    Node(int d) {
+        data = d;
+        next = null;
+    }
+} 
+
+class Main {
+    public static void main(String[] args) {
+        
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        
+        while (t-- > 0) {
+            int n = sc.nextInt();
+            
+            int a = sc.nextInt();
+            Node head = new Node(a);
+            Node tail = head;
+            
+            for (int i=0; i<n-1; i++)
+            {
+                a = sc.nextInt();
+                tail.next = new Node(a);
+                tail = tail.next;
+            }
+            
+            int k = sc.nextInt();
+            
+            Solution ob = new Solution();
+            head = ob.rotate(head,k);
+            printList(head);
+        }
+    }
+    
+    public static void printList(Node n) {
+        while (n != null) {
+            System.out.print(n.data + " ");
+            n = n.next;
+        }
+        System.out.println();
+    }
+}
+// } Driver Code Ends
+
+
+/* node of linked list:
+
+class Node{
+    int data;
+    Node next;
+    Node(int d){
+        data=d;
+        next=null;
+    }
+}
+
+*/
+
+class Solution{
+    //Function to rotate a linked list.
+    public Node rotate(Node head, int k) {
+        // add code here
+        int size = 0;
+        Node temp = head;
+        Node tail = null;
+        while(temp!=null){
+            tail = temp;
+            temp = temp.next;
+            size++;
+        }
+        if(k == size) return head;
+        if(k>size){
+            k = k%size;
+        } 
+        temp = head;
+        
+        while(k!=1){
+            temp = temp.next;
+            k--;
+        }
+        tail.next = head;
+        head = temp.next;
+        temp.next = null;
+        return head;
+        
+    }
+}
diff --git a/leetcode/leetcode/Subset Sum Problem - GFG/subset-sum-problem.java b/leetcode/leetcode/Subset Sum Problem - GFG/subset-sum-problem.java
new file mode 100644
index 0000000..6643615
--- /dev/null
+++ b/leetcode/leetcode/Subset Sum Problem - GFG/subset-sum-problem.java	
@@ -0,0 +1,55 @@
+// { Driver Code Starts
+import java.io.*;
+import java.util.*;
+
+class GFG
+{
+    public static void main(String args[])throws IOException
+    {
+        BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
+        int t = Integer.parseInt(read.readLine());
+        while(t-- > 0)
+        {
+            int N = Integer.parseInt(read.readLine());
+            String input_line[] = read.readLine().trim().split("\\s+");
+            int arr[]= new int[N];
+            for(int i = 0; i < N; i++)
+                arr[i] = Integer.parseInt(input_line[i]);
+            int sum = Integer.parseInt(read.readLine());
+
+            Solution ob = new Solution();
+            if(ob.isSubsetSum(N, arr, sum))
+            System.out.println(1);
+            else
+            System.out.println(0);
+
+            
+        }
+    }
+}
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+class Solution{
+
+
+    static Boolean isSubsetSum(int N, int arr[], int sum){
+        boolean dp[][] = new boolean[N+1][sum+1];
+        for(int i = 0;i<=sum;i++) dp[0][i] = false;
+        for(int i =0;i<=N;i++) dp[i][0] = true;
+        for(int i = 1;i<=N;i++){
+            for(int j = 1;j<=sum;j++){
+                dp[i][j] =  dp[i-1][j];
+                if(!dp[i][j]){
+                    int val = arr[i-1];
+                    if(val<=j){
+                        dp[i][j] = dp[i-1][j-val];
+                    }
+                }
+            }
+        }
+        return dp[N][sum];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Sum Tree - GFG/README.md b/leetcode/leetcode/Sum Tree - GFG/README.md
new file mode 100644
index 0000000..060ec95
--- /dev/null
+++ b/leetcode/leetcode/Sum Tree - GFG/README.md	
@@ -0,0 +1,55 @@
+# Sum Tree
+## Medium 
+<div class="problem-statement">
+                <p></p><div class="entry-content">
+<p><span style="font-size:18px">Given a Binary Tree. Return <strong>true</strong>&nbsp;if, for every node <strong>X</strong>&nbsp;in the tree other than the&nbsp;leaves, its value is equal to the sum of its left subtree's value and its right subtree's value. Else return <strong>false</strong>.</span></p>
+
+<p><span style="font-size:18px">An empty tree is also a Sum Tree as the sum of an empty tree can be considered to be 0. A leaf node is also considered a Sum Tree.</span></p>
+
+<p><br>
+<strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+    3
+  /   \    
+ 1     2</span>
+
+<span style="font-size:18px"><strong>Output:</strong> 1</span>
+<span style="font-size:18px"><strong>Explanation:
+</strong>The sum of left subtree and right subtree is
+1 + 2 = 3, which is the value of the root node.
+Therefore,the given binary tree is a <strong>sum tree</strong>.</span>
+</pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><strong><span style="font-size:18px">Input:</span></strong>
+
+<span style="font-size:18px">          10
+        /    \
+      20      30
+    /   \ 
+   10    10</span>
+
+<span style="font-size:18px"><strong>Output: </strong>0</span>
+<span style="font-size:18px"><strong>Explanation:
+</strong>The given tree is not a sum tree.
+For the root node, sum of elements
+in left subtree is 40 and sum of elements
+in right subtree is 30. Root element = 10
+which is not equal to 30+40.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:&nbsp; </strong><br>
+You don't need to read input or print anything. Complete the function <strong>isSumTree() </strong>which takes <strong>root </strong>node as input parameter and returns true if the tree is a SumTree else it returns false.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity: </strong>O(N)<br>
+<strong>Expected Auxiliary Space:</strong> O(Height of the Tree</span><span style="font-size:18px">)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ number of nodes ≤ 10<sup>4</sup></span></p>
+</div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Sum Tree - GFG/sum-tree.java b/leetcode/leetcode/Sum Tree - GFG/sum-tree.java
new file mode 100644
index 0000000..27a58f3
--- /dev/null
+++ b/leetcode/leetcode/Sum Tree - GFG/sum-tree.java	
@@ -0,0 +1,146 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+class GfG {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t > 0){
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+        	    Solution g = new Solution();
+			
+			    if(g.isSumTree(root) == true)
+    			    System.out.println(1);
+    			else 
+    			    System.out.println(0);
+                t--;
+            
+        }
+    }
+  
+}
+
+// } Driver Code Ends
+
+
+/* A Binary Tree node
+class Node
+{
+    int data;
+    Node left, right;
+
+    Node(int item)
+    {
+        data = item;
+        left = right = null;
+    }
+}
+*/
+class Solution
+{
+    class pair{
+        boolean isSumTree;
+        int sum;
+        boolean isNull;
+        pair(boolean isSumTree, int sum,boolean isNull){
+            this.isSumTree = isSumTree;
+            this.sum = sum;
+            this.isNull = isNull;
+        }
+    }
+    pair helper(Node root){
+        if(root == null){
+            return new pair(true,0,true);
+        }
+        pair left = helper(root.left);
+        pair right = helper(root.right);
+        if(left.isSumTree && right.isSumTree){
+            if(left.isNull && right.isNull) return new pair(true,root.data,false);
+            else if(root.data == left.sum + right.sum){
+                return new pair(true,root.data+left.sum+right.sum,false);
+            }
+        }
+        return new pair(false,0,false);
+    }
+	boolean isSumTree(Node root)
+	{
+	    return helper(root).isSumTree;
+	}
+}
diff --git a/leetcode/leetcode/Top View of Binary Tree - GFG/README.md b/leetcode/leetcode/Top View of Binary Tree - GFG/README.md
new file mode 100644
index 0000000..ebbc921
--- /dev/null
+++ b/leetcode/leetcode/Top View of Binary Tree - GFG/README.md	
@@ -0,0 +1,48 @@
+# Top View of Binary Tree
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given below is a binary tree. The task is to print the top view of binary tree. Top view of a binary tree is the set of nodes visible when the tree is viewed from the top. For the given below tree</span></p>
+
+<p><span style="font-size:18px">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 1<br>
+&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp;&nbsp;&nbsp; \<br>
+&nbsp;&nbsp; 2&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 3<br>
+&nbsp; /&nbsp; \&nbsp;&nbsp;&nbsp; /&nbsp;&nbsp; \<br>
+4&nbsp;&nbsp;&nbsp; 5&nbsp; 6&nbsp;&nbsp; 7</span></p>
+
+<p><span style="font-size:18px">Top view will be: 4 2 1 3 7<br>
+<strong>Note: </strong>Return nodes from <strong>leftmost </strong>node to <strong>rightmost </strong>node.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>&nbsp;     1
+  &nbsp;/&nbsp;&nbsp;&nbsp; \
+  2&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 3
+<strong>Output: </strong>2 1 3<strong>
+</strong></span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>&nbsp;      10
+ &nbsp;&nbsp; /&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; \
+  20&nbsp; &nbsp;&nbsp;&nbsp; &nbsp; 30
+ /&nbsp;&nbsp; \&nbsp;&nbsp;&nbsp;&nbsp;/&nbsp; &nbsp;&nbsp;\
+40&nbsp;&nbsp; 60  90&nbsp; &nbsp;&nbsp;100
+<strong>Output: </strong>40 20 10 30 100
+</span></pre>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong><br>
+<span style="font-size:18px">Since this is a function problem. You don't have to take input. Just complete the function<strong>&nbsp;topView() </strong>that takes <strong>root node </strong>as parameter and returns a list of nodes visible from the top view from left to right.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N)<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(N).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤&nbsp;N ≤&nbsp;10<sup>5</sup><br>
+1 ≤ Node Data ≤&nbsp;10<sup>5</sup></span><br>
+&nbsp;</p>
+
+<p><strong>Note:</strong>The <strong>Input/Ouput</strong> format and <strong>Example </strong>given are used for system's internal purpose, and should be used by a user for <strong>Expected Output </strong>only. As it is a function problem, hence a user should not read any input from stdin/console. The task is to complete the function specified, and not to write the full code.</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Top View of Binary Tree - GFG/top-view-of-binary-tree.java b/leetcode/leetcode/Top View of Binary Tree - GFG/top-view-of-binary-tree.java
new file mode 100644
index 0000000..4a13593
--- /dev/null
+++ b/leetcode/leetcode/Top View of Binary Tree - GFG/top-view-of-binary-tree.java	
@@ -0,0 +1,163 @@
+// { Driver Code Starts
+//Initial Template for JAVA
+
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+public class Tree {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    static void printInorder(Node root)
+    {
+        if(root == null)
+            return;
+            
+        printInorder(root.left);
+        System.out.print(root.data+" ");
+        
+        printInorder(root.right);
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t > 0){
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+    	    	
+                Solution ob = new Solution();
+
+                ArrayList<Integer> vec = ob.topView(root);
+                for(int x : vec)
+                    System.out.print(x + " ");
+                System.out.println();
+        	
+                t--;   
+        }
+    }
+}// } Driver Code Ends
+
+
+//User function Template for Java
+
+/*
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+*/
+
+class Solution
+{
+    static class pair{
+        Node root;
+        int level;
+        pair(Node root1, int level1){
+            root = root1;
+            level = level1;
+        }
+    }
+    //Function to return a list of nodes visible from the top view 
+    //from left to right in Binary Tree.
+    static ArrayList<Integer> topView(Node root)
+    {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int minLevel = 0;
+        int maxLevel = 0;
+        Queue<pair> q = new LinkedList<>();
+        q.add(new pair(root,0));
+        while(!q.isEmpty()){
+            pair front = q.remove();
+            minLevel = Math.min(minLevel,front.level);
+            maxLevel = Math.max(maxLevel,front.level);
+            if(!map.containsKey(front.level)){
+                map.put(front.level,front.root.data);
+            }
+            if(front.root.left!=null) q.add(new pair(front.root.left,front.level -1));
+            if(front.root.right!=null) q.add(new pair(front.root.right,front.level +1));
+        }
+        ArrayList<Integer> list = new ArrayList<>();
+        while(minLevel<=maxLevel){
+            list.add(map.get(minLevel));
+            minLevel++;
+        }
+        return list;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Trailing zeroes in factorial - GFG/README.md b/leetcode/leetcode/Trailing zeroes in factorial - GFG/README.md
new file mode 100644
index 0000000..e6d7703
--- /dev/null
+++ b/leetcode/leetcode/Trailing zeroes in factorial - GFG/README.md	
@@ -0,0 +1,33 @@
+# Trailing zeroes in factorial
+##  Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">For an integer <strong>N</strong>&nbsp;find the number of trailing zeroes in <strong>N!.</strong></span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 5</span>
+<span style="font-size:18px"><strong>Output:
+</strong>1</span>
+<span style="font-size:18px"><strong>Explanation:
+</strong>5! = 120 so the number of trailing zero is 1.</span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 4</span>
+<span style="font-size:18px"><strong>Output:
+</strong></span><span style="font-size:18px">0</span>
+<span style="font-size:18px"><strong>Explanation:
+</strong>4! = 24 so the number of trailing zero is 0.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:&nbsp;&nbsp;</strong><br>
+You don't need to read input or print anything. Your task is to complete the function&nbsp;<strong>trailingZeroes()</strong>&nbsp;which take an integer N as an input parameter and returns the count of trailing zeroes in the N!.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(logN)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(1)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N&nbsp;&lt;= 10<sup>9</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Trailing zeroes in factorial - GFG/trailing-zeroes-in-factorial.java b/leetcode/leetcode/Trailing zeroes in factorial - GFG/trailing-zeroes-in-factorial.java
new file mode 100644
index 0000000..a67483a
--- /dev/null
+++ b/leetcode/leetcode/Trailing zeroes in factorial - GFG/trailing-zeroes-in-factorial.java	
@@ -0,0 +1,38 @@
+// { Driver Code Starts
+//Initial Template for Java
+import java.io.*;
+import java.util.*;
+
+class GFG
+{
+    public static void main(String args[])throws IOException
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-- > 0)
+        {
+            int N = sc.nextInt();
+			
+            Solution ob = new Solution();
+            int ans  = ob.trailingZeroes(N);
+            System.out.println(ans);
+        }
+    }
+}
+// } Driver Code Ends
+
+
+//User function Template for Java
+class Solution{
+    static int trailingZeroes(int N){
+        // Write your code here\
+        while(N%5!=0) N--;
+        int result = 0;
+        while(N!=0){
+            result+=(N/5);
+            N = N/5;
+            
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/Transform to Sum Tree - GFG/README.md b/leetcode/leetcode/Transform to Sum Tree - GFG/README.md
new file mode 100644
index 0000000..390fd5a
--- /dev/null
+++ b/leetcode/leetcode/Transform to Sum Tree - GFG/README.md	
@@ -0,0 +1,45 @@
+# Transform to Sum Tree
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a Binary Tree of size N , where each node can have positive or negative values. Convert this to a tree where each node contains the sum of the left and right sub trees of the original tree. The values of leaf nodes are changed to 0.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+             10
+          /      \
+        -2        6
+       /   \     /  \
+     8     -4   7    5</span>
+
+<span style="font-size:18px"><strong>Output:</strong>
+            20
+          /    \
+        4        12
+       /  \     /  \
+     0     0   0    0</span>
+
+<strong><span style="font-size:18px">Explanation:</span></strong>
+
+<span style="font-size:18px">           (4-2+12+6)
+          /           \
+      (8-4)          (7+5)
+       /   \         /  \
+      0     0       0    0</span></pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task: &nbsp;</strong><br>
+You dont need to read input or print anything. Complete the function<strong> toSumTree()</strong> which takes root node as input parameter and modifies the given tree in-place.</span></p>
+
+<p><span style="font-size:18px"><strong>Note:</strong> If you click on Compile and Test the output will be the in-order traversal of the modified tree.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity: </strong>O(N)<br>
+<strong>Expected Auxiliary Space: </strong>O(height of tree)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N&nbsp;≤ 10<sup>4</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Vertical Traversal of Binary Tree - GFG/README.md b/leetcode/leetcode/Vertical Traversal of Binary Tree - GFG/README.md
new file mode 100644
index 0000000..b53b16c
--- /dev/null
+++ b/leetcode/leetcode/Vertical Traversal of Binary Tree - GFG/README.md	
@@ -0,0 +1,43 @@
+# Vertical Traversal of Binary Tree
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a Binary Tree, find the vertical traversal of it starting from the leftmost level to the rightmost level.<br>
+If there are multiple nodes passing through a vertical line, then they should be printed as they appear in <strong>level order</strong> traversal of the tree.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+           1
+         /   \
+       2       3
+     /   \   /   \
+   4      5 6      7
+              \      \
+               8      9           
+</span><span style="font-size:18px"><strong>Output: </strong>
+4 2 1 5 6 3 8 7 9 
+<strong>Explanation:</strong></span>
+<img alt="" src="https://media.geeksforgeeks.org/img-practice/ScreenShot2021-05-28at3-1622541589.png" class="img-responsive">
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+&nbsp;      </strong>1
+ &nbsp; &nbsp;/&nbsp;&nbsp;&nbsp; \
+ &nbsp; 2&nbsp; &nbsp; &nbsp;  3
+ /&nbsp;&nbsp;  \&nbsp; &nbsp; &nbsp;&nbsp;\
+4&nbsp; &nbsp;  &nbsp;5&nbsp; &nbsp;  &nbsp;6
+<strong>Output: </strong>4 2 1 5 3 6<strong>
+</strong></span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Your task is to complete the function&nbsp;<strong>verticalOrder()&nbsp;</strong>which takes the root node as input parameter and returns an array containing&nbsp;the vertical order traversal of the tree from the leftmost to the rightmost level. If 2 nodes lie in the same vertical level, they should be printed in the order they appear in the level order traversal of the tree.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N)<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(N)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= Number of nodes &lt;= 3*10<sup>4</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/leetcode/leetcode/Vertical Traversal of Binary Tree - GFG/vertical-traversal-of-binary-tree.java b/leetcode/leetcode/Vertical Traversal of Binary Tree - GFG/vertical-traversal-of-binary-tree.java
new file mode 100644
index 0000000..56b1450
--- /dev/null
+++ b/leetcode/leetcode/Vertical Traversal of Binary Tree - GFG/vertical-traversal-of-binary-tree.java	
@@ -0,0 +1,147 @@
+// { Driver Code Starts
+//Initial Template for Java
+
+//Contributed by Sudarshan Sharma
+import java.util.LinkedList; 
+import java.util.Queue; 
+import java.io.*;
+import java.util.*;
+
+class Node{
+    int data;
+    Node left;
+    Node right;
+    Node(int data){
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+
+class GfG {
+    
+    static Node buildTree(String str){
+        
+        if(str.length()==0 || str.charAt(0)=='N'){
+            return null;
+        }
+        
+        String ip[] = str.split(" ");
+        // Create the root of the tree
+        Node root = new Node(Integer.parseInt(ip[0]));
+        // Push the root to the queue
+        
+        Queue<Node> queue = new LinkedList<>(); 
+        
+        queue.add(root);
+        // Starting from the second element
+        
+        int i = 1;
+        while(queue.size()>0 && i < ip.length) {
+            
+            // Get and remove the front of the queue
+            Node currNode = queue.peek();
+            queue.remove();
+                
+            // Get the current node's value from the string
+            String currVal = ip[i];
+                
+            // If the left child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the left child for the current node
+                currNode.left = new Node(Integer.parseInt(currVal));
+                // Push it to the queue
+                queue.add(currNode.left);
+            }
+                
+            // For the right child
+            i++;
+            if(i >= ip.length)
+                break;
+                
+            currVal = ip[i];
+                
+            // If the right child is not null
+            if(!currVal.equals("N")) {
+                    
+                // Create the right child for the current node
+                currNode.right = new Node(Integer.parseInt(currVal));
+                    
+                // Push it to the queue
+                queue.add(currNode.right);
+            }
+            i++;
+        }
+        
+        return root;
+    }
+    static void printInorder(Node root)
+    {
+        if(root == null)
+            return;
+            
+        printInorder(root.left);
+        System.out.print(root.data+" ");
+        
+        printInorder(root.right);
+    }
+    
+	public static void main (String[] args) throws IOException{
+	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        
+	        int t=Integer.parseInt(br.readLine());
+    
+	        while(t-- > 0){
+	            String s = br.readLine();
+    	    	Node root = buildTree(s);
+                Solution obj = new Solution();
+                ArrayList <Integer> res = obj.verticalOrder(root);
+                for (Integer num : res) System.out.print(num + " "); 
+                System.out.println();
+    	        
+	        }
+	}
+}
+// } Driver Code Ends
+
+
+//User function Template for Java
+
+
+class Solution
+{
+    //Function to find the vertical order traversal of Binary Tree.
+    static class pair{
+        int level;
+        Node root;
+        pair(Node root,int level){
+            this.root = root;
+            this.level = level;
+        }
+    }
+    static ArrayList <Integer> verticalOrder(Node root)
+    {
+        HashMap<Integer,ArrayList<Integer>> map = new HashMap<>();
+        Queue<pair> q = new LinkedList<>();
+        q.add(new pair(root,0));
+        int min = 0;
+        while(!q.isEmpty()){
+            for(int i = q.size();i!=0;i--){
+                pair p = q.remove();
+                ArrayList<Integer> list = map.getOrDefault(p.level,new ArrayList<Integer>());
+                list.add(p.root.data);
+                map.put(p.level,list);
+                if(p.root.left!=null) q.add(new pair(p.root.left,p.level-1));
+                if(p.root.right!=null) q.add(new pair(p.root.right,p.level+1));
+                min = Math.min(min,p.level);
+            }
+        }
+        ArrayList<Integer> list = new ArrayList<Integer>();
+        while(map.containsKey(min)){
+            list.addAll(map.get(min));
+            min++;
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/a-number-after-a-double-reversal/README.md b/leetcode/leetcode/a-number-after-a-double-reversal/README.md
new file mode 100644
index 0000000..4921eea
--- /dev/null
+++ b/leetcode/leetcode/a-number-after-a-double-reversal/README.md
@@ -0,0 +1,38 @@
+[Discussion Post (created on 26/11/2021 at 15:3)](https://leetcode.com/problems/a-number-after-a-double-reversal/discuss/1648216/JAVA-100-FAST)  
+<h2>2119. A Number After a Double Reversal</h2><h3>Easy</h3><hr><div><p><strong>Reversing</strong> an integer means to reverse all its digits.</p>
+
+<ul>
+	<li>For example, reversing <code>2021</code> gives <code>1202</code>. Reversing <code>12300</code> gives <code>321</code> as the <strong>leading zeros are not retained</strong>.</li>
+</ul>
+
+<p>Given an integer <code>num</code>, <strong>reverse</strong> <code>num</code> to get <code>reversed1</code>, <strong>then reverse</strong> <code>reversed1</code> to get <code>reversed2</code>. Return <code>true</code> <em>if</em> <code>reversed2</code> <em>equals</em> <code>num</code>. Otherwise return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 526
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Reverse num to get 625, then reverse 625 to get 526, which equals num.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = 1800
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Reverse num to get 81, then reverse 81 to get 18, which does not equal num.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> num = 0
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Reverse num to get 0, then reverse 0 to get 0, which equals num.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= num &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/a-number-after-a-double-reversal/a-number-after-a-double-reversal.java b/leetcode/leetcode/a-number-after-a-double-reversal/a-number-after-a-double-reversal.java
new file mode 100644
index 0000000..9dc6f87
--- /dev/null
+++ b/leetcode/leetcode/a-number-after-a-double-reversal/a-number-after-a-double-reversal.java
@@ -0,0 +1,7 @@
+class Solution {
+    public boolean isSameAfterReversals(int num) {
+        if(num == 0) return true;
+        if(num%10==0) return false;
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/add-digits/README.md b/leetcode/leetcode/add-digits/README.md
new file mode 100644
index 0000000..46da928
--- /dev/null
+++ b/leetcode/leetcode/add-digits/README.md
@@ -0,0 +1,29 @@
+<h2>258. Add Digits</h2><h3>Easy</h3><hr><div><p>Given an integer <code>num</code>, repeatedly add all its digits until the result has only one digit, and return it.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 38
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The process is
+38 --&gt; 3 + 8 --&gt; 11
+11 --&gt; 1 + 1 --&gt; 2 
+Since 2 has only one digit, return it.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = 0
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= num &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you do it without any loop/recursion in <code>O(1)</code> runtime?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/add-digits/add-digits.java b/leetcode/leetcode/add-digits/add-digits.java
new file mode 100644
index 0000000..530f023
--- /dev/null
+++ b/leetcode/leetcode/add-digits/add-digits.java
@@ -0,0 +1,6 @@
+class Solution {
+    public int addDigits(int num) {
+            return 1 + (num - 1) % 9;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/add-two-numbers-ii/README.md b/leetcode/leetcode/add-two-numbers-ii/README.md
new file mode 100644
index 0000000..72c2721
--- /dev/null
+++ b/leetcode/leetcode/add-two-numbers-ii/README.md
@@ -0,0 +1,35 @@
+<h2>445. Add Two Numbers II</h2><h3>Medium</h3><hr><div><p>You are given two <strong>non-empty</strong> linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.</p>
+
+<p>You may assume the two numbers do not contain any leading zero, except the number 0 itself.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/04/09/sumii-linked-list.jpg" style="width: 523px; height: 342px;">
+<pre><strong>Input:</strong> l1 = [7,2,4,3], l2 = [5,6,4]
+<strong>Output:</strong> [7,8,0,7]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> l1 = [2,4,3], l2 = [5,6,4]
+<strong>Output:</strong> [8,0,7]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> l1 = [0], l2 = [0]
+<strong>Output:</strong> [0]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in each linked list is in the range <code>[1, 100]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 9</code></li>
+	<li>It is guaranteed that the list represents a number that does not have leading zeros.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong>&nbsp;Could you solve it without reversing the input lists?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/add-two-numbers-ii/add-two-numbers-ii.java b/leetcode/leetcode/add-two-numbers-ii/add-two-numbers-ii.java
new file mode 100644
index 0000000..00e2f67
--- /dev/null
+++ b/leetcode/leetcode/add-two-numbers-ii/add-two-numbers-ii.java
@@ -0,0 +1,63 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    
+    public ListNode reverse(ListNode head){
+        if(head == null || head.next == null) return head;
+        ListNode prev = null;
+        ListNode curr = head;
+        ListNode next = head.next;
+        while(next != null){
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+            next = next.next;
+        }
+        curr.next = prev;
+        return curr;
+    }
+    
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        l1 = reverse(l1);
+        l2 = reverse(l2);
+        ListNode res = new ListNode();
+        ListNode head = res;
+        int carry = 0;
+        while(l1!= null || l2 !=null){
+            int val1;
+            int val2;
+            if(l1==null) val1 =0;
+            else{
+                val1 = l1.val;
+                l1 = l1.next;
+            }
+            if(l2==null) val2 =0;
+            else{
+                val2 = l2.val;
+                l2 = l2.next;
+            }
+            int data = val1+val2 + carry;
+            if(data>9){
+                carry = data/10;
+                data = data%10;
+            }else{
+                carry = 0;
+            }
+            res.next = new ListNode(data);
+            res = res.next;
+
+        }
+        if(carry!=0){
+            res.next = new ListNode(carry);
+        }
+        return reverse(head.next);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/add-two-numbers/README.md b/leetcode/leetcode/add-two-numbers/README.md
new file mode 100644
index 0000000..f257754
--- /dev/null
+++ b/leetcode/leetcode/add-two-numbers/README.md
@@ -0,0 +1,33 @@
+<h2>2. Add Two Numbers</h2><h3>Medium</h3><hr><div><p>You are given two <strong>non-empty</strong> linked lists representing two non-negative integers. The digits are stored in <strong>reverse order</strong>, and each of their nodes contains a single digit. Add the two numbers and return the sum&nbsp;as a linked list.</p>
+
+<p>You may assume the two numbers do not contain any leading zero, except the number 0 itself.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg" style="width: 483px; height: 342px;">
+<pre><strong>Input:</strong> l1 = [2,4,3], l2 = [5,6,4]
+<strong>Output:</strong> [7,0,8]
+<strong>Explanation:</strong> 342 + 465 = 807.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> l1 = [0], l2 = [0]
+<strong>Output:</strong> [0]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+<strong>Output:</strong> [8,9,9,9,0,0,0,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in each linked list is in the range <code>[1, 100]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 9</code></li>
+	<li>It is guaranteed that the list represents a number that does not have leading zeros.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/add-two-numbers/add-two-numbers.java b/leetcode/leetcode/add-two-numbers/add-two-numbers.java
new file mode 100644
index 0000000..7a57e58
--- /dev/null
+++ b/leetcode/leetcode/add-two-numbers/add-two-numbers.java
@@ -0,0 +1,42 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        int carry = 0;
+        ListNode head = new ListNode();
+        ListNode temp = head;
+        while(l1!=null || l2!=null){
+            int val1 = 0;
+            int val2 = 0;
+            if(l1!=null){
+                val1 = l1.val;
+                l1 = l1.next;
+                
+            } 
+            if(l2!=null) {
+                val2 = l2.val;
+                l2 = l2.next;
+                
+            }
+            int data = val1 + val2 +carry;
+            if(data>9){
+                carry = data/10;
+                data = data%10;
+            }else{
+                carry = 0;
+            }
+            temp.next = new ListNode(data);
+            temp = temp.next;
+        }
+        if(carry!=0) temp.next = new ListNode(carry);
+        return head.next;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/adding-spaces-to-a-string/README.md b/leetcode/leetcode/adding-spaces-to-a-string/README.md
new file mode 100644
index 0000000..47a9bd4
--- /dev/null
+++ b/leetcode/leetcode/adding-spaces-to-a-string/README.md
@@ -0,0 +1,46 @@
+<h2>2109. Adding Spaces to a String</h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> string <code>s</code> and a <strong>0-indexed</strong> integer array <code>spaces</code> that describes the indices in the original string where spaces will be added. Each space should be inserted <strong>before</strong> the character at the given index.</p>
+
+<ul>
+	<li>For example, given <code>s = "EnjoyYourCoffee"</code> and <code>spaces = [5, 9]</code>, we place spaces before <code>'Y'</code> and <code>'C'</code>, which are at indices <code>5</code> and <code>9</code> respectively. Thus, we obtain <code>"Enjoy <strong><u>Y</u></strong>our <u><strong>C</strong></u>offee"</code>.</li>
+</ul>
+
+<p>Return<strong> </strong><em>the modified string <strong>after</strong> the spaces have been added.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "LeetcodeHelpsMeLearn", spaces = [8,13,15]
+<strong>Output:</strong> "Leetcode Helps Me Learn"
+<strong>Explanation:</strong> 
+The indices 8, 13, and 15 correspond to the underlined characters in "Leetcode<u><strong>H</strong></u>elps<u><strong>M</strong></u>e<u><strong>L</strong></u>earn".
+We then place spaces before those characters.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "icodeinpython", spaces = [1,5,7,9]
+<strong>Output:</strong> "i code in py thon"
+<strong>Explanation:</strong>
+The indices 1, 5, 7, and 9 correspond to the underlined characters in "i<u><strong>c</strong></u>ode<u><strong>i</strong></u>n<u><strong>p</strong></u>y<u><strong>t</strong></u>hon".
+We then place spaces before those characters.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "spacing", spaces = [0,1,2,3,4,5,6]
+<strong>Output:</strong> " s p a c i n g"
+<strong>Explanation:</strong>
+We are also able to place spaces before the first character of the string.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 3 * 10<sup>5</sup></code></li>
+	<li><code>s</code> consists only of lowercase and uppercase English letters.</li>
+	<li><code>1 &lt;= spaces.length &lt;= 3 * 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= spaces[i] &lt;= s.length - 1</code></li>
+	<li>All the values of <code>spaces</code> are <strong>strictly increasing</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/adding-spaces-to-a-string/adding-spaces-to-a-string.java b/leetcode/leetcode/adding-spaces-to-a-string/adding-spaces-to-a-string.java
new file mode 100644
index 0000000..95b4448
--- /dev/null
+++ b/leetcode/leetcode/adding-spaces-to-a-string/adding-spaces-to-a-string.java
@@ -0,0 +1,17 @@
+class Solution {
+    public String addSpaces(String s, int[] spaces) {
+        StringBuilder sb = new StringBuilder(s.length()+spaces.length);
+        int i  = 0;
+        int counter = 0;
+        while(i<s.length()){
+            if(counter<spaces.length && spaces[counter] == i){
+                sb.append(" ");
+                counter++;
+            }else{
+                sb.append(s.charAt(i));
+                i++;
+            }
+        }
+        return sb.toString();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/apply-discount-every-n-orders/README.md b/leetcode/leetcode/apply-discount-every-n-orders/README.md
new file mode 100644
index 0000000..603ada4
--- /dev/null
+++ b/leetcode/leetcode/apply-discount-every-n-orders/README.md
@@ -0,0 +1,58 @@
+<h2>1357. Apply Discount Every n Orders</h2><h3>Medium</h3><hr><div><p>There is a supermarket that is frequented by many customers. The products sold at the supermarket are represented as two parallel integer arrays <code>products</code> and <code>prices</code>, where the <code>i<sup>th</sup></code> product has an ID of <code>products[i]</code> and a price of <code>prices[i]</code>.</p>
+
+<p>When a customer is paying, their bill is represented as two parallel integer arrays <code>product</code> and <code>amount</code>, where the <code>j<sup>th</sup></code> product they purchased has an ID of <code>product[j]</code>, and <code>amount[j]</code> is how much of the product they bought. Their subtotal is calculated as the sum of each <code>amount[j] * (price of the j<sup>th</sup> product)</code>.</p>
+
+<p>The supermarket decided to have a sale. Every <code>n<sup>th</sup></code> customer paying for their groceries will be given a <strong>percentage discount</strong>. The discount amount is given by <code>discount</code>, where they will be given <code>discount</code> percent off their subtotal. More formally, if their subtotal is <code>bill</code>, then they would actually pay <code>bill * ((100 - discount) / 100)</code>.</p>
+
+<p>Implement the <code>Cashier</code> class:</p>
+
+<ul>
+	<li><code>Cashier(int n, int discount, int[] products, int[] prices)</code> Initializes the object with <code>n</code>, the <code>discount</code>, and the <code>products</code> and their <code>prices</code>.</li>
+	<li><code>double getBill(int[] product, int[] amount)</code> Returns the final total of the bill with the discount applied (if any). Answers within <code>10<sup>-5</sup></code> of the actual value will be accepted.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["Cashier","getBill","getBill","getBill","getBill","getBill","getBill","getBill"]
+[[3,50,[1,2,3,4,5,6,7],[100,200,300,400,300,200,100]],[[1,2],[1,2]],[[3,7],[10,10]],[[1,2,3,4,5,6,7],[1,1,1,1,1,1,1]],[[4],[10]],[[7,3],[10,10]],[[7,5,3,1,6,4,2],[10,10,10,9,9,9,7]],[[2,3,5],[5,3,2]]]
+<strong>Output</strong>
+[null,500.0,4000.0,800.0,4000.0,4000.0,7350.0,2500.0]
+<strong>Explanation</strong>
+Cashier cashier = new Cashier(3,50,[1,2,3,4,5,6,7],[100,200,300,400,300,200,100]);
+cashier.getBill([1,2],[1,2]);                        // return 500.0. 1<sup>st</sup> customer, no discount.
+                                                     // bill = 1 * 100 + 2 * 200 = 500.
+cashier.getBill([3,7],[10,10]);                      // return 4000.0. 2<sup>nd</sup> customer, no discount.
+                                                     // bill = 10 * 300 + 10 * 100 = 4000.
+cashier.getBill([1,2,3,4,5,6,7],[1,1,1,1,1,1,1]);    // return 800.0. 3<sup>rd</sup> customer, 50% discount.
+                                                     // Original bill = 1600
+                                                     // Actual bill = 1600 * ((100 - 50) / 100) = 800.
+cashier.getBill([4],[10]);                           // return 4000.0. 4<sup>th</sup> customer, no discount.
+cashier.getBill([7,3],[10,10]);                      // return 4000.0. 5<sup>th</sup> customer, no discount.
+cashier.getBill([7,5,3,1,6,4,2],[10,10,10,9,9,9,7]); // return 7350.0. 6<sup>th</sup> customer, 50% discount.
+                                                     // Original bill = 14700, but with
+                                                     // Actual bill = 14700 * ((100 - 50) / 100) = 7350.
+cashier.getBill([2,3,5],[5,3,2]);                    // return 2500.0.  6<sup>th</sup> customer, no discount.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= discount &lt;= 100</code></li>
+	<li><code>1 &lt;= products.length &lt;= 200</code></li>
+	<li><code>prices.length == products.length</code></li>
+	<li><code>1 &lt;= products[i] &lt;= 200</code></li>
+	<li><code>1 &lt;= prices[i] &lt;= 1000</code></li>
+	<li>The elements in <code>products</code> are <strong>unique</strong>.</li>
+	<li><code>1 &lt;= product.length &lt;= products.length</code></li>
+	<li><code>amount.length == product.length</code></li>
+	<li><code>product[j]</code> exists in <code>products</code>.</li>
+	<li><code>1 &lt;= amount[j] &lt;= 1000</code></li>
+	<li>The elements of <code>product</code> are <strong>unique</strong>.</li>
+	<li>At most <code>1000</code> calls will be made to <code>getBill</code>.</li>
+	<li>Answers within <code>10<sup>-5</sup></code> of the actual value will be accepted.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/apply-discount-every-n-orders/apply-discount-every-n-orders.java b/leetcode/leetcode/apply-discount-every-n-orders/apply-discount-every-n-orders.java
new file mode 100644
index 0000000..dbf2b4c
--- /dev/null
+++ b/leetcode/leetcode/apply-discount-every-n-orders/apply-discount-every-n-orders.java
@@ -0,0 +1,35 @@
+class Cashier {
+    HashMap<Integer,Integer> map;
+    public int N;
+    public int dis;
+    public int customerNo;
+    public Cashier(int n, int discount, int[] products, int[] prices) {
+        map = new HashMap<>(products.length);
+        for(int i=0;i<products.length;i++){
+            map.put(products[i],prices[i]);
+        }
+        N = n;
+        dis = discount;
+        customerNo = 0;
+        
+    }
+    
+    public double getBill(int[] product, int[] amount) {
+        double total = 0;
+        customerNo++;
+        for(int i =0;i<product.length;i++){
+            total+=(map.get(product[i])*amount[i]);
+        }
+        if(customerNo==N){
+            total = total*((double)(100-dis)/100);
+            customerNo=0;
+        }
+        return total;
+    }
+}
+
+/**
+ * Your Cashier object will be instantiated and called as such:
+ * Cashier obj = new Cashier(n, discount, products, prices);
+ * double param_1 = obj.getBill(product,amount);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/arranging-coins/README.md b/leetcode/leetcode/arranging-coins/README.md
new file mode 100644
index 0000000..20e3cd8
--- /dev/null
+++ b/leetcode/leetcode/arranging-coins/README.md
@@ -0,0 +1,26 @@
+<h2>441. Arranging Coins</h2><h3>Easy</h3><hr><div><p>You have <code>n</code> coins and you want to build a staircase with these coins. The staircase consists of <code>k</code> rows where the <code>i<sup>th</sup></code> row has exactly <code>i</code> coins. The last row of the staircase <strong>may be</strong> incomplete.</p>
+
+<p>Given the integer <code>n</code>, return <em>the number of <strong>complete rows</strong> of the staircase you will build</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/04/09/arrangecoins1-grid.jpg" style="width: 253px; height: 253px;">
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Because the 3<sup>rd</sup> row is incomplete, we return 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/04/09/arrangecoins2-grid.jpg" style="width: 333px; height: 333px;">
+<pre><strong>Input:</strong> n = 8
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Because the 4<sup>th</sup> row is incomplete, we return 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/arranging-coins/arranging-coins.java b/leetcode/leetcode/arranging-coins/arranging-coins.java
new file mode 100644
index 0000000..11ae265
--- /dev/null
+++ b/leetcode/leetcode/arranging-coins/arranging-coins.java
@@ -0,0 +1,5 @@
+class Solution {
+  public int arrangeCoins(int n) {
+    return (int)(Math.sqrt(2 * (long)n + 0.25) - 0.5);
+  }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/array-partition-i/README.md b/leetcode/leetcode/array-partition-i/README.md
new file mode 100644
index 0000000..daab9ff
--- /dev/null
+++ b/leetcode/leetcode/array-partition-i/README.md
@@ -0,0 +1,29 @@
+<h2>561. Array Partition I</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> of <code>2n</code> integers, group these integers into <code>n</code> pairs <code>(a<sub>1</sub>, b<sub>1</sub>), (a<sub>2</sub>, b<sub>2</sub>), ..., (a<sub>n</sub>, b<sub>n</sub>)</code> such that the sum of <code>min(a<sub>i</sub>, b<sub>i</sub>)</code> for all <code>i</code> is <strong>maximized</strong>. Return<em> the maximized sum</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,4,3,2]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> All possible pairings (ignoring the ordering of elements) are:
+1. (1, 4), (2, 3) -&gt; min(1, 4) + min(2, 3) = 1 + 2 = 3
+2. (1, 3), (2, 4) -&gt; min(1, 3) + min(2, 4) = 1 + 2 = 3
+3. (1, 2), (3, 4) -&gt; min(1, 2) + min(3, 4) = 1 + 3 = 4
+So the maximum possible sum is 4.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [6,2,6,5,1,2]
+<strong>Output:</strong> 9
+<strong>Explanation:</strong> The optimal pairing is (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>nums.length == 2 * n</code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/array-partition-i/array-partition-i.java b/leetcode/leetcode/array-partition-i/array-partition-i.java
new file mode 100644
index 0000000..88e8e19
--- /dev/null
+++ b/leetcode/leetcode/array-partition-i/array-partition-i.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int arrayPairSum(int[] nums) {
+        Arrays.sort(nums);
+        int ans=0;
+        for(int i = 0;i<nums.length;i=i+2){
+            ans+=nums[i];
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/average-of-levels-in-binary-tree/README.md b/leetcode/leetcode/average-of-levels-in-binary-tree/README.md
new file mode 100644
index 0000000..19914a8
--- /dev/null
+++ b/leetcode/leetcode/average-of-levels-in-binary-tree/README.md
@@ -0,0 +1,24 @@
+<h2>637. Average of Levels in Binary Tree</h2><h3>Easy</h3><hr><div>Given the <code>root</code> of a binary tree, return <em>the average value of the nodes on each level in the form of an array</em>. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/avg1-tree.jpg" style="width: 277px; height: 302px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> [3.00000,14.50000,11.00000]
+Explanation: The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11.
+Hence return [3, 14.5, 11].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/avg2-tree.jpg" style="width: 292px; height: 302px;">
+<pre><strong>Input:</strong> root = [3,9,20,15,7]
+<strong>Output:</strong> [3.00000,14.50000,11.00000]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-2<sup>31</sup> &lt;= Node.val &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/average-of-levels-in-binary-tree/average-of-levels-in-binary-tree.java b/leetcode/leetcode/average-of-levels-in-binary-tree/average-of-levels-in-binary-tree.java
new file mode 100644
index 0000000..986f611
--- /dev/null
+++ b/leetcode/leetcode/average-of-levels-in-binary-tree/average-of-levels-in-binary-tree.java
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    
+    public int level(TreeNode root){
+        if(root == null) return 0;
+        return 1 + Math.max(level(root.left), level(root.right));
+        
+    }
+    
+    public Pair<Long,Long> levelHelper(TreeNode root, int level){
+        if(root == null) {
+            Pair<Long, Long> p = new  Pair<Long,Long>((long) 0,(long) 0);
+            return p;
+        }
+        if(level==0){
+            Pair<Long,Long> p = new  Pair<Long,Long>((long)1,(long) root.val);
+            return p;
+        }
+        Pair<Long, Long> p1 = levelHelper(root.left,level-1);
+        Pair<Long, Long> p2 = levelHelper(root.right,level-1);
+        Pair<Long, Long> p = new  Pair<Long,Long>( p1.getKey()+p2.getKey(),p1.getValue()+p2.getValue());
+        return p;
+    }
+    public List<Double> averageOfLevels(TreeNode root) {
+        int maxLevel = level(root);
+        List<Double> list = new ArrayList<Double>(maxLevel);
+        for(int i=0;i<maxLevel;i++){
+            Pair<Long,Long> p1 = levelHelper(root,i);
+            list.add( (p1.getValue())/(double)p1.getKey());
+        }
+
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/balanced-binary-tree/README.md b/leetcode/leetcode/balanced-binary-tree/README.md
new file mode 100644
index 0000000..803d204
--- /dev/null
+++ b/leetcode/leetcode/balanced-binary-tree/README.md
@@ -0,0 +1,35 @@
+<h2>110. Balanced Binary Tree</h2><h3>Easy</h3><hr><div><p>Given a binary tree, determine if it is height-balanced.</p>
+
+<p>For this problem, a height-balanced binary tree is defined as:</p>
+
+<blockquote>
+<p>a binary tree in which the left and right subtrees of <em>every</em> node differ in height by no more than 1.</p>
+</blockquote>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_1.jpg" style="width: 342px; height: 221px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/06/balance_2.jpg" style="width: 452px; height: 301px;">
+<pre><strong>Input:</strong> root = [1,2,2,3,3,null,null,4,4]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 5000]</code>.</li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/balanced-binary-tree/balanced-binary-tree.java b/leetcode/leetcode/balanced-binary-tree/balanced-binary-tree.java
new file mode 100644
index 0000000..230ae92
--- /dev/null
+++ b/leetcode/leetcode/balanced-binary-tree/balanced-binary-tree.java
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int height(TreeNode root){
+        if(root==null) return 0;
+        return Math.max(height(root.left),height(root.right))+1;
+    }
+    public boolean isBalanced(TreeNode root) {
+        if(root == null) return true;
+        return Math.abs(height(root.left) - height(root.right))<=1 && isBalanced(root.left) && isBalanced(root.right) ;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/binary-search/README.md b/leetcode/leetcode/binary-search/README.md
new file mode 100644
index 0000000..cb494d2
--- /dev/null
+++ b/leetcode/leetcode/binary-search/README.md
@@ -0,0 +1,29 @@
+<h2>704. Binary Search</h2><h3>Easy</h3><hr><div><p>Given an array of integers <code>nums</code> which is sorted in ascending order, and an integer <code>target</code>, write a function to search <code>target</code> in <code>nums</code>. If <code>target</code> exists, then return its index. Otherwise, return <code>-1</code>.</p>
+
+<p>You must write an algorithm with <code>O(log n)</code> runtime complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,0,3,5,9,12], target = 9
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> 9 exists in nums and its index is 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,0,3,5,9,12], target = 2
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> 2 does not exist in nums so return -1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt; nums[i], target &lt; 10<sup>4</sup></code></li>
+	<li>All the integers in <code>nums</code> are <strong>unique</strong>.</li>
+	<li><code>nums</code> is sorted in ascending order.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/binary-search/binary-search.java b/leetcode/leetcode/binary-search/binary-search.java
new file mode 100644
index 0000000..fea4fa8
--- /dev/null
+++ b/leetcode/leetcode/binary-search/binary-search.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int search(int[] nums, int target) {
+        int low = 0;
+        int high = nums.length - 1;
+        int mid;
+        while(low<=high){
+            mid = (low+high)/2;
+            if(nums[mid] == target){
+                return mid;
+            } else if(nums[mid] > target){
+                high  = mid-1;
+            } else{
+                low = mid+1;
+            }
+        }
+        return -1;
+    }
+} }
+}
diff --git a/leetcode/leetcode/binary-tree-inorder-traversal/README.md b/leetcode/leetcode/binary-tree-inorder-traversal/README.md
new file mode 100644
index 0000000..728adca
--- /dev/null
+++ b/leetcode/leetcode/binary-tree-inorder-traversal/README.md
@@ -0,0 +1,43 @@
+<h2>94. Binary Tree Inorder Traversal</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the inorder traversal of its nodes' values</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 202px; height: 324px;">
+<pre><strong>Input:</strong> root = [1,null,2,3]
+<strong>Output:</strong> [1,3,2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_5.jpg" style="width: 202px; height: 202px;">
+<pre><strong>Input:</strong> root = [1,2]
+<strong>Output:</strong> [2,1]
+</pre>
+
+<p><strong>Example 5:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_4.jpg" style="width: 202px; height: 202px;">
+<pre><strong>Input:</strong> root = [1,null,2]
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/binary-tree-inorder-traversal/binary-tree-inorder-traversal.java b/leetcode/leetcode/binary-tree-inorder-traversal/binary-tree-inorder-traversal.java
new file mode 100644
index 0000000..76284e7
--- /dev/null
+++ b/leetcode/leetcode/binary-tree-inorder-traversal/binary-tree-inorder-traversal.java
@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> list = new ArrayList<Integer>();
+        if(root==null){
+            return list;
+        }
+        list.addAll(inorderTraversal(root.left));
+        list.add(root.val);
+        list.addAll(inorderTraversal(root.right));
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/binary-tree-postorder-traversal/README.md b/leetcode/leetcode/binary-tree-postorder-traversal/README.md
new file mode 100644
index 0000000..24f1990
--- /dev/null
+++ b/leetcode/leetcode/binary-tree-postorder-traversal/README.md
@@ -0,0 +1,43 @@
+<h2>145. Binary Tree Postorder Traversal</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a&nbsp;binary tree, return <em>the postorder traversal of its nodes' values</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/pre1.jpg" style="width: 202px; height: 317px;">
+<pre><strong>Input:</strong> root = [1,null,2,3]
+<strong>Output:</strong> [3,2,1]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/pre3.jpg" style="width: 202px; height: 197px;">
+<pre><strong>Input:</strong> root = [1,2]
+<strong>Output:</strong> [2,1]
+</pre>
+
+<p><strong>Example 5:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/28/pre2.jpg" style="width: 202px; height: 197px;">
+<pre><strong>Input:</strong> root = [1,null,2]
+<strong>Output:</strong> [2,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of the nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/binary-tree-postorder-traversal/binary-tree-postorder-traversal.java b/leetcode/leetcode/binary-tree-postorder-traversal/binary-tree-postorder-traversal.java
new file mode 100644
index 0000000..b3bb473
--- /dev/null
+++ b/leetcode/leetcode/binary-tree-postorder-traversal/binary-tree-postorder-traversal.java
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> postorderTraversal(TreeNode root) {
+        List<Integer> list = new ArrayList<Integer>();
+        if(root==null){
+            return list;
+        }
+        list.addAll(postorderTraversal(root.left));
+        list.addAll(postorderTraversal(root.right));
+        list.add(root.val);
+        return list;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/binary-tree-preorder-traversal/README.md b/leetcode/leetcode/binary-tree-preorder-traversal/README.md
new file mode 100644
index 0000000..7794c1f
--- /dev/null
+++ b/leetcode/leetcode/binary-tree-preorder-traversal/README.md
@@ -0,0 +1,44 @@
+<h2>144. Binary Tree Preorder Traversal</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the preorder traversal of its nodes' values</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg" style="width: 202px; height: 324px;">
+<pre><strong>Input:</strong> root = [1,null,2,3]
+<strong>Output:</strong> [1,2,3]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_5.jpg" style="width: 202px; height: 202px;">
+<pre><strong>Input:</strong> root = [1,2]
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p><strong>Example 5:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/15/inorder_4.jpg" style="width: 202px; height: 202px;">
+<pre><strong>Input:</strong> root = [1,null,2]
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/binary-tree-preorder-traversal/binary-tree-preorder-traversal.java b/leetcode/leetcode/binary-tree-preorder-traversal/binary-tree-preorder-traversal.java
new file mode 100644
index 0000000..a86e2a8
--- /dev/null
+++ b/leetcode/leetcode/binary-tree-preorder-traversal/binary-tree-preorder-traversal.java
@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> preorderTraversal(TreeNode root) {
+        List<Integer> list = new ArrayList<Integer>();
+        if(root==null){
+            return list;
+        }
+        list.add(root.val);
+        list.addAll(preorderTraversal(root.left));
+        list.addAll(preorderTraversal(root.right));
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/binary-tree-tilt/README.md b/leetcode/leetcode/binary-tree-tilt/README.md
new file mode 100644
index 0000000..bba0dd5
--- /dev/null
+++ b/leetcode/leetcode/binary-tree-tilt/README.md
@@ -0,0 +1,44 @@
+<h2>563. Binary Tree Tilt</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the sum of every tree node's <strong>tilt</strong>.</em></p>
+
+<p>The <strong>tilt</strong> of a tree node is the <b>absolute difference</b> between the sum of all left subtree node <strong>values</strong> and all right subtree node <strong>values</strong>. If a node does not have a left child, then the sum of the left subtree node <strong>values</strong> is treated as <code>0</code>. The rule is similar if there the node does not have a right child.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/20/tilt1.jpg" style="width: 712px; height: 182px;">
+<pre><strong>Input:</strong> root = [1,2,3]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> 
+Tilt of node 2 : |0-0| = 0 (no children)
+Tilt of node 3 : |0-0| = 0 (no children)
+Tilt of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3)
+Sum of every tilt : 0 + 0 + 1 = 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/20/tilt2.jpg" style="width: 800px; height: 203px;">
+<pre><strong>Input:</strong> root = [4,2,9,3,5,null,7]
+<strong>Output:</strong> 15
+<strong>Explanation:</strong> 
+Tilt of node 3 : |0-0| = 0 (no children)
+Tilt of node 5 : |0-0| = 0 (no children)
+Tilt of node 7 : |0-0| = 0 (no children)
+Tilt of node 2 : |3-5| = 2 (left subtree is just left child, so sum is 3; right subtree is just right child, so sum is 5)
+Tilt of node 9 : |0-7| = 7 (no left child, so sum is 0; right subtree is just right child, so sum is 7)
+Tilt of node 4 : |(3+5+2)-(9+7)| = |10-16| = 6 (left subtree values are 3, 5, and 2, which sums to 10; right subtree values are 9 and 7, which sums to 16)
+Sum of every tilt : 0 + 0 + 0 + 2 + 7 + 6 = 15
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/20/tilt3.jpg" style="width: 800px; height: 293px;">
+<pre><strong>Input:</strong> root = [21,7,14,1,1,2,2,3,3]
+<strong>Output:</strong> 9
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/binary-tree-tilt/binary-tree-tilt.java b/leetcode/leetcode/binary-tree-tilt/binary-tree-tilt.java
new file mode 100644
index 0000000..73496ff
--- /dev/null
+++ b/leetcode/leetcode/binary-tree-tilt/binary-tree-tilt.java
@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int tilt = 0;
+    
+    public int helperTilt(TreeNode root){
+        if(root == null) return 0;
+        int ls = helperTilt(root.left);
+        int rs = helperTilt(root.right);
+        tilt+=Math.abs(ls-rs);
+        return ls + rs + root.val;
+    }
+    
+    public int findTilt(TreeNode root) {
+        helperTilt(root);
+        return tilt;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/bitwise-and-of-numbers-range/README.md b/leetcode/leetcode/bitwise-and-of-numbers-range/README.md
new file mode 100644
index 0000000..f1781aa
--- /dev/null
+++ b/leetcode/leetcode/bitwise-and-of-numbers-range/README.md
@@ -0,0 +1,30 @@
+[Discussion Post (created on 10/9/2021 at 11:17)](https://leetcode.com/problems/bitwise-and-of-numbers-range/discuss/1513651/PYTHON-O(1)-TIME-and-SPACE)  
+[Discussion Post (created on 10/9/2021 at 11:14)](https://leetcode.com/problems/bitwise-and-of-numbers-range/discuss/1513649/C%2B%2B-O(1)-TIME-and-SPACE)  
+<h2>201. Bitwise AND of Numbers Range</h2><h3>Medium</h3><hr><div><p>Given two integers <code>left</code> and <code>right</code> that represent the range <code>[left, right]</code>, return <em>the bitwise AND of all numbers in this range, inclusive</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> left = 5, right = 7
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> left = 0, right = 0
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> left = 1, right = 2147483647
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= left &lt;= right &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/bitwise-and-of-numbers-range/bitwise-and-of-numbers-range.cpp b/leetcode/leetcode/bitwise-and-of-numbers-range/bitwise-and-of-numbers-range.cpp
new file mode 100644
index 0000000..ed9a0b4
--- /dev/null
+++ b/leetcode/leetcode/bitwise-and-of-numbers-range/bitwise-and-of-numbers-range.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int rangeBitwiseAnd(int left, int right) {
+        int counter = 0;
+        while(left!=right){
+            left = left>>1;
+            right = right>>1;
+            counter++;
+        }
+        return left<<counter;
+    }
+};
\ No newline at end of file
diff --git a/leetcode/leetcode/bitwise-and-of-numbers-range/bitwise-and-of-numbers-range.java b/leetcode/leetcode/bitwise-and-of-numbers-range/bitwise-and-of-numbers-range.java
new file mode 100644
index 0000000..f022e24
--- /dev/null
+++ b/leetcode/leetcode/bitwise-and-of-numbers-range/bitwise-and-of-numbers-range.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int rangeBitwiseAnd(int left, int right) {
+        int counter = 0;
+        while(left!=right){
+            left = left>>1;
+            right = right>>1;
+            counter++;
+        }
+        
+        while(counter!=0){
+            left = left<<1;
+            counter--;
+        }
+        return left;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/build-array-from-permutation/README.md b/leetcode/leetcode/build-array-from-permutation/README.md
new file mode 100644
index 0000000..a2f3be6
--- /dev/null
+++ b/leetcode/leetcode/build-array-from-permutation/README.md
@@ -0,0 +1,35 @@
+<h2>1920. Build Array from Permutation</h2><h3>Easy</h3><hr><div><p>Given a <strong>zero-based permutation</strong> <code>nums</code> (<strong>0-indexed</strong>), build an array <code>ans</code> of the <strong>same length</strong> where <code>ans[i] = nums[nums[i]]</code> for each <code>0 &lt;= i &lt; nums.length</code> and return it.</p>
+
+<p>A <strong>zero-based permutation</strong> <code>nums</code> is an array of <strong>distinct</strong> integers from <code>0</code> to <code>nums.length - 1</code> (<strong>inclusive</strong>).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,2,1,5,3,4]
+<strong>Output:</strong> [0,1,2,4,5,3]<strong>
+Explanation:</strong> The array ans is built as follows: 
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
+    = [0,1,2,4,5,3]</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [5,0,1,2,3,4]
+<strong>Output:</strong> [4,5,0,1,2,3]
+<strong>Explanation:</strong> The array ans is built as follows:
+ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
+    = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
+    = [4,5,0,1,2,3]</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums[i] &lt; nums.length</code></li>
+	<li>The elements in <code>nums</code> are <strong>distinct</strong>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong> Can you solve it without using an extra space (i.e., <code>O(1)</code> memory)?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/build-array-from-permutation/build-array-from-permutation.java b/leetcode/leetcode/build-array-from-permutation/build-array-from-permutation.java
new file mode 100644
index 0000000..419b088
--- /dev/null
+++ b/leetcode/leetcode/build-array-from-permutation/build-array-from-permutation.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int[] buildArray(int[] nums) {
+        int[] result = new int[nums.length];
+        int counter =0;
+        while(counter<nums.length){
+            result[counter] = nums[nums[counter]];
+            counter++;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/calculate-money-in-leetcode-bank/README.md b/leetcode/leetcode/calculate-money-in-leetcode-bank/README.md
new file mode 100644
index 0000000..ff701f6
--- /dev/null
+++ b/leetcode/leetcode/calculate-money-in-leetcode-bank/README.md
@@ -0,0 +1,35 @@
+<h2>1716. Calculate Money in Leetcode Bank</h2><h3>Easy</h3><hr><div><p>Hercy wants to save money for his first car. He puts money in the Leetcode&nbsp;bank <strong>every day</strong>.</p>
+
+<p>He starts by putting in <code>$1</code> on Monday, the first day. Every day from Tuesday to Sunday, he will put in <code>$1</code> more than the day before. On every subsequent Monday, he will put in <code>$1</code> more than the <strong>previous Monday</strong>.<span style="display: none;"> </span></p>
+
+<p>Given <code>n</code>, return <em>the total amount of money he will have in the Leetcode bank at the end of the </em><code>n<sup>th</sup></code><em> day.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> 10
+<strong>Explanation:</strong>&nbsp;After the 4<sup>th</sup> day, the total is 1 + 2 + 3 + 4 = 10.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 10
+<strong>Output:</strong> 37
+<strong>Explanation:</strong>&nbsp;After the 10<sup>th</sup> day, the total is (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4) = 37. Notice that on the 2<sup>nd</sup> Monday, Hercy only puts in $2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 20
+<strong>Output:</strong> 96
+<strong>Explanation:</strong>&nbsp;After the 20<sup>th</sup> day, the total is (1 + 2 + 3 + 4 + 5 + 6 + 7) + (2 + 3 + 4 + 5 + 6 + 7 + 8) + (3 + 4 + 5 + 6 + 7 + 8) = 96.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/calculate-money-in-leetcode-bank/calculate-money-in-leetcode-bank.java b/leetcode/leetcode/calculate-money-in-leetcode-bank/calculate-money-in-leetcode-bank.java
new file mode 100644
index 0000000..4fbed76
--- /dev/null
+++ b/leetcode/leetcode/calculate-money-in-leetcode-bank/calculate-money-in-leetcode-bank.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int totalMoney(int n) {
+        int res = 0;
+        int counter = 0;
+        while(n>=7){
+            res = res + 28 + counter*7;
+            counter++;
+            n = n-7;
+        }
+        if(n!=0) res = res + ((n)*(2*(counter+1) + (n-1)))/2;
+            //S = n/2[2a + (n − 1) × d]
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/README.md b/leetcode/leetcode/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/README.md
new file mode 100644
index 0000000..cb861a8
--- /dev/null
+++ b/leetcode/leetcode/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/README.md
@@ -0,0 +1,50 @@
+<h2>1455. Check If a Word Occurs As a Prefix of Any Word in a Sentence</h2><h3>Easy</h3><hr><div><p>Given a <code>sentence</code> that consists of some words separated by a <strong>single space</strong>, and a <code>searchWord</code>, check if <code>searchWord</code> is a prefix of any word in <code>sentence</code>.</p>
+
+<p>Return <em>the index of the word in </em><code>sentence</code><em> (<strong>1-indexed</strong>) where </em><code>searchWord</code><em> is a prefix of this word</em>. If <code>searchWord</code> is a prefix of more than one word, return the index of the first word <strong>(minimum index)</strong>. If there is no such word return <code>-1</code>.</p>
+
+<p>A <strong>prefix</strong> of a string <code>s</code> is any leading contiguous substring of <code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> sentence = "i love eating burger", searchWord = "burg"
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> "burg" is prefix of "burger" which is the 4th word in the sentence.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> sentence = "this problem is an easy problem", searchWord = "pro"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> "pro" is prefix of "problem" which is the 2nd and the 6th word in the sentence, but we return 2 as it's the minimal index.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> sentence = "i am tired", searchWord = "you"
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> "you" is not a prefix of any word in the sentence.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> sentence = "i use triple pillow", searchWord = "pill"
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> sentence = "hello from the other side", searchWord = "they"
+<strong>Output:</strong> -1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= sentence.length &lt;= 100</code></li>
+	<li><code>1 &lt;= searchWord.length &lt;= 10</code></li>
+	<li><code>sentence</code> consists of lowercase English letters and spaces.</li>
+	<li><code>searchWord</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.java b/leetcode/leetcode/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.java
new file mode 100644
index 0000000..dea6057
--- /dev/null
+++ b/leetcode/leetcode/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int isPrefixOfWord(String sentence, String searchWord) {
+        String[] arr = sentence.split(" ");
+        for(int i = 0;i<arr.length;i++){
+            if(arr[i].length() >= searchWord.length()){
+                if(arr[i].substring(0,searchWord.length()).equals(searchWord)){
+                    return i+1;
+                }
+            }
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-all-as-appears-before-all-bs/README.md b/leetcode/leetcode/check-if-all-as-appears-before-all-bs/README.md
new file mode 100644
index 0000000..6e03202
--- /dev/null
+++ b/leetcode/leetcode/check-if-all-as-appears-before-all-bs/README.md
@@ -0,0 +1,37 @@
+<h2>2124. Check if All A's Appears Before All B's</h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code> consisting of <strong>only</strong> the characters <code>'a'</code> and <code>'b'</code>, return <code>true</code> <em>if <strong>every</strong> </em><code>'a'</code> <em>appears before <strong>every</strong> </em><code>'b'</code><em> in the string</em>. Otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "aaabbb"
+<strong>Output:</strong> true
+<strong>Explanation:</strong>
+The 'a's are at indices 0, 1, and 2, while the 'b's are at indices 3, 4, and 5.
+Hence, every 'a' appears before every 'b' and we return true.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "abab"
+<strong>Output:</strong> false
+<strong>Explanation:</strong>
+There is an 'a' at index 2 and a 'b' at index 1.
+Hence, not every 'a' appears before every 'b' and we return false.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "bbb"
+<strong>Output:</strong> true
+<strong>Explanation:</strong>
+There are no 'a's, hence, every 'a' appears before every 'b' and we return true.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 100</code></li>
+	<li><code>s[i]</code> is either <code>'a'</code> or <code>'b'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-all-as-appears-before-all-bs/check-if-all-as-appears-before-all-bs.java b/leetcode/leetcode/check-if-all-as-appears-before-all-bs/check-if-all-as-appears-before-all-bs.java
new file mode 100644
index 0000000..c5144ba
--- /dev/null
+++ b/leetcode/leetcode/check-if-all-as-appears-before-all-bs/check-if-all-as-appears-before-all-bs.java
@@ -0,0 +1,9 @@
+class Solution {
+    public boolean checkString(String s) {
+        int len = s.length();
+        for(int i = 0;i<len - 1;i++){
+            if(s.charAt(i) == 'b' && s.charAt(i+1) == 'a') return false; 
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-one-string-swap-can-make-strings-equal/README.md b/leetcode/leetcode/check-if-one-string-swap-can-make-strings-equal/README.md
new file mode 100644
index 0000000..92e271c
--- /dev/null
+++ b/leetcode/leetcode/check-if-one-string-swap-can-make-strings-equal/README.md
@@ -0,0 +1,41 @@
+<h2>1790. Check if One String Swap Can Make Strings Equal</h2><h3>Easy</h3><hr><div><p>You are given two strings <code>s1</code> and <code>s2</code> of equal length. A <strong>string swap</strong> is an operation where you choose two indices in a string (not necessarily different) and swap the characters at these indices.</p>
+
+<p>Return <code>true</code> <em>if it is possible to make both strings equal by performing <strong>at most one string swap </strong>on <strong>exactly one</strong> of the strings. </em>Otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s1 = "bank", s2 = "kanb"
+<strong>Output:</strong> true
+<strong>Explanation:</strong> For example, swap the first character with the last character of s2 to make "bank".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s1 = "attack", s2 = "defend"
+<strong>Output:</strong> false
+<strong>Explanation:</strong> It is impossible to make them equal with one string swap.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s1 = "kelb", s2 = "kelb"
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The two strings are already equal, so no string swap operation is required.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> s1 = "abcd", s2 = "dcba"
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s1.length, s2.length &lt;= 100</code></li>
+	<li><code>s1.length == s2.length</code></li>
+	<li><code>s1</code> and <code>s2</code> consist of only lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-one-string-swap-can-make-strings-equal/check-if-one-string-swap-can-make-strings-equal.java b/leetcode/leetcode/check-if-one-string-swap-can-make-strings-equal/check-if-one-string-swap-can-make-strings-equal.java
new file mode 100644
index 0000000..2cc9594
--- /dev/null
+++ b/leetcode/leetcode/check-if-one-string-swap-can-make-strings-equal/check-if-one-string-swap-can-make-strings-equal.java
@@ -0,0 +1,32 @@
+class Solution {
+    public boolean areAlmostEqual(String s1, String s2) {
+        int result = 0;
+        int counter1=-1;
+        int counter2  =-1;;
+        if(s1.length() != s2.length()){
+            return false;
+        }
+        if(s1.equals(s2)){
+            return true;
+        }
+        for(int i = 0;i<s1.length(); i++){
+            if(s1.charAt(i) != s2.charAt(i)){
+                result++;
+                if(counter1==-1){
+                    counter1 = i;
+                }else{
+                    counter2 =i;
+                }
+            }
+            if(result > 2){
+                return false;
+            }
+        }
+        if(result==2 && s1.charAt(counter1) == s2.charAt(counter2) && s1.charAt(counter2) == s2.charAt(counter1)){
+            return true;
+        }
+        return false;
+        
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-the-sentence-is-pangram/README.md b/leetcode/leetcode/check-if-the-sentence-is-pangram/README.md
new file mode 100644
index 0000000..9c9090a
--- /dev/null
+++ b/leetcode/leetcode/check-if-the-sentence-is-pangram/README.md
@@ -0,0 +1,26 @@
+<h2>1832. Check if the Sentence Is Pangram</h2><h3>Easy</h3><hr><div><p>A <strong>pangram</strong> is a sentence where every letter of the English alphabet appears at least once.</p>
+
+<p>Given a string <code>sentence</code> containing only lowercase English letters, return<em> </em><code>true</code><em> if </em><code>sentence</code><em> is a <strong>pangram</strong>, or </em><code>false</code><em> otherwise.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> sentence = "thequickbrownfoxjumpsoverthelazydog"
+<strong>Output:</strong> true
+<strong>Explanation:</strong> sentence contains at least one of every letter of the English alphabet.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> sentence = "leetcode"
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= sentence.length &lt;= 1000</code></li>
+	<li><code>sentence</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-the-sentence-is-pangram/check-if-the-sentence-is-pangram.java b/leetcode/leetcode/check-if-the-sentence-is-pangram/check-if-the-sentence-is-pangram.java
new file mode 100644
index 0000000..a49230f
--- /dev/null
+++ b/leetcode/leetcode/check-if-the-sentence-is-pangram/check-if-the-sentence-is-pangram.java
@@ -0,0 +1,13 @@
+class Solution {
+    public boolean checkIfPangram(String sentence) {
+        boolean[] arr = new boolean[26];
+        for(int i= 0;i<sentence.length();i++){
+            char c = sentence.charAt(i);
+            arr[((int)c)-97] = true;
+        }
+        for(boolean b: arr){
+            if(!b) return b;
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-two-string-arrays-are-equivalent/README.md b/leetcode/leetcode/check-if-two-string-arrays-are-equivalent/README.md
new file mode 100644
index 0000000..7d4a7e9
--- /dev/null
+++ b/leetcode/leetcode/check-if-two-string-arrays-are-equivalent/README.md
@@ -0,0 +1,36 @@
+<h2>1662. Check If Two String Arrays are Equivalent</h2><h3>Easy</h3><hr><div><p>Given two string arrays <code>word1</code> and <code>word2</code>, return<em> </em><code>true</code><em> if the two arrays <strong>represent</strong> the same string, and </em><code>false</code><em> otherwise.</em></p>
+
+<p>A string is <strong>represented</strong> by an array if the array elements concatenated <strong>in order</strong> forms the string.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> word1 = ["ab", "c"], word2 = ["a", "bc"]
+<strong>Output:</strong> true
+<strong>Explanation:</strong>
+word1 represents string "ab" + "c" -&gt; "abc"
+word2 represents string "a" + "bc" -&gt; "abc"
+The strings are the same, so return true.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> word1 = ["a", "cb"], word2 = ["ab", "c"]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> word1  = ["abc", "d", "defg"], word2 = ["abcddefg"]
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= word1.length, word2.length &lt;= 10<sup>3</sup></code></li>
+	<li><code>1 &lt;= word1[i].length, word2[i].length &lt;= 10<sup>3</sup></code></li>
+	<li><code>1 &lt;= sum(word1[i].length), sum(word2[i].length) &lt;= 10<sup>3</sup></code></li>
+	<li><code>word1[i]</code> and <code>word2[i]</code> consist of lowercase letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/check-if-two-string-arrays-are-equivalent/check-if-two-string-arrays-are-equivalent.java b/leetcode/leetcode/check-if-two-string-arrays-are-equivalent/check-if-two-string-arrays-are-equivalent.java
new file mode 100644
index 0000000..ff61541
--- /dev/null
+++ b/leetcode/leetcode/check-if-two-string-arrays-are-equivalent/check-if-two-string-arrays-are-equivalent.java
@@ -0,0 +1,5 @@
+class Solution {
+    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
+        return String.join("",word1).equals(String.join("",word2));
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/climbing-stairs/README.md b/leetcode/leetcode/climbing-stairs/README.md
new file mode 100644
index 0000000..057c39e
--- /dev/null
+++ b/leetcode/leetcode/climbing-stairs/README.md
@@ -0,0 +1,31 @@
+<h2>70. Climbing Stairs</h2><h3>Easy</h3><hr><div><p>You are climbing a staircase. It takes <code>n</code> steps to reach the top.</p>
+
+<p>Each time you can either climb <code>1</code> or <code>2</code> steps. In how many distinct ways can you climb to the top?</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There are two ways to climb to the top.
+1. 1 step + 1 step
+2. 2 steps
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> There are three ways to climb to the top.
+1. 1 step + 1 step + 1 step
+2. 1 step + 2 steps
+3. 2 steps + 1 step
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 45</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/climbing-stairs/climbing-stairs.cpp b/leetcode/leetcode/climbing-stairs/climbing-stairs.cpp
new file mode 100644
index 0000000..6bb2d37
--- /dev/null
+++ b/leetcode/leetcode/climbing-stairs/climbing-stairs.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int climbStairs(int n) {
+    if(n <=2){
+        return n;
+    }
+    int n1 = 2;
+    int n2 = 1;
+    int res = 0;
+    for(int i=2; i<n; i++){
+    	res = n1 + n2;
+    	n2 = n1;
+        n1 = res;
+    }
+    return res;
+    }
+};
\ No newline at end of file
diff --git a/leetcode/leetcode/climbing-stairs/climbing-stairs.java b/leetcode/leetcode/climbing-stairs/climbing-stairs.java
new file mode 100644
index 0000000..653fcc5
--- /dev/null
+++ b/leetcode/leetcode/climbing-stairs/climbing-stairs.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int climbStairs(int n) {
+    if(n <=2){
+        return n;
+    }
+    int n1 = 2;
+    int n2 = 1;
+    int res = 0;
+    for(int i=2; i<n; i++){
+    	res = n1 + n2;
+    	n2 = n1;
+        n1 = res;
+    }
+    return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/complement-of-base-10-integer/README.md b/leetcode/leetcode/complement-of-base-10-integer/README.md
new file mode 100644
index 0000000..536580d
--- /dev/null
+++ b/leetcode/leetcode/complement-of-base-10-integer/README.md
@@ -0,0 +1,40 @@
+<h2>1009. Complement of Base 10 Integer</h2><h3>Easy</h3><hr><div><p>The <strong>complement</strong> of an integer is the integer you get when you flip all the <code>0</code>'s to <code>1</code>'s and all the <code>1</code>'s to <code>0</code>'s in its binary representation.</p>
+
+<ul>
+	<li>For example, The integer <code>5</code> is <code>"101"</code> in binary and its <strong>complement</strong> is <code>"010"</code> which is the integer <code>2</code>.</li>
+</ul>
+
+<p>Given an integer <code>n</code>, return <em>its complement</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 5 is "101" in binary, with complement "010" in binary, which is 2 in base-10.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 7
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> 7 is "111" in binary, with complement "000" in binary, which is 0 in base-10.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 10
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> 10 is "1010" in binary, with complement "0101" in binary, which is 5 in base-10.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt; 10<sup>9</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as 476: <a href="https://leetcode.com/problems/number-complement/" target="_blank">https://leetcode.com/problems/number-complement/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/complement-of-base-10-integer/complement-of-base-10-integer.java b/leetcode/leetcode/complement-of-base-10-integer/complement-of-base-10-integer.java
new file mode 100644
index 0000000..b96a31f
--- /dev/null
+++ b/leetcode/leetcode/complement-of-base-10-integer/complement-of-base-10-integer.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int bitwiseComplement(int n) {
+        if(n==0) return 1;
+        int res = 0;
+        int c = 0;
+        while(n!=0){
+            if(n%2==0) res += (int)Math.pow(2,c);
+            c++;
+            n = n/2;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/complex-number-multiplication/README.md b/leetcode/leetcode/complex-number-multiplication/README.md
new file mode 100644
index 0000000..d4b11e0
--- /dev/null
+++ b/leetcode/leetcode/complex-number-multiplication/README.md
@@ -0,0 +1,32 @@
+<h2>537. Complex Number Multiplication</h2><h3>Medium</h3><hr><div><p>A <a href="https://en.wikipedia.org/wiki/Complex_number" target="_blank">complex number</a> can be represented as a string on the form <code>"<strong>real</strong>+<strong>imaginary</strong>i"</code> where:</p>
+
+<ul>
+	<li><code>real</code> is the real part and is an integer in the range <code>[-100, 100]</code>.</li>
+	<li><code>imaginary</code> is the imaginary part and is an integer in the range <code>[-100, 100]</code>.</li>
+	<li><code>i<sup>2</sup> == -1</code>.</li>
+</ul>
+
+<p>Given two complex numbers <code>num1</code> and <code>num2</code> as strings, return <em>a string of the complex number that represents their multiplications</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num1 = "1+1i", num2 = "1+1i"
+<strong>Output:</strong> "0+2i"
+<strong>Explanation:</strong> (1 + i) * (1 + i) = 1 + i2 + 2 * i = 2i, and you need convert it to the form of 0+2i.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num1 = "1+-1i", num2 = "1+-1i"
+<strong>Output:</strong> "0+-2i"
+<strong>Explanation:</strong> (1 - i) * (1 - i) = 1 + i2 - 2 * i = -2i, and you need convert it to the form of 0+-2i.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>num1</code> and <code>num2</code> are valid complex numbers.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/complex-number-multiplication/complex-number-multiplication.java b/leetcode/leetcode/complex-number-multiplication/complex-number-multiplication.java
new file mode 100644
index 0000000..45916ea
--- /dev/null
+++ b/leetcode/leetcode/complex-number-multiplication/complex-number-multiplication.java
@@ -0,0 +1,9 @@
+class Solution {
+    public String complexNumberMultiply(String num1, String num2) {
+        int a = Integer.parseInt(num1.substring(0,num1.indexOf("+")));
+        int b = Integer.parseInt(num1.substring(num1.indexOf("+")+1,num1.length() -1));
+        int c = Integer.parseInt(num2.substring(0,num2.indexOf("+")));
+        int d = Integer.parseInt(num2.substring(num2.indexOf("+")+1,num2.length() -1));
+        return String.valueOf(a*c - b*d) + "+" + String.valueOf(a*d+b*c) + "i";
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/concatenation-of-array/README.md b/leetcode/leetcode/concatenation-of-array/README.md
new file mode 100644
index 0000000..776fb33
--- /dev/null
+++ b/leetcode/leetcode/concatenation-of-array/README.md
@@ -0,0 +1,33 @@
+<h2>1929. Concatenation of Array</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> of length <code>n</code>, you want to create an array <code>ans</code> of length <code>2n</code> where <code>ans[i] == nums[i]</code> and <code>ans[i + n] == nums[i]</code> for <code>0 &lt;= i &lt; n</code> (<strong>0-indexed</strong>).</p>
+
+<p>Specifically, <code>ans</code> is the <strong>concatenation</strong> of two <code>nums</code> arrays.</p>
+
+<p>Return <em>the array </em><code>ans</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,1]
+<strong>Output:</strong> [1,2,1,1,2,1]
+<strong>Explanation:</strong> The array ans is formed as follows:
+- ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
+- ans = [1,2,1,1,2,1]</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3,2,1]
+<strong>Output:</strong> [1,3,2,1,1,3,2,1]
+<strong>Explanation:</strong> The array ans is formed as follows:
+- ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
+- ans = [1,3,2,1,1,3,2,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 1000</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/concatenation-of-array/concatenation-of-array.java b/leetcode/leetcode/concatenation-of-array/concatenation-of-array.java
new file mode 100644
index 0000000..db377da
--- /dev/null
+++ b/leetcode/leetcode/concatenation-of-array/concatenation-of-array.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int[] getConcatenation(int[] nums) {
+        int[] result = new int[2*nums.length];
+        boolean reset = true;
+        int counter= 0;
+        for(int i = 0;i<2*nums.length;i++){
+            result[i] = nums[counter];
+            counter++;
+            if(counter == nums.length && reset){
+                counter=0;
+                reset = false;
+            }
+            
+        }
+        return result;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/consecutive-characters/README.md b/leetcode/leetcode/consecutive-characters/README.md
new file mode 100644
index 0000000..561fd51
--- /dev/null
+++ b/leetcode/leetcode/consecutive-characters/README.md
@@ -0,0 +1,45 @@
+<h2>1446. Consecutive Characters</h2><h3>Easy</h3><hr><div><p>The <strong>power</strong> of the string is the maximum length of a non-empty substring that contains only one unique character.</p>
+
+<p>Given a string <code>s</code>, return <em>the <strong>power</strong> of</em> <code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "leetcode"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The substring "ee" is of length 2 with the character 'e' only.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "abbcccddddeeeeedcba"
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The substring "eeeee" is of length 5 with the character 'e' only.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "triplepillooooow"
+<strong>Output:</strong> 5
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> s = "hooraaaaaaaaaaay"
+<strong>Output:</strong> 11
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> s = "tourist"
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 500</code></li>
+	<li><code>s</code> consists of only lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/consecutive-characters/consecutive-characters.java b/leetcode/leetcode/consecutive-characters/consecutive-characters.java
new file mode 100644
index 0000000..36b8c18
--- /dev/null
+++ b/leetcode/leetcode/consecutive-characters/consecutive-characters.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int maxPower(String s) {
+        int max = 1;
+        int current = 0;
+        for(int i = 0;i<s.length()-1;i++){
+            if(s.charAt(i) == s.charAt(i+1)){
+                current++;
+            }else{
+                if(current>=max) max = current+1;
+                current = 0;
+            }
+        }
+        if(current>=max) max = current+1;
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/contains-duplicate/README.md b/leetcode/leetcode/contains-duplicate/README.md
new file mode 100644
index 0000000..3c222d4
--- /dev/null
+++ b/leetcode/leetcode/contains-duplicate/README.md
@@ -0,0 +1,21 @@
+<h2>217. Contains Duplicate</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code>, return <code>true</code> if any value appears <strong>at least twice</strong> in the array, and return <code>false</code> if every element is distinct.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3,1]
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> false
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,1,3,3,4,3,2,4,2]
+<strong>Output:</strong> true
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/contains-duplicate/contains-duplicate.java b/leetcode/leetcode/contains-duplicate/contains-duplicate.java
new file mode 100644
index 0000000..da5b60d
--- /dev/null
+++ b/leetcode/leetcode/contains-duplicate/contains-duplicate.java
@@ -0,0 +1,10 @@
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> set =  new HashSet<>();
+        for(int i = 0;i<nums.length;i++){
+            if(set.contains(nums[i])) return true;
+            set.add(nums[i]);
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/convert-1d-array-into-2d-array/README.md b/leetcode/leetcode/convert-1d-array-into-2d-array/README.md
new file mode 100644
index 0000000..8d163f1
--- /dev/null
+++ b/leetcode/leetcode/convert-1d-array-into-2d-array/README.md
@@ -0,0 +1,53 @@
+<h2>2022. Convert 1D Array Into 2D Array</h2><h3>Easy</h3><hr><div><p>You are given a <strong>0-indexed</strong> 1-dimensional (1D) integer array <code>original</code>, and two integers, <code>m</code> and <code>n</code>. You are tasked with creating a 2-dimensional (2D) array with <code> m</code> rows and <code>n</code> columns using <strong>all</strong> the elements from <code>original</code>.</p>
+
+<p>The elements from indices <code>0</code> to <code>n - 1</code> (<strong>inclusive</strong>) of <code>original</code> should form the first row of the constructed 2D array, the elements from indices <code>n</code> to <code>2 * n - 1</code> (<strong>inclusive</strong>) should form the second row of the constructed 2D array, and so on.</p>
+
+<p>Return <em>an </em><code>m x n</code><em> 2D array constructed according to the above procedure, or an empty 2D array if it is impossible</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2021/08/26/image-20210826114243-1.png" style="width: 500px; height: 174px;">
+<pre><strong>Input:</strong> original = [1,2,3,4], m = 2, n = 2
+<strong>Output:</strong> [[1,2],[3,4]]
+<strong>Explanation:
+</strong>The constructed 2D array should contain 2 rows and 2 columns.
+The first group of n=2 elements in original, [1,2], becomes the first row in the constructed 2D array.
+The second group of n=2 elements in original, [3,4], becomes the second row in the constructed 2D array.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> original = [1,2,3], m = 1, n = 3
+<strong>Output:</strong> [[1,2,3]]
+<b>Explanation:</b>
+The constructed 2D array should contain 1 row and 3 columns.
+Put all three elements in original into the first row of the constructed 2D array.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> original = [1,2], m = 1, n = 1
+<strong>Output:</strong> []
+<strong>Explanation:
+</strong>There are 2 elements in original.
+It is impossible to fit 2 elements in a 1x1 2D array, so return an empty 2D array.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> original = [3], m = 1, n = 2
+<strong>Output:</strong> []
+<strong>Explanation:</strong>
+There is 1 element in original.
+It is impossible to make 1 element fill all the spots in a 1x2 2D array, so return an empty 2D array.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= original.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= original[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= m, n &lt;= 4 * 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/convert-1d-array-into-2d-array/convert-1d-array-into-2d-array.java b/leetcode/leetcode/convert-1d-array-into-2d-array/convert-1d-array-into-2d-array.java
new file mode 100644
index 0000000..cb335df
--- /dev/null
+++ b/leetcode/leetcode/convert-1d-array-into-2d-array/convert-1d-array-into-2d-array.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int[][] construct2DArray(int[] original, int m, int n) {
+        if(original.length != m*n) return new int[0][0];
+        int[][] res = new int[m][n];
+        int c1 = 0;
+        int c2 = 0;
+        for(int i=0;i<original.length;i++) res[i/n][i%n] = original[i];
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/convert-binary-number-in-a-linked-list-to-integer/README.md b/leetcode/leetcode/convert-binary-number-in-a-linked-list-to-integer/README.md
new file mode 100644
index 0000000..d1ba6d7
--- /dev/null
+++ b/leetcode/leetcode/convert-binary-number-in-a-linked-list-to-integer/README.md
@@ -0,0 +1,44 @@
+<h2>1290. Convert Binary Number in a Linked List to Integer</h2><h3>Easy</h3><hr><div><p>Given <code>head</code> which is a reference node to&nbsp;a singly-linked list. The value of each node in the linked list is either 0 or 1. The linked list holds the binary representation of a number.</p>
+
+<p>Return the <em>decimal value</em> of the number in the linked list.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/12/05/graph-1.png" style="width: 426px; height: 108px;">
+<pre><strong>Input:</strong> head = [1,0,1]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> (101) in base 2 = (5) in base 10
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [0]
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]
+<strong>Output:</strong> 18880
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> head = [0,0]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The Linked List is not empty.</li>
+	<li>Number of nodes&nbsp;will not exceed <code>30</code>.</li>
+	<li>Each node's value is either&nbsp;<code>0</code> or <code>1</code>.</li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/convert-binary-number-in-a-linked-list-to-integer/convert-binary-number-in-a-linked-list-to-integer.java b/leetcode/leetcode/convert-binary-number-in-a-linked-list-to-integer/convert-binary-number-in-a-linked-list-to-integer.java
new file mode 100644
index 0000000..a4a07b0
--- /dev/null
+++ b/leetcode/leetcode/convert-binary-number-in-a-linked-list-to-integer/convert-binary-number-in-a-linked-list-to-integer.java
@@ -0,0 +1,28 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public int getDecimalValue(ListNode head) {
+        ListNode temp = head;
+        int twoS = 1;
+        while(temp.next!=null){
+            temp = temp.next;
+            twoS = twoS*2;
+        }
+        temp = head;
+        int result= 0;
+        while(temp!=null){
+            result = result + (temp.val)*twoS;
+            twoS = twoS/2;
+            temp = temp.next;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/convert-sorted-array-to-binary-search-tree/README.md b/leetcode/leetcode/convert-sorted-array-to-binary-search-tree/README.md
new file mode 100644
index 0000000..f590b05
--- /dev/null
+++ b/leetcode/leetcode/convert-sorted-array-to-binary-search-tree/README.md
@@ -0,0 +1,29 @@
+<h2>108. Convert Sorted Array to Binary Search Tree</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> where the elements are sorted in <strong>ascending order</strong>, convert <em>it to a <strong>height-balanced</strong> binary search tree</em>.</p>
+
+<p>A <strong>height-balanced</strong> binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than one.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree1.jpg" style="width: 302px; height: 222px;">
+<pre><strong>Input:</strong> nums = [-10,-3,0,5,9]
+<strong>Output:</strong> [0,-3,9,-10,null,5]
+<strong>Explanation:</strong> [0,-10,5,null,-3,null,9] is also accepted:
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree2.jpg" style="width: 302px; height: 222px;">
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/18/btree.jpg" style="width: 342px; height: 142px;">
+<pre><strong>Input:</strong> nums = [1,3]
+<strong>Output:</strong> [3,1]
+<strong>Explanation:</strong> [1,3] and [3,1] are both a height-balanced BSTs.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+	<li><code>nums</code> is sorted in a <strong>strictly increasing</strong> order.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/convert-sorted-array-to-binary-search-tree/convert-sorted-array-to-binary-search-tree.java b/leetcode/leetcode/convert-sorted-array-to-binary-search-tree/convert-sorted-array-to-binary-search-tree.java
new file mode 100644
index 0000000..f10c670
--- /dev/null
+++ b/leetcode/leetcode/convert-sorted-array-to-binary-search-tree/convert-sorted-array-to-binary-search-tree.java
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode sortedArrayToBSTHekper(int[] nums, int start, int end) {
+        if(start>end) return null;
+        int mid = (start+end)/2;
+        TreeNode root = new TreeNode(nums[mid]);
+        root.left = sortedArrayToBSTHekper(nums,start,mid-1);
+        root.right = sortedArrayToBSTHekper(nums,mid+1,end);
+        return root;
+    }
+    public TreeNode sortedArrayToBST(int[] nums) {
+        return sortedArrayToBSTHekper(nums,0,nums.length-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/convert-sorted-list-to-binary-search-tree/README.md b/leetcode/leetcode/convert-sorted-list-to-binary-search-tree/README.md
new file mode 100644
index 0000000..555e148
--- /dev/null
+++ b/leetcode/leetcode/convert-sorted-list-to-binary-search-tree/README.md
@@ -0,0 +1,26 @@
+<h2>109. Convert Sorted List to Binary Search Tree</h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a singly linked list where elements are <strong>sorted in ascending order</strong>, convert it to a height balanced BST.</p>
+
+<p>For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of <em>every</em> node never differ by more than 1.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/17/linked.jpg" style="width: 500px; height: 388px;">
+<pre><strong>Input:</strong> head = [-10,-3,0,5,9]
+<strong>Output:</strong> [0,-3,9,-10,null,5]
+<strong>Explanation:</strong> One possible answer is [0,-3,9,-10,null,5], which represents the shown height balanced BST.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in <code>head</code> is in the range <code>[0, 2 * 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/convert-sorted-list-to-binary-search-tree/convert-sorted-list-to-binary-search-tree.java b/leetcode/leetcode/convert-sorted-list-to-binary-search-tree/convert-sorted-list-to-binary-search-tree.java
new file mode 100644
index 0000000..72d26a9
--- /dev/null
+++ b/leetcode/leetcode/convert-sorted-list-to-binary-search-tree/convert-sorted-list-to-binary-search-tree.java
@@ -0,0 +1,46 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode sortedListToBST(ListNode head) {
+        if(head == null) return null;
+        if(head.next==null) {
+            return new TreeNode(head.val);
+        }
+        ListNode slow = head;
+        ListNode fast = head;
+        ListNode prev = head;
+        while(fast!=null && fast.next!=null){
+            prev = slow;
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        prev.next = null;
+        TreeNode root = new TreeNode(slow.val);
+        root.left = sortedListToBST(head);
+        root.right = sortedListToBST(slow.next);
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/count-complete-tree-nodes/README.md b/leetcode/leetcode/count-complete-tree-nodes/README.md
new file mode 100644
index 0000000..58c6cd2
--- /dev/null
+++ b/leetcode/leetcode/count-complete-tree-nodes/README.md
@@ -0,0 +1,34 @@
+<h2>222. Count Complete Tree Nodes</h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a <strong>complete</strong> binary tree, return the number of the nodes in the tree.</p>
+
+<p>According to <strong><a href="http://en.wikipedia.org/wiki/Binary_tree#Types_of_binary_trees" target="_blank">Wikipedia</a></strong>, every level, except possibly the last, is completely filled in a complete binary tree, and all nodes in the last level are as far left as possible. It can have between <code>1</code> and <code>2<sup>h</sup></code> nodes inclusive at the last level <code>h</code>.</p>
+
+<p>Design an algorithm that runs in less than&nbsp;<code data-stringify-type="code">O(n)</code>&nbsp;time complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/14/complete.jpg" style="width: 372px; height: 302px;">
+<pre><strong>Input:</strong> root = [1,2,3,4,5,6]
+<strong>Output:</strong> 6
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 5 * 10<sup>4</sup></code></li>
+	<li>The tree is guaranteed to be <strong>complete</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/count-complete-tree-nodes/count-complete-tree-nodes.java b/leetcode/leetcode/count-complete-tree-nodes/count-complete-tree-nodes.java
new file mode 100644
index 0000000..593c1a3
--- /dev/null
+++ b/leetcode/leetcode/count-complete-tree-nodes/count-complete-tree-nodes.java
@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int leftDepth(TreeNode root){
+        if(root==null) return 0;
+        int counter = 0;
+        while(root!=null){
+            root = root.left;
+            counter++;
+        }
+        return counter;
+    }
+    public int rightDepth(TreeNode root){
+        if(root==null) return 0;
+        int counter = 0;
+        while(root!=null){
+            root = root.right;
+            counter++;
+        }
+        return counter;
+    }
+    public int countNodes(TreeNode root) {
+        if(root == null) return 0;
+        int lD = leftDepth(root);
+        if(lD == rightDepth(root)){
+            return (int) Math.pow(2,lD) -1;
+        }
+        return 1 + countNodes(root.left) + countNodes(root.right);
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/count-items-matching-a-rule/README.md b/leetcode/leetcode/count-items-matching-a-rule/README.md
new file mode 100644
index 0000000..6aab445
--- /dev/null
+++ b/leetcode/leetcode/count-items-matching-a-rule/README.md
@@ -0,0 +1,36 @@
+<h2>1773. Count Items Matching a Rule</h2><h3>Easy</h3><hr><div><p>You are given an array <code>items</code>, where each <code>items[i] = [type<sub>i</sub>, color<sub>i</sub>, name<sub>i</sub>]</code> describes the type, color, and name of the <code>i<sup>th</sup></code> item. You are also given a rule represented by two strings, <code>ruleKey</code> and <code>ruleValue</code>.</p>
+
+<p>The <code>i<sup>th</sup></code> item is said to match the rule if <strong>one</strong> of the following is true:</p>
+
+<ul>
+	<li><code>ruleKey == "type"</code> and <code>ruleValue == type<sub>i</sub></code>.</li>
+	<li><code>ruleKey == "color"</code> and <code>ruleValue == color<sub>i</sub></code>.</li>
+	<li><code>ruleKey == "name"</code> and <code>ruleValue == name<sub>i</sub></code>.</li>
+</ul>
+
+<p>Return <em>the number of items that match the given rule</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> items = [["phone","blue","pixel"],["computer","silver","lenovo"],["phone","gold","iphone"]], ruleKey = "color", ruleValue = "silver"
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> There is only one item matching the given rule, which is ["computer","silver","lenovo"].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> items = [["phone","blue","pixel"],["computer","silver","phone"],["phone","gold","iphone"]], ruleKey = "type", ruleValue = "phone"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There are only two items matching the given rule, which are ["phone","blue","pixel"] and ["phone","gold","iphone"]. Note that the item ["computer","silver","phone"] does not match.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= items.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= type<sub>i</sub>.length, color<sub>i</sub>.length, name<sub>i</sub>.length, ruleValue.length &lt;= 10</code></li>
+	<li><code>ruleKey</code> is equal to either <code>"type"</code>, <code>"color"</code>, or <code>"name"</code>.</li>
+	<li>All strings consist only of lowercase letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/count-items-matching-a-rule/count-items-matching-a-rule.java b/leetcode/leetcode/count-items-matching-a-rule/count-items-matching-a-rule.java
new file mode 100644
index 0000000..d092e60
--- /dev/null
+++ b/leetcode/leetcode/count-items-matching-a-rule/count-items-matching-a-rule.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int countMatches(List<List<String>> items, String ruleKey, String ruleValue) {
+        int res =0;
+        int counter = 0;
+        if(ruleKey.equals("name")) counter= 2;
+        else if(ruleKey.length() == 5) counter = 1;
+        for(int i = 0;i<items.size();i++){
+            if((items.get(i).get(counter)).equals(ruleValue)) res++;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/count-negative-numbers-in-a-sorted-matrix/README.md b/leetcode/leetcode/count-negative-numbers-in-a-sorted-matrix/README.md
new file mode 100644
index 0000000..d64ea7e
--- /dev/null
+++ b/leetcode/leetcode/count-negative-numbers-in-a-sorted-matrix/README.md
@@ -0,0 +1,40 @@
+<h2>1351. Count Negative Numbers in a Sorted Matrix</h2><h3>Easy</h3><hr><div><p>Given a <code>m x n</code> matrix <code>grid</code> which is sorted in non-increasing order both row-wise and column-wise, return <em>the number of <strong>negative</strong> numbers in</em> <code>grid</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> There are 8 negatives number in the matrix.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[3,2],[1,0]]
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[1,-1],[-1,-1]]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[-1]]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 100</code></li>
+	<li><code>-100 &lt;= grid[i][j] &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you find an <code>O(n + m)</code> solution?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/count-negative-numbers-in-a-sorted-matrix/count-negative-numbers-in-a-sorted-matrix.java b/leetcode/leetcode/count-negative-numbers-in-a-sorted-matrix/count-negative-numbers-in-a-sorted-matrix.java
new file mode 100644
index 0000000..28a8ac9
--- /dev/null
+++ b/leetcode/leetcode/count-negative-numbers-in-a-sorted-matrix/count-negative-numbers-in-a-sorted-matrix.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int countNegatives(int[][] grid) {
+        int result = 0;
+        for(int i = 0;i<grid.length;i++){
+            int counter = grid[i].length-1;
+            while(counter!=-1 && grid[i][counter]<0){
+                result++;
+                counter--;
+            }
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/count-number-of-pairs-with-absolute-difference-k/README.md b/leetcode/leetcode/count-number-of-pairs-with-absolute-difference-k/README.md
new file mode 100644
index 0000000..28be410
--- /dev/null
+++ b/leetcode/leetcode/count-number-of-pairs-with-absolute-difference-k/README.md
@@ -0,0 +1,47 @@
+<h2>2006. Count Number of Pairs With Absolute Difference K</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <em>the number of pairs</em> <code>(i, j)</code> <em>where</em> <code>i &lt; j</code> <em>such that</em> <code>|nums[i] - nums[j]| == k</code>.</p>
+
+<p>The value of <code>|x|</code> is defined as:</p>
+
+<ul>
+	<li><code>x</code> if <code>x &gt;= 0</code>.</li>
+	<li><code>-x</code> if <code>x &lt; 0</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,2,1], k = 1
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The pairs with an absolute difference of 1 are:
+- [<strong><u>1</u></strong>,<strong><u>2</u></strong>,2,1]
+- [<strong><u>1</u></strong>,2,<strong><u>2</u></strong>,1]
+- [1,<strong><u>2</u></strong>,2,<strong><u>1</u></strong>]
+- [1,2,<strong><u>2</u></strong>,<strong><u>1</u></strong>]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3], k = 3
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There are no pairs with an absolute difference of 3.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,2,1,5,4], k = 2
+<strong>Output:</strong> 3
+<b>Explanation:</b> The pairs with an absolute difference of 2 are:
+- [<strong><u>3</u></strong>,2,<strong><u>1</u></strong>,5,4]
+- [<strong><u>3</u></strong>,2,1,<strong><u>5</u></strong>,4]
+- [3,<strong><u>2</u></strong>,1,5,<strong><u>4</u></strong>]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 200</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
+	<li><code>1 &lt;= k &lt;= 99</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/count-number-of-pairs-with-absolute-difference-k/count-number-of-pairs-with-absolute-difference-k.java b/leetcode/leetcode/count-number-of-pairs-with-absolute-difference-k/count-number-of-pairs-with-absolute-difference-k.java
new file mode 100644
index 0000000..4f80a5a
--- /dev/null
+++ b/leetcode/leetcode/count-number-of-pairs-with-absolute-difference-k/count-number-of-pairs-with-absolute-difference-k.java
@@ -0,0 +1,9 @@
+class Solution {
+    public int countKDifference(int[] nums, int k) {
+        int arr[] = new int[200];
+        for(int num: nums) arr[num -1]++;
+        int ans = 0;
+        for(int i = k ;i<200;i++) ans += arr[i]*arr[i-k];
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/count-odd-numbers-in-an-interval-range/README.md b/leetcode/leetcode/count-odd-numbers-in-an-interval-range/README.md
new file mode 100644
index 0000000..4f260d0
--- /dev/null
+++ b/leetcode/leetcode/count-odd-numbers-in-an-interval-range/README.md
@@ -0,0 +1,21 @@
+<h2>1523. Count Odd Numbers in an Interval Range</h2><h3>Easy</h3><hr><div><p>Given two non-negative integers <code>low</code> and <code><font face="monospace">high</font></code>. Return the <em>count of odd numbers between </em><code>low</code><em> and </em><code><font face="monospace">high</font></code><em>&nbsp;(inclusive)</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> low = 3, high = 7
+<strong>Output:</strong> 3
+<b>Explanation: </b>The odd numbers between 3 and 7 are [3,5,7].</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> low = 8, high = 10
+<strong>Output:</strong> 1
+<b>Explanation: </b>The odd numbers between 8 and 10 are [9].</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= low &lt;= high&nbsp;&lt;= 10^9</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/count-odd-numbers-in-an-interval-range/count-odd-numbers-in-an-interval-range.java b/leetcode/leetcode/count-odd-numbers-in-an-interval-range/count-odd-numbers-in-an-interval-range.java
new file mode 100644
index 0000000..11f29a3
--- /dev/null
+++ b/leetcode/leetcode/count-odd-numbers-in-an-interval-range/count-odd-numbers-in-an-interval-range.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int countOdds(int low, int high) {
+        int res = 0;
+        if(low%2!=0) res++;
+        else if(high%2!=0) res++;
+        res+=(high-low)/2;
+        
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/count-primes/README.md b/leetcode/leetcode/count-primes/README.md
new file mode 100644
index 0000000..54b2740
--- /dev/null
+++ b/leetcode/leetcode/count-primes/README.md
@@ -0,0 +1,29 @@
+<h2>204. Count Primes</h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, return <em>the number of prime numbers that are strictly less than</em> <code>n</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 10
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> There are 4 prime numbers less than 10, they are 2, 3, 5, 7.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 0
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 5 * 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/count-primes/count-primes.java b/leetcode/leetcode/count-primes/count-primes.java
new file mode 100644
index 0000000..d545791
--- /dev/null
+++ b/leetcode/leetcode/count-primes/count-primes.java
@@ -0,0 +1,19 @@
+class Solution {  
+    public int countPrimes(int n) {
+        if(n<=1) return 0;
+        boolean[] notPrime = new boolean[n];
+        int res = 0;
+        for(int i = 2;i< Math.sqrt(n);i++){
+            if(notPrime[i]== false){
+                for(int j = i*i;j<n;j=j+i){
+                     if(!(notPrime[j])){
+                         notPrime[j] = true;
+                         res++;
+                     }
+                    
+                }
+            }
+        }
+        return n-res-2;
+    }
+}
diff --git a/leetcode/leetcode/create-target-array-in-the-given-order/README.md b/leetcode/leetcode/create-target-array-in-the-given-order/README.md
new file mode 100644
index 0000000..dc4e95b
--- /dev/null
+++ b/leetcode/leetcode/create-target-array-in-the-given-order/README.md
@@ -0,0 +1,55 @@
+<h2>1389. Create Target Array in the Given Order</h2><h3>Easy</h3><hr><div><p>Given two arrays of integers&nbsp;<code>nums</code> and <code>index</code>. Your task is to create <em>target</em> array under the following rules:</p>
+
+<ul>
+	<li>Initially <em>target</em> array is empty.</li>
+	<li>From left to right read nums[i] and index[i], insert at index <code>index[i]</code>&nbsp;the value <code>nums[i]</code>&nbsp;in&nbsp;<em>target</em> array.</li>
+	<li>Repeat the previous step until there are no elements to read in <code>nums</code> and <code>index.</code></li>
+</ul>
+
+<p>Return the <em>target</em> array.</p>
+
+<p>It is guaranteed that the insertion operations will be valid.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1,2,3,4], index = [0,1,2,2,1]
+<strong>Output:</strong> [0,4,1,3,2]
+<strong>Explanation:</strong>
+nums       index     target
+0            0        [0]
+1            1        [0,1]
+2            2        [0,1,2]
+3            2        [0,1,3,2]
+4            1        [0,4,1,3,2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,0], index = [0,1,2,3,0]
+<strong>Output:</strong> [0,1,2,3,4]
+<strong>Explanation:</strong>
+nums       index     target
+1            0        [1]
+2            1        [1,2]
+3            2        [1,2,3]
+4            3        [1,2,3,4]
+0            0        [0,1,2,3,4]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1], index = [0]
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length, index.length &lt;= 100</code></li>
+	<li><code>nums.length == index.length</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 100</code></li>
+	<li><code>0 &lt;= index[i] &lt;= i</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/create-target-array-in-the-given-order/create-target-array-in-the-given-order.java b/leetcode/leetcode/create-target-array-in-the-given-order/create-target-array-in-the-given-order.java
new file mode 100644
index 0000000..5d0510d
--- /dev/null
+++ b/leetcode/leetcode/create-target-array-in-the-given-order/create-target-array-in-the-given-order.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] createTargetArray(int[] nums, int[] index) {
+        int[] result =  new int[nums.length];
+        int counter = 0;
+        while(counter<nums.length){
+            if(counter>index[counter]){
+                for(int i = counter;i!=index[counter];i--){
+                    result[i] = result[i-1];
+                }
+                
+            }
+            result[index[counter]] = nums[counter];
+            counter++;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/delete-leaves-with-a-given-value/README.md b/leetcode/leetcode/delete-leaves-with-a-given-value/README.md
new file mode 100644
index 0000000..50dc740
--- /dev/null
+++ b/leetcode/leetcode/delete-leaves-with-a-given-value/README.md
@@ -0,0 +1,53 @@
+<h2>1325. Delete Leaves With a Given Value</h2><h3>Medium</h3><hr><div><p>Given a binary tree&nbsp;<code>root</code>&nbsp;and an integer&nbsp;<code>target</code>, delete all the&nbsp;<strong>leaf nodes</strong>&nbsp;with value <code>target</code>.</p>
+
+<p>Note&nbsp;that once you delete a leaf node with value <code>target</code><strong>,&nbsp;</strong>if it's parent node becomes a leaf node and has the value <code><font face="monospace">target</font></code>, it should also be deleted (you need to continue doing that until you can't).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/01/09/sample_1_1684.png" style="width: 550px; height: 120px;"></strong></p>
+
+<pre><strong>Input:</strong> root = [1,2,3,2,null,2,4], target = 2
+<strong>Output:</strong> [1,null,3,null,4]
+<strong>Explanation:</strong> Leaf nodes in green with value (target = 2) are removed (Picture in left). 
+After removing, new nodes become leaf nodes with value (target = 2) (Picture in center).
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/01/09/sample_2_1684.png" style="width: 300px; height: 120px;"></strong></p>
+
+<pre><strong>Input:</strong> root = [1,3,3,3,2], target = 3
+<strong>Output:</strong> [1,3,null,null,2]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/01/15/sample_3_1684.png" style="width: 420px; height: 150px;"></strong></p>
+
+<pre><strong>Input:</strong> root = [1,2,null,2,null,2], target = 2
+<strong>Output:</strong> [1]
+<strong>Explanation:</strong> Leaf nodes in green with value (target = 2) are removed at each step.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,1,1], target = 1
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,2,3], target = 1
+<strong>Output:</strong> [1,2,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= target&nbsp;&lt;= 1000</code></li>
+	<li>The&nbsp;given binary tree will have between&nbsp;<code>1</code>&nbsp;and&nbsp;<code>3000</code>&nbsp;nodes.</li>
+	<li>Each node's value is between <code>[1, 1000]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/delete-leaves-with-a-given-value/delete-leaves-with-a-given-value.java b/leetcode/leetcode/delete-leaves-with-a-given-value/delete-leaves-with-a-given-value.java
new file mode 100644
index 0000000..5805adc
--- /dev/null
+++ b/leetcode/leetcode/delete-leaves-with-a-given-value/delete-leaves-with-a-given-value.java
@@ -0,0 +1,24 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode removeLeafNodes(TreeNode root, int target) {
+        if(root==null) return null;
+        root.left = removeLeafNodes(root.left, target);
+        root.right = removeLeafNodes(root.right, target);
+        if(root.val == target && root.left == null && root.right == null) return null;
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/delete-node-in-a-linked-list/README.md b/leetcode/leetcode/delete-node-in-a-linked-list/README.md
new file mode 100644
index 0000000..87760a2
--- /dev/null
+++ b/leetcode/leetcode/delete-node-in-a-linked-list/README.md
@@ -0,0 +1,47 @@
+<h2>237. Delete Node in a Linked List</h2><h3>Easy</h3><hr><div><p>Write a function to <strong>delete a node</strong> in a singly-linked list. You will <strong>not</strong> be given access to the <code>head</code> of the list, instead you will be given access to <strong>the node to be deleted</strong> directly.</p>
+
+<p>It is <strong>guaranteed</strong> that the node to be deleted is <strong>not a tail node</strong> in the list.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/node1.jpg" style="width: 450px; height: 322px;">
+<pre><strong>Input:</strong> head = [4,5,1,9], node = 5
+<strong>Output:</strong> [4,1,9]
+<strong>Explanation: </strong>You are given the second node with value 5, the linked list should become 4 -&gt; 1 -&gt; 9 after calling your function.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/node2.jpg" style="width: 450px; height: 354px;">
+<pre><strong>Input:</strong> head = [4,5,1,9], node = 1
+<strong>Output:</strong> [4,5,9]
+<strong>Explanation: </strong>You are given the third node with value 1, the linked list should become 4 -&gt; 5 -&gt; 9 after calling your function.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,2,3,4], node = 3
+<strong>Output:</strong> [1,2,4]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> head = [0,1], node = 0
+<strong>Output:</strong> [1]
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> head = [-3,5,-99], node = -3
+<strong>Output:</strong> [5,-99]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of the nodes in the given list is in the range <code>[2, 1000]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+	<li>The value of each node in the list is <strong>unique</strong>.</li>
+	<li>The <code>node</code> to be deleted is <strong>in the list</strong> and is <strong>not a tail</strong> node</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/delete-node-in-a-linked-list/delete-node-in-a-linked-list.java b/leetcode/leetcode/delete-node-in-a-linked-list/delete-node-in-a-linked-list.java
new file mode 100644
index 0000000..0e4d4fb
--- /dev/null
+++ b/leetcode/leetcode/delete-node-in-a-linked-list/delete-node-in-a-linked-list.java
@@ -0,0 +1,14 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public void deleteNode(ListNode node) {
+        node.val = (node.next).val;
+        node.next = (node.next).next;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/delete-the-middle-node-of-a-linked-list/README.md b/leetcode/leetcode/delete-the-middle-node-of-a-linked-list/README.md
new file mode 100644
index 0000000..d3344a3
--- /dev/null
+++ b/leetcode/leetcode/delete-the-middle-node-of-a-linked-list/README.md
@@ -0,0 +1,45 @@
+<h2>2095. Delete the Middle Node of a Linked List</h2><h3>Medium</h3><hr><div><p>You are given the <code>head</code> of a linked list. <strong>Delete</strong> the <strong>middle node</strong>, and return <em>the</em> <code>head</code> <em>of the modified linked list</em>.</p>
+
+<p>The <strong>middle node</strong> of a linked list of size <code>n</code> is the <code>⌊n / 2⌋<sup>th</sup></code> node from the <b>start</b> using <strong>0-based indexing</strong>, where <code>⌊x⌋</code> denotes the largest integer less than or equal to <code>x</code>.</p>
+
+<ul>
+	<li>For <code>n</code> = <code>1</code>, <code>2</code>, <code>3</code>, <code>4</code>, and <code>5</code>, the middle nodes are <code>0</code>, <code>1</code>, <code>1</code>, <code>2</code>, and <code>2</code>, respectively.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/16/eg1drawio.png" style="width: 500px; height: 77px;">
+<pre><strong>Input:</strong> head = [1,3,4,7,1,2,6]
+<strong>Output:</strong> [1,3,4,1,2,6]
+<strong>Explanation:</strong>
+The above figure represents the given linked list. The indices of the nodes are written below.
+Since n = 7, node 3 with value 7 is the middle node, which is marked in red.
+We return the new list after removing this node. 
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/16/eg2drawio.png" style="width: 250px; height: 43px;">
+<pre><strong>Input:</strong> head = [1,2,3,4]
+<strong>Output:</strong> [1,2,4]
+<strong>Explanation:</strong>
+The above figure represents the given linked list.
+For n = 4, node 2 with value 3 is the middle node, which is marked in red.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/16/eg3drawio.png" style="width: 150px; height: 58px;">
+<pre><strong>Input:</strong> head = [2,1]
+<strong>Output:</strong> [2]
+<strong>Explanation:</strong>
+The above figure represents the given linked list.
+For n = 2, node 1 with value 1 is the middle node, which is marked in red.
+Node 0 with value 2 is the only node remaining after removing node 1.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/delete-the-middle-node-of-a-linked-list/delete-the-middle-node-of-a-linked-list.java b/leetcode/leetcode/delete-the-middle-node-of-a-linked-list/delete-the-middle-node-of-a-linked-list.java
new file mode 100644
index 0000000..23c09a1
--- /dev/null
+++ b/leetcode/leetcode/delete-the-middle-node-of-a-linked-list/delete-the-middle-node-of-a-linked-list.java
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode deleteMiddle(ListNode head) {
+        if(head==null || head.next ==  null) return null;
+        ListNode slow = head;
+        ListNode fast = head;
+        ListNode prev = null;
+        while(fast!=null && fast.next != null){
+            prev = slow;
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        prev.next = slow.next;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/design-a-stack-with-increment-operation/README.md b/leetcode/leetcode/design-a-stack-with-increment-operation/README.md
new file mode 100644
index 0000000..892b0cf
--- /dev/null
+++ b/leetcode/leetcode/design-a-stack-with-increment-operation/README.md
@@ -0,0 +1,46 @@
+<h2>1381. Design a Stack With Increment Operation</h2><h3>Medium</h3><hr><div><p>Design a stack which supports the following operations.</p>
+
+<p>Implement the <code>CustomStack</code> class:</p>
+
+<ul>
+	<li><code>CustomStack(int maxSize)</code> Initializes the object with <code>maxSize</code> which is the maximum number of elements in the stack or do nothing if the stack reached the <code>maxSize</code>.</li>
+	<li><code>void push(int x)</code>&nbsp;Adds <code>x</code> to the top of the stack if the stack hasn't reached the <code>maxSize</code>.</li>
+	<li><code>int pop()</code>&nbsp;Pops and returns the top of stack or <strong>-1</strong> if the stack is empty.</li>
+	<li><code>void inc(int k, int val)</code> Increments the bottom <code>k</code> elements of the stack by <code>val</code>. If there are less than <code>k</code> elements in the stack, just increment all the elements in the stack.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["CustomStack","push","push","pop","push","push","push","increment","increment","pop","pop","pop","pop"]
+[[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]
+<strong>Output</strong>
+[null,null,null,2,null,null,null,null,null,103,202,201,-1]
+<strong>Explanation</strong>
+CustomStack customStack = new CustomStack(3); // Stack is Empty []
+customStack.push(1);                          // stack becomes [1]
+customStack.push(2);                          // stack becomes [1, 2]
+customStack.pop();                            // return 2 --&gt; Return top of the stack 2, stack becomes [1]
+customStack.push(2);                          // stack becomes [1, 2]
+customStack.push(3);                          // stack becomes [1, 2, 3]
+customStack.push(4);                          // stack still [1, 2, 3], Don't add another elements as size is 4
+customStack.increment(5, 100);                // stack becomes [101, 102, 103]
+customStack.increment(2, 100);                // stack becomes [201, 202, 103]
+customStack.pop();                            // return 103 --&gt; Return top of the stack 103, stack becomes [201, 202]
+customStack.pop();                            // return 202 --&gt; Return top of the stack 102, stack becomes [201]
+customStack.pop();                            // return 201 --&gt; Return top of the stack 101, stack becomes []
+customStack.pop();                            // return -1 --&gt; Stack is empty return -1.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= maxSize &lt;= 1000</code></li>
+	<li><code>1 &lt;= x &lt;= 1000</code></li>
+	<li><code>1 &lt;= k &lt;= 1000</code></li>
+	<li><code>0 &lt;= val &lt;= 100</code></li>
+	<li>At most&nbsp;<code>1000</code>&nbsp;calls will be made to each method of <code>increment</code>, <code>push</code> and <code>pop</code> each separately.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/design-a-stack-with-increment-operation/design-a-stack-with-increment-operation.java b/leetcode/leetcode/design-a-stack-with-increment-operation/design-a-stack-with-increment-operation.java
new file mode 100644
index 0000000..b885d7e
--- /dev/null
+++ b/leetcode/leetcode/design-a-stack-with-increment-operation/design-a-stack-with-increment-operation.java
@@ -0,0 +1,41 @@
+class CustomStack {
+    private int[] arr;
+    private int nextIndex;
+    private int fixSize;
+
+    public CustomStack(int maxSize) {
+        arr = new int[maxSize];
+        nextIndex = 0;
+        fixSize = maxSize;
+    }
+    
+    public void push(int x) {
+        if(nextIndex ==fixSize ){
+            return;
+        }
+        arr[nextIndex] = x;
+        nextIndex++;
+    }
+    
+    public int pop() {
+        if(nextIndex==0) return -1;
+        nextIndex--;
+        return arr[nextIndex];
+    }
+    
+    public void increment(int k, int val) {
+        int counter = 0;
+        while(counter<k && counter<nextIndex){
+            arr[counter] = arr[counter] + val;
+            counter++;
+        }
+    }
+}
+
+/**
+ * Your CustomStack object will be instantiated and called as such:
+ * CustomStack obj = new CustomStack(maxSize);
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * obj.increment(k,val);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/design-browser-history/README.md b/leetcode/leetcode/design-browser-history/README.md
new file mode 100644
index 0000000..84c2147
--- /dev/null
+++ b/leetcode/leetcode/design-browser-history/README.md
@@ -0,0 +1,45 @@
+<h2>1472. Design Browser History</h2><h3>Medium</h3><hr><div><p>You have a <strong>browser</strong> of one tab where you start on the <code>homepage</code> and you can visit another <code>url</code>, get back in the history number of <code>steps</code> or move forward in the history number of <code>steps</code>.</p>
+
+<p>Implement the <code>BrowserHistory</code> class:</p>
+
+<ul>
+	<li><code>BrowserHistory(string homepage)</code> Initializes the object with the <code>homepage</code>&nbsp;of the browser.</li>
+	<li><code>void visit(string url)</code>&nbsp;Visits&nbsp;<code>url</code> from the current page. It clears up all the forward history.</li>
+	<li><code>string back(int steps)</code>&nbsp;Move <code>steps</code> back in history. If you can only return <code>x</code> steps in the history and <code>steps &gt; x</code>, you will&nbsp;return only <code>x</code> steps. Return the current <code>url</code>&nbsp;after moving back in history <strong>at most</strong> <code>steps</code>.</li>
+	<li><code>string forward(int steps)</code>&nbsp;Move <code>steps</code> forward in history. If you can only forward <code>x</code> steps in the history and <code>steps &gt; x</code>, you will&nbsp;forward only&nbsp;<code>x</code> steps. Return the current <code>url</code>&nbsp;after forwarding in history <strong>at most</strong> <code>steps</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example:</strong></p>
+
+<pre><b>Input:</b>
+["BrowserHistory","visit","visit","visit","back","back","forward","visit","forward","back","back"]
+[["leetcode.com"],["google.com"],["facebook.com"],["youtube.com"],[1],[1],[1],["linkedin.com"],[2],[2],[7]]
+<b>Output:</b>
+[null,null,null,null,"facebook.com","google.com","facebook.com",null,"linkedin.com","google.com","leetcode.com"]
+
+<b>Explanation:</b>
+BrowserHistory browserHistory = new BrowserHistory("leetcode.com");
+browserHistory.visit("google.com");       // You are in "leetcode.com". Visit "google.com"
+browserHistory.visit("facebook.com");     // You are in "google.com". Visit "facebook.com"
+browserHistory.visit("youtube.com");      // You are in "facebook.com". Visit "youtube.com"
+browserHistory.back(1);                   // You are in "youtube.com", move back to "facebook.com" return "facebook.com"
+browserHistory.back(1);                   // You are in "facebook.com", move back to "google.com" return "google.com"
+browserHistory.forward(1);                // You are in "google.com", move forward to "facebook.com" return "facebook.com"
+browserHistory.visit("linkedin.com");     // You are in "facebook.com". Visit "linkedin.com"
+browserHistory.forward(2);                // You are in "linkedin.com", you cannot move forward any steps.
+browserHistory.back(2);                   // You are in "linkedin.com", move back two steps to "facebook.com" then to "google.com". return "google.com"
+browserHistory.back(7);                   // You are in "google.com", you can move back only one step to "leetcode.com". return "leetcode.com"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= homepage.length &lt;= 20</code></li>
+	<li><code>1 &lt;= url.length &lt;= 20</code></li>
+	<li><code>1 &lt;= steps &lt;= 100</code></li>
+	<li><code>homepage</code> and <code>url</code> consist of&nbsp; '.' or lower case English letters.</li>
+	<li>At most <code>5000</code>&nbsp;calls will be made to <code>visit</code>, <code>back</code>, and <code>forward</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/design-browser-history/design-browser-history.java b/leetcode/leetcode/design-browser-history/design-browser-history.java
new file mode 100644
index 0000000..58d940f
--- /dev/null
+++ b/leetcode/leetcode/design-browser-history/design-browser-history.java
@@ -0,0 +1,44 @@
+class BrowserHistory {
+    public Stack<String> future;
+    public Stack<String> history;
+    int size = 1;
+    public BrowserHistory(String homepage) {
+        history=new Stack<String>();
+        history.push(homepage);
+        future = new Stack<String>();
+    }
+    
+    public void visit(String url) {
+        history.push(url);
+        future = new Stack<String>();
+        size++;
+    }
+    
+    public String back(int steps) {
+        while(steps>0 && size>1){
+            future.push(history.peek());
+            history.pop();
+            --steps;
+            size--;
+        }
+        return history.peek();
+    }
+    
+    public String forward(int steps) {
+        while(steps>0 && !future.empty()){
+            history.push(future.peek());
+            future.pop();
+            --steps;
+            size++;
+        }
+        return history.peek();
+    }
+}
+
+/**
+ * Your BrowserHistory object will be instantiated and called as such:
+ * BrowserHistory obj = new BrowserHistory(homepage);
+ * obj.visit(url);
+ * String param_2 = obj.back(steps);
+ * String param_3 = obj.forward(steps);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/design-circular-queue/README.md b/leetcode/leetcode/design-circular-queue/README.md
new file mode 100644
index 0000000..cf7c485
--- /dev/null
+++ b/leetcode/leetcode/design-circular-queue/README.md
@@ -0,0 +1,50 @@
+[Discussion Post (created on 18/11/2021 at 16:31)](https://leetcode.com/problems/design-circular-queue/discuss/1633913/JAVA)  
+<h2>622. Design Circular Queue</h2><h3>Medium</h3><hr><div><p>Design your implementation of the circular queue. The circular queue is a linear data structure in which the operations are performed based on FIFO (First In First Out) principle and the last position is connected back to the first position to make a circle. It is also called "Ring Buffer".</p>
+
+<p>One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.</p>
+
+<p>Implementation the <code>MyCircularQueue</code> class:</p>
+
+<ul>
+	<li><code>MyCircularQueue(k)</code> Initializes the object with the size of the queue to be <code>k</code>.</li>
+	<li><code>int Front()</code> Gets the front item from the queue. If the queue is empty, return <code>-1</code>.</li>
+	<li><code>int Rear()</code> Gets the last item from the queue. If the queue is empty, return <code>-1</code>.</li>
+	<li><code>boolean enQueue(int value)</code> Inserts an element into the circular queue. Return <code>true</code> if the operation is successful.</li>
+	<li><code>boolean deQueue()</code> Deletes an element from the circular queue. Return <code>true</code> if the operation is successful.</li>
+	<li><code>boolean isEmpty()</code> Checks whether the circular queue is empty or not.</li>
+	<li><code>boolean isFull()</code> Checks whether the circular queue is full or not.</li>
+</ul>
+
+<p>You must solve the problem without using the built-in queue data structure in your programming language.&nbsp;</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["MyCircularQueue", "enQueue", "enQueue", "enQueue", "enQueue", "Rear", "isFull", "deQueue", "enQueue", "Rear"]
+[[3], [1], [2], [3], [4], [], [], [], [4], []]
+<strong>Output</strong>
+[null, true, true, true, false, 3, true, true, true, 4]
+
+<strong>Explanation</strong>
+MyCircularQueue myCircularQueue = new MyCircularQueue(3);
+myCircularQueue.enQueue(1); // return True
+myCircularQueue.enQueue(2); // return True
+myCircularQueue.enQueue(3); // return True
+myCircularQueue.enQueue(4); // return False
+myCircularQueue.Rear();     // return 3
+myCircularQueue.isFull();   // return True
+myCircularQueue.deQueue();  // return True
+myCircularQueue.enQueue(4); // return True
+myCircularQueue.Rear();     // return 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= 1000</code></li>
+	<li><code>0 &lt;= value &lt;= 1000</code></li>
+	<li>At most <code>3000</code> calls will be made to&nbsp;<code>enQueue</code>, <code>deQueue</code>,&nbsp;<code>Front</code>,&nbsp;<code>Rear</code>,&nbsp;<code>isEmpty</code>, and&nbsp;<code>isFull</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/design-circular-queue/design-circular-queue.java b/leetcode/leetcode/design-circular-queue/design-circular-queue.java
new file mode 100644
index 0000000..d6710f0
--- /dev/null
+++ b/leetcode/leetcode/design-circular-queue/design-circular-queue.java
@@ -0,0 +1,66 @@
+class MyCircularQueue {
+    public int arr[];
+    public int front;
+    public int next;
+    public int currentSize;
+    public int totalSize;
+    public MyCircularQueue(int k) {
+        arr = new int[k];
+        front = -1;
+        next = 0;
+        totalSize = k;
+        currentSize = 0;
+    }
+    
+    public boolean enQueue(int value) {
+        if(currentSize == totalSize){
+            return false;
+        }
+        arr[next] = value;
+        next = (next+1)%totalSize;
+        if(front == -1) front = 0;
+        currentSize++;
+        return true;
+    }
+    
+    public boolean deQueue() {
+        if(currentSize==0) return false;
+        front = (front+1)%totalSize;
+        currentSize--;
+        if(currentSize==0){
+            front = -1;
+            next = 0;
+        }
+        return true;
+    }
+    
+    public int Front() {
+        if(currentSize==0) return -1;
+        return arr[front];
+    }
+    
+    public int Rear() {
+        if(currentSize==0) return -1;
+        if(next == 0) return arr[totalSize-1];
+        return arr[next-1];
+    }
+    
+    public boolean isEmpty() {
+        return currentSize==0;
+    }
+    
+    public boolean isFull() {
+        return currentSize==totalSize;
+    }
+}
+
+/**
+ * Your MyCircularQueue object will be instantiated and called as such:
+ * MyCircularQueue obj = new MyCircularQueue(k);
+ * boolean param_1 = obj.enQueue(value);
+ * boolean param_2 = obj.deQueue();
+ * int param_3 = obj.Front();
+ * int param_4 = obj.Rear();
+ * boolean param_5 = obj.isEmpty();
+ * boolean param_6 = obj.isFull();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/design-linked-list/README.md b/leetcode/leetcode/design-linked-list/README.md
new file mode 100644
index 0000000..a6e93b8
--- /dev/null
+++ b/leetcode/leetcode/design-linked-list/README.md
@@ -0,0 +1,43 @@
+<h2>707. Design Linked List</h2><h3>Medium</h3><hr><div><p>Design your implementation of the linked list. You can choose to use a singly or doubly linked list.<br>
+A node in a singly linked list should have two attributes: <code>val</code> and <code>next</code>. <code>val</code> is the value of the current node, and <code>next</code> is a pointer/reference to the next node.<br>
+If you want to use the doubly linked list, you will need one more attribute <code>prev</code> to indicate the previous node in the linked list. Assume all nodes in the linked list are <strong>0-indexed</strong>.</p>
+
+<p>Implement the <code>MyLinkedList</code> class:</p>
+
+<ul>
+	<li><code>MyLinkedList()</code> Initializes the <code>MyLinkedList</code> object.</li>
+	<li><code>int get(int index)</code> Get the value of the <code>index<sup>th</sup></code> node in the linked list. If the index is invalid, return <code>-1</code>.</li>
+	<li><code>void addAtHead(int val)</code> Add a node of value <code>val</code> before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.</li>
+	<li><code>void addAtTail(int val)</code> Append a node of value <code>val</code> as the last element of the linked list.</li>
+	<li><code>void addAtIndex(int index, int val)</code> Add a node of value <code>val</code> before the <code>index<sup>th</sup></code> node in the linked list. If <code>index</code> equals the length of the linked list, the node will be appended to the end of the linked list. If <code>index</code> is greater than the length, the node <strong>will not be inserted</strong>.</li>
+	<li><code>void deleteAtIndex(int index)</code> Delete the <code>index<sup>th</sup></code> node in the linked list, if the index is valid.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
+[[], [1], [3], [1, 2], [1], [1], [1]]
+<strong>Output</strong>
+[null, null, null, null, 2, null, 3]
+
+<strong>Explanation</strong>
+MyLinkedList myLinkedList = new MyLinkedList();
+myLinkedList.addAtHead(1);
+myLinkedList.addAtTail(3);
+myLinkedList.addAtIndex(1, 2);    // linked list becomes 1-&gt;2-&gt;3
+myLinkedList.get(1);              // return 2
+myLinkedList.deleteAtIndex(1);    // now the linked list is 1-&gt;3
+myLinkedList.get(1);              // return 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= index, val &lt;= 1000</code></li>
+	<li>Please do not use the built-in LinkedList library.</li>
+	<li>At most <code>2000</code> calls will be made to <code>get</code>, <code>addAtHead</code>, <code>addAtTail</code>, <code>addAtIndex</code> and <code>deleteAtIndex</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/design-linked-list/design-linked-list.java b/leetcode/leetcode/design-linked-list/design-linked-list.java
new file mode 100644
index 0000000..fa4d277
--- /dev/null
+++ b/leetcode/leetcode/design-linked-list/design-linked-list.java
@@ -0,0 +1,105 @@
+class MyLinkedList {
+    class Node{
+        int val;
+        Node next;
+        Node(int value){
+            val = value;
+            next = null;
+        }
+    }
+    
+    Node head;
+    Node tail;
+    int size;
+    public MyLinkedList() {
+        head = tail = null;
+        size = 0;
+    }
+    
+    public int get(int index) {
+        if(index<0 || index>=size) return -1;
+        Node temp = head;
+        int counter = 0;
+        while(counter<index){
+            temp  =temp.next;
+            counter++;
+        }
+        return temp.val;
+    }
+    
+    public void addAtHead(int val) {
+        Node temp = new Node(val);
+        if(size == 0){
+            head = tail = temp;
+        }else{
+        temp.next = head;
+        head = temp;
+        }
+        size++;
+        
+    }
+    
+    public void addAtTail(int val) {
+        Node temp = new Node(val);
+        if(size==0){
+            head = tail = temp;
+        }else{
+        tail.next = temp;
+        tail = temp;
+        }
+        size++;
+    }
+    
+    public void addAtIndex(int index, int val) {
+        if(index == size) addAtTail(val);
+        else if(index==0) addAtHead(val);
+        else if(index<0 || index>size) return;
+        else{
+            Node temp = head;
+            int counter = 0;
+            while(counter<index-1){
+                counter++;
+                temp = temp.next;
+            }
+            Node temp2 = new Node(val);
+            temp2.next = temp.next;
+            temp.next = temp2;
+            size++;
+        }
+        
+    }
+    
+    public void deleteAtIndex(int index) {
+        if(index<0||index>=size) return;
+        else if(index==0){
+            head = head.next;
+            size--;
+            return;
+        }
+        Node temp = head;
+        int counter = 0;
+        while(counter<index-1){
+            temp = temp.next;
+            counter++;
+        }
+        if(index ==size-1){
+            temp.next = null;
+            tail =temp;
+            size--;
+        }else{
+            temp.next = (temp.next).next;
+            size--;
+        }
+
+    }
+}
+
+/**
+ * Your MyLinkedList object will be instantiated and called as such:
+ * MyLinkedList obj = new MyLinkedList();
+ * int param_1 = obj.get(index);
+ * obj.addAtHead(val);
+ * obj.addAtTail(val);
+ * obj.addAtIndex(index,val);
+ * obj.deleteAtIndex(index);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/destroying-asteroids/README.md b/leetcode/leetcode/destroying-asteroids/README.md
new file mode 100644
index 0000000..77e9c5a
--- /dev/null
+++ b/leetcode/leetcode/destroying-asteroids/README.md
@@ -0,0 +1,38 @@
+<h2>2126. Destroying Asteroids</h2><h3>Medium</h3><hr><div><p>You are given an integer <code>mass</code>, which represents the original mass of a planet. You are further given an integer array <code>asteroids</code>, where <code>asteroids[i]</code> is the mass of the <code>i<sup>th</sup></code> asteroid.</p>
+
+<p>You can arrange for the planet to collide with the asteroids in <strong>any arbitrary order</strong>. If the mass of the planet is <b>greater than or equal to</b> the mass of the asteroid, the asteroid is <strong>destroyed</strong> and the planet <strong>gains</strong> the mass of the asteroid. Otherwise, the planet is destroyed.</p>
+
+<p>Return <code>true</code><em> if <strong>all</strong> asteroids can be destroyed. Otherwise, return </em><code>false</code><em>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> mass = 10, asteroids = [3,9,19,5,21]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> One way to order the asteroids is [9,19,5,3,21]:
+- The planet collides with the asteroid with a mass of 9. New planet mass: 10 + 9 = 19
+- The planet collides with the asteroid with a mass of 19. New planet mass: 19 + 19 = 38
+- The planet collides with the asteroid with a mass of 5. New planet mass: 38 + 5 = 43
+- The planet collides with the asteroid with a mass of 3. New planet mass: 43 + 3 = 46
+- The planet collides with the asteroid with a mass of 21. New planet mass: 46 + 21 = 67
+All asteroids are destroyed.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> mass = 5, asteroids = [4,9,23,4]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> 
+The planet cannot ever gain enough mass to destroy the asteroid with a mass of 23.
+After the planet destroys the other asteroids, it will have a mass of 5 + 4 + 9 + 4 = 22.
+This is less than 23, so a collision would not destroy the last asteroid.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= mass &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= asteroids.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= asteroids[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/destroying-asteroids/destroying-asteroids.java b/leetcode/leetcode/destroying-asteroids/destroying-asteroids.java
new file mode 100644
index 0000000..532d311
--- /dev/null
+++ b/leetcode/leetcode/destroying-asteroids/destroying-asteroids.java
@@ -0,0 +1,11 @@
+class Solution {
+    public boolean asteroidsDestroyed(int mass, int[] asteroids) {
+        Arrays.sort(asteroids);
+        long val = mass;
+        for(int i=0;i<asteroids.length;i++){
+            if(val<asteroids[i]) return false;
+            val+=asteroids[i];
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/detect-capital/README.md b/leetcode/leetcode/detect-capital/README.md
new file mode 100644
index 0000000..8416e09
--- /dev/null
+++ b/leetcode/leetcode/detect-capital/README.md
@@ -0,0 +1,26 @@
+<h2>520. Detect Capital</h2><h3>Easy</h3><hr><div><p>We define the usage of capitals in a word to be right when one of the following cases holds:</p>
+
+<ul>
+	<li>All letters in this word are capitals, like <code>"USA"</code>.</li>
+	<li>All letters in this word are not capitals, like <code>"leetcode"</code>.</li>
+	<li>Only the first letter in this word is capital, like <code>"Google"</code>.</li>
+</ul>
+
+<p>Given a string <code>word</code>, return <code>true</code> if the usage of capitals in it is right.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> word = "USA"
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> word = "FlaG"
+<strong>Output:</strong> false
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= word.length &lt;= 100</code></li>
+	<li><code>word</code> consists of lowercase and uppercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/detect-capital/detect-capital.java b/leetcode/leetcode/detect-capital/detect-capital.java
new file mode 100644
index 0000000..1de9dd1
--- /dev/null
+++ b/leetcode/leetcode/detect-capital/detect-capital.java
@@ -0,0 +1,25 @@
+class Solution {
+    public boolean detectCapitalUse(String word) {
+        int noOfCapital = 0;
+        boolean first = false;
+        
+        int counter = 0;
+        while(counter<word.length()){
+            if(word.charAt(counter) > 64 && word.charAt(counter)<91){
+                noOfCapital++;
+                if(!first){
+                    first = true;
+                    if(counter!= 0){
+                        return false;
+                    }
+                }
+            }
+            counter++;
+        }
+        if(noOfCapital == word.length() || noOfCapital == 1 || noOfCapital==0){
+            return true;
+        }
+        return false;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/diameter-of-binary-tree/README.md b/leetcode/leetcode/diameter-of-binary-tree/README.md
new file mode 100644
index 0000000..cde9546
--- /dev/null
+++ b/leetcode/leetcode/diameter-of-binary-tree/README.md
@@ -0,0 +1,28 @@
+<h2>543. Diameter of Binary Tree</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the length of the <strong>diameter</strong> of the tree</em>.</p>
+
+<p>The <strong>diameter</strong> of a binary tree is the <strong>length</strong> of the longest path between any two nodes in a tree. This path may or may not pass through the <code>root</code>.</p>
+
+<p>The <strong>length</strong> of a path between two nodes is represented by the number of edges between them.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/06/diamtree.jpg" style="width: 292px; height: 302px;">
+<pre><strong>Input:</strong> root = [1,2,3,4,5]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 3 is the length of the path [4,2,1,3] or [5,2,1,3].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,2]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/diameter-of-binary-tree/diameter-of-binary-tree.java b/leetcode/leetcode/diameter-of-binary-tree/diameter-of-binary-tree.java
new file mode 100644
index 0000000..1facd3d
--- /dev/null
+++ b/leetcode/leetcode/diameter-of-binary-tree/diameter-of-binary-tree.java
@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public Pair<Integer,Integer> heightDiameter(TreeNode root){
+        if(root==null){
+            Pair<Integer, Integer> p1 = new Pair<>(0,0);
+            return p1;
+        }
+        Pair<Integer,Integer> output1 = heightDiameter(root.left);
+        Pair<Integer,Integer> output2 = heightDiameter(root.right);
+        int lh = output1.getKey();
+        int ld = output1.getValue();
+        int rh = output2.getKey();
+        int rd = output2.getValue();
+        Pair<Integer, Integer> output3 = new Pair<Integer, Integer>(Math.max(lh,rh)+1, Math.max(lh+rh, Math.max(ld,rd)));
+        return output3;
+        
+    }
+    public int diameterOfBinaryTree(TreeNode root) {
+        return heightDiameter(root).getValue();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/encode-and-decode-tinyurl/README.md b/leetcode/leetcode/encode-and-decode-tinyurl/README.md
new file mode 100644
index 0000000..1ee2338
--- /dev/null
+++ b/leetcode/leetcode/encode-and-decode-tinyurl/README.md
@@ -0,0 +1,35 @@
+[Discussion Post (created on 13/8/2021 at 13:52)](https://leetcode.com/problems/encode-and-decode-tinyurl/discuss/1460841/Java-Time%3A-1-ms-(96.50)-Space%3A-38.9-MB-(82.56))  
+<h2>535. Encode and Decode TinyURL</h2><h3>Medium</h3><hr><div><blockquote>Note: This is a companion problem to the <a href="https://leetcode.com/discuss/interview-question/system-design/" target="_blank">System Design</a> problem: <a href="https://leetcode.com/discuss/interview-question/124658/Design-a-URL-Shortener-(-TinyURL-)-System/" target="_blank">Design TinyURL</a>.</blockquote>
+
+<p>TinyURL is a URL shortening service where you enter a URL such as <code>https://leetcode.com/problems/design-tinyurl</code> and it returns a short URL such as <code>http://tinyurl.com/4e9iAk</code>. Design a class to encode a URL and decode a tiny URL.</p>
+
+<p>There is no restriction on how your encode/decode algorithm should work. You just need to ensure that a URL can be encoded to a tiny URL and the tiny URL can be decoded to the original URL.</p>
+
+<p>Implement the <code>Solution</code> class:</p>
+
+<ul>
+	<li><code>Solution()</code> Initializes the object of the system.</li>
+	<li><code>String encode(String longUrl)</code> Returns a tiny URL for the given <code>longUrl</code>.</li>
+	<li><code>String decode(String shortUrl)</code> Returns the original long URL for the given <code>shortUrl</code>. It is guaranteed that the given <code>shortUrl</code> was encoded by the same object.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> url = "https://leetcode.com/problems/design-tinyurl"
+<strong>Output:</strong> "https://leetcode.com/problems/design-tinyurl"
+
+<strong>Explanation:</strong>
+Solution obj = new Solution();
+string tiny = obj.encode(url); // returns the encoded tiny url.
+string ans = obj.decode(tiny); // returns the original url after deconding it.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= url.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>url</code> is guranteed to be a valid URL.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/encode-and-decode-tinyurl/encode-and-decode-tinyurl.java b/leetcode/leetcode/encode-and-decode-tinyurl/encode-and-decode-tinyurl.java
new file mode 100644
index 0000000..b048b3c
--- /dev/null
+++ b/leetcode/leetcode/encode-and-decode-tinyurl/encode-and-decode-tinyurl.java
@@ -0,0 +1,31 @@
+public class Codec {
+    
+    public static HashMap <String, String> map =  new HashMap<>();
+    public static int counter = 1;
+
+    // Encodes a URL to a shortened URL.
+    public String encode(String longUrl) {
+        String res = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
+        StringBuilder result = new StringBuilder();
+        result.append("http://tinyurl.com/");
+        int temp = counter;
+        int index;
+        while(temp!=0){
+            index = temp%62;
+            result.append(res.charAt(index));
+            temp = temp/62;
+        }
+        counter++;
+        map.put(result.toString(),longUrl);
+        return result.toString();
+    }
+
+    // Decodes a shortened URL to its original URL.
+    public String decode(String shortUrl) {
+        return map.get(shortUrl);
+    }
+}
+
+// Your Codec object will be instantiated and called as such:
+// Codec codec = new Codec();
+// codec.decode(codec.encode(url));
\ No newline at end of file
diff --git a/leetcode/leetcode/fibonacci-number/README.md b/leetcode/leetcode/fibonacci-number/README.md
new file mode 100644
index 0000000..3dfc343
--- /dev/null
+++ b/leetcode/leetcode/fibonacci-number/README.md
@@ -0,0 +1,37 @@
+<h2>509. Fibonacci Number</h2><h3>Easy</h3><hr><div><p>The <b>Fibonacci numbers</b>, commonly denoted <code>F(n)</code> form a sequence, called the <b>Fibonacci sequence</b>, such that each number is the sum of the two preceding ones, starting from <code>0</code> and <code>1</code>. That is,</p>
+
+<pre>F(0) = 0, F(1) = 1
+F(n) = F(n - 1) + F(n - 2), for n &gt; 1.
+</pre>
+
+<p>Given <code>n</code>, calculate <code>F(n)</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> F(2) = F(1) + F(0) = 1 + 0 = 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> F(3) = F(2) + F(1) = 1 + 1 = 2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> F(4) = F(3) + F(2) = 2 + 1 = 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 30</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/fibonacci-number/fibonacci-number.java b/leetcode/leetcode/fibonacci-number/fibonacci-number.java
new file mode 100644
index 0000000..d6aa801
--- /dev/null
+++ b/leetcode/leetcode/fibonacci-number/fibonacci-number.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int fib(int n) {
+        if(n<=1) return n;
+        int s1 = 0;
+        int s2 = 1;
+        int res = 0;
+        int counter = 0;
+        while(counter<n-1){
+            res = s1+ s2;
+            s1 = s2;
+            s2 = res;
+            counter++;
+        }
+        return res;
+    }
+}
diff --git a/leetcode/leetcode/final-value-of-variable-after-performing-operations/README.md b/leetcode/leetcode/final-value-of-variable-after-performing-operations/README.md
new file mode 100644
index 0000000..47c3b31
--- /dev/null
+++ b/leetcode/leetcode/final-value-of-variable-after-performing-operations/README.md
@@ -0,0 +1,54 @@
+<h2>2011. Final Value of Variable After Performing Operations</h2><h3>Easy</h3><hr><div><p>There is a programming language with only <strong>four</strong> operations and <strong>one</strong> variable <code>X</code>:</p>
+
+<ul>
+	<li><code>++X</code> and <code>X++</code> <strong>increments</strong> the value of the variable <code>X</code> by <code>1</code>.</li>
+	<li><code>--X</code> and <code>X--</code> <strong>decrements</strong> the value of the variable <code>X</code> by <code>1</code>.</li>
+</ul>
+
+<p>Initially, the value of <code>X</code> is <code>0</code>.</p>
+
+<p>Given an array of strings <code>operations</code> containing a list of operations, return <em>the <strong>final </strong>value of </em><code>X</code> <em>after performing all the operations</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> operations = ["--X","X++","X++"]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong>&nbsp;The operations are performed as follows:
+Initially, X = 0.
+--X: X is decremented by 1, X =  0 - 1 = -1.
+X++: X is incremented by 1, X = -1 + 1 =  0.
+X++: X is incremented by 1, X =  0 + 1 =  1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> operations = ["++X","++X","X++"]
+<strong>Output:</strong> 3
+<strong>Explanation: </strong>The operations are performed as follows:
+Initially, X = 0.
+++X: X is incremented by 1, X = 0 + 1 = 1.
+++X: X is incremented by 1, X = 1 + 1 = 2.
+X++: X is incremented by 1, X = 2 + 1 = 3.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> operations = ["X++","++X","--X","X--"]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong>&nbsp;The operations are performed as follows:
+Initially, X = 0.
+X++: X is incremented by 1, X = 0 + 1 = 1.
+++X: X is incremented by 1, X = 1 + 1 = 2.
+--X: X is decremented by 1, X = 2 - 1 = 1.
+X--: X is decremented by 1, X = 1 - 1 = 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= operations.length &lt;= 100</code></li>
+	<li><code>operations[i]</code> will be either <code>"++X"</code>, <code>"X++"</code>, <code>"--X"</code>, or <code>"X--"</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/final-value-of-variable-after-performing-operations/final-value-of-variable-after-performing-operations.java b/leetcode/leetcode/final-value-of-variable-after-performing-operations/final-value-of-variable-after-performing-operations.java
new file mode 100644
index 0000000..7a4e985
--- /dev/null
+++ b/leetcode/leetcode/final-value-of-variable-after-performing-operations/final-value-of-variable-after-performing-operations.java
@@ -0,0 +1,9 @@
+class Solution {
+    public int finalValueAfterOperations(String[] operations) {
+        int val = 0;
+        for(int i = 0;i<operations.length;i++)
+            if(operations[i].contains("-")) val--;
+            else val++;
+        return val;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/find-all-duplicates-in-an-array/README.md b/leetcode/leetcode/find-all-duplicates-in-an-array/README.md
new file mode 100644
index 0000000..b99e5b7
--- /dev/null
+++ b/leetcode/leetcode/find-all-duplicates-in-an-array/README.md
@@ -0,0 +1,25 @@
+<h2>442. Find All Duplicates in an Array</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> of length <code>n</code> where all the integers of <code>nums</code> are in the range <code>[1, n]</code> and each integer appears <strong>once</strong> or <strong>twice</strong>, return <em>an array of all the integers that appears <strong>twice</strong></em>.</p>
+
+<p>You must write an algorithm that runs in&nbsp;<code>O(n)&nbsp;</code>time and uses only constant extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [4,3,2,7,8,2,3,1]
+<strong>Output:</strong> [2,3]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,2]
+<strong>Output:</strong> [1]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> []
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= n</code></li>
+	<li>Each element in <code>nums</code> appears <strong>once</strong> or <strong>twice</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/find-all-duplicates-in-an-array/find-all-duplicates-in-an-array.java b/leetcode/leetcode/find-all-duplicates-in-an-array/find-all-duplicates-in-an-array.java
new file mode 100644
index 0000000..499f655
--- /dev/null
+++ b/leetcode/leetcode/find-all-duplicates-in-an-array/find-all-duplicates-in-an-array.java
@@ -0,0 +1,21 @@
+class Solution {
+    public List<Integer> findDuplicates(int[] arr) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int i = 0;i<arr.length;i++){
+            if(map.containsKey(arr[i])){
+                int val = map.get(arr[i]);
+                val++;
+                map.put(arr[i], val);
+            }else{
+                map.put(arr[i],1);
+            }
+        }
+        ArrayList<Integer> list = new ArrayList<>();
+        for (Map.Entry ele : map.entrySet()) {
+            if((int)ele.getValue()>1){
+                list.add((int)ele.getKey());
+            }
+        }
+        return list;
+    }
+}
diff --git a/leetcode/leetcode/find-first-and-last-position-of-element-in-sorted-array/README.md b/leetcode/leetcode/find-first-and-last-position-of-element-in-sorted-array/README.md
new file mode 100644
index 0000000..f765d7e
--- /dev/null
+++ b/leetcode/leetcode/find-first-and-last-position-of-element-in-sorted-array/README.md
@@ -0,0 +1,28 @@
+[Discussion Post (created on 25/1/2022 at 19:3)](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/discuss/1798742/Java-Fastest-100)  
+<h2>34. Find First and Last Position of Element in Sorted Array</h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>nums</code> sorted in non-decreasing order, find the starting and ending position of a given <code>target</code> value.</p>
+
+<p>If <code>target</code> is not found in the array, return <code>[-1, -1]</code>.</p>
+
+<p>You must&nbsp;write an algorithm with&nbsp;<code>O(log n)</code> runtime complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [5,7,7,8,8,10], target = 8
+<strong>Output:</strong> [3,4]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [5,7,7,8,8,10], target = 6
+<strong>Output:</strong> [-1,-1]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [], target = 0
+<strong>Output:</strong> [-1,-1]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup>&nbsp;&lt;= nums[i]&nbsp;&lt;= 10<sup>9</sup></code></li>
+	<li><code>nums</code> is a non-decreasing array.</li>
+	<li><code>-10<sup>9</sup>&nbsp;&lt;= target&nbsp;&lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/find-first-and-last-position-of-element-in-sorted-array/find-first-and-last-position-of-element-in-sorted-array.java b/leetcode/leetcode/find-first-and-last-position-of-element-in-sorted-array/find-first-and-last-position-of-element-in-sorted-array.java
new file mode 100644
index 0000000..c9ebc5f
--- /dev/null
+++ b/leetcode/leetcode/find-first-and-last-position-of-element-in-sorted-array/find-first-and-last-position-of-element-in-sorted-array.java
@@ -0,0 +1,36 @@
+class Solution {
+    public int[] searchRange(int[] arr, int target) {
+        int low = 0;
+        int high = arr.length - 1;
+        int[] res = {-1,-1};
+        
+        int mid = (low+high)/2;
+        while(low<=high){
+            if(arr[mid] == target){
+                res[0] = mid;
+                high = mid -1;
+            }else if(arr[mid] > target){
+                high = mid - 1;
+            }else if(arr[mid]<target){
+                low = mid+1;
+            }
+            mid = (low+high)/2;
+        }
+        if(res[0]==-1) return res;
+        low = 0;
+        high = arr.length -1;
+        while(low<=high){
+            if(arr[mid] == target){
+                res[1] = mid;
+                low = mid +1;
+            }else if(arr[mid] > target){
+                high = mid - 1;
+            }else if(arr[mid]<target){
+                low = mid+1;
+            }
+            mid = (low+high)/2;
+        }
+        return res;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/find-first-palindromic-string-in-the-array/README.md b/leetcode/leetcode/find-first-palindromic-string-in-the-array/README.md
new file mode 100644
index 0000000..850add1
--- /dev/null
+++ b/leetcode/leetcode/find-first-palindromic-string-in-the-array/README.md
@@ -0,0 +1,37 @@
+[Discussion Post (created on 19/11/2021 at 22:20)](https://leetcode.com/problems/find-first-palindromic-string-in-the-array/discuss/1636350/JAVA)  
+<h2>2108. Find First Palindromic String in the Array</h2><h3>Easy</h3><hr><div><p>Given an array of strings <code>words</code>, return <em>the first <strong>palindromic</strong> string in the array</em>. If there is no such string, return <em>an <strong>empty string</strong> </em><code>""</code>.</p>
+
+<p>A string is <strong>palindromic</strong> if it reads the same forward and backward.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> words = ["abc","car","ada","racecar","cool"]
+<strong>Output:</strong> "ada"
+<strong>Explanation:</strong> The first string that is palindromic is "ada".
+Note that "racecar" is also palindromic, but it is not the first.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words = ["notapalindrome","racecar"]
+<strong>Output:</strong> "racecar"
+<strong>Explanation:</strong> The first and only string that is palindromic is "racecar".
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> words = ["def","ghi"]
+<strong>Output:</strong> ""
+<strong>Explanation:</strong> There are no palindromic strings, so the empty string is returned.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= words.length &lt;= 100</code></li>
+	<li><code>1 &lt;= words[i].length &lt;= 100</code></li>
+	<li><code>words[i]</code> consists only of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/find-first-palindromic-string-in-the-array/find-first-palindromic-string-in-the-array.java b/leetcode/leetcode/find-first-palindromic-string-in-the-array/find-first-palindromic-string-in-the-array.java
new file mode 100644
index 0000000..df0d941
--- /dev/null
+++ b/leetcode/leetcode/find-first-palindromic-string-in-the-array/find-first-palindromic-string-in-the-array.java
@@ -0,0 +1,18 @@
+class Solution {
+    boolean isPalidrome(String s){
+        int i = 0;
+        int j = s.length() - 1;
+        while(i<j){
+            if(!(s.charAt(i) == s.charAt(j))) return false;
+            i++;
+            j--;
+        }
+        return true;
+    }
+    public String firstPalindrome(String[] words) {
+        for(String s: words){
+            if(isPalidrome(s)) return s;
+        }
+        return "";
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/find-minimum-in-rotated-sorted-array/README.md b/leetcode/leetcode/find-minimum-in-rotated-sorted-array/README.md
new file mode 100644
index 0000000..54c6b9f
--- /dev/null
+++ b/leetcode/leetcode/find-minimum-in-rotated-sorted-array/README.md
@@ -0,0 +1,46 @@
+<h2>153. Find Minimum in Rotated Sorted Array</h2><h3>Medium</h3><hr><div><p>Suppose an array of length <code>n</code> sorted in ascending order is <strong>rotated</strong> between <code>1</code> and <code>n</code> times. For example, the array <code>nums = [0,1,2,4,5,6,7]</code> might become:</p>
+
+<ul>
+	<li><code>[4,5,6,7,0,1,2]</code> if it was rotated <code>4</code> times.</li>
+	<li><code>[0,1,2,4,5,6,7]</code> if it was rotated <code>7</code> times.</li>
+</ul>
+
+<p>Notice that <strong>rotating</strong> an array <code>[a[0], a[1], a[2], ..., a[n-1]]</code> 1 time results in the array <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code>.</p>
+
+<p>Given the sorted rotated array <code>nums</code> of <strong>unique</strong> elements, return <em>the minimum element of this array</em>.</p>
+
+<p>You must write an algorithm that runs in&nbsp;<code>O(log n) time.</code></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,4,5,1,2]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The original array was [1,2,3,4,5] rotated 3 times.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [4,5,6,7,0,1,2]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The original array was [0,1,2,4,5,6,7] and it was rotated 4 times.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [11,13,15,17]
+<strong>Output:</strong> 11
+<strong>Explanation:</strong> The original array was [11,13,15,17] and it was rotated 4 times. 
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 5000</code></li>
+	<li><code>-5000 &lt;= nums[i] &lt;= 5000</code></li>
+	<li>All the integers of <code>nums</code> are <strong>unique</strong>.</li>
+	<li><code>nums</code> is sorted and rotated between <code>1</code> and <code>n</code> times.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/find-minimum-in-rotated-sorted-array/find-minimum-in-rotated-sorted-array.java b/leetcode/leetcode/find-minimum-in-rotated-sorted-array/find-minimum-in-rotated-sorted-array.java
new file mode 100644
index 0000000..411810a
--- /dev/null
+++ b/leetcode/leetcode/find-minimum-in-rotated-sorted-array/find-minimum-in-rotated-sorted-array.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int findMin(int[] arr) {
+        if (arr.length == 1) return arr[0];
+        int left = 0;
+        int right = arr.length-1;
+        if(arr[left]<arr[right]) return arr[0];
+        while(left<=right){
+            int mid = (left+right)/2;
+            if(arr[mid]>arr[mid+1]){
+                return arr[mid+1];
+            }else if(arr[mid]<arr[mid-1]){
+                return arr[mid];
+            }else if(arr[left]<arr[mid]){
+                left = mid+1;
+            }else{
+                right = mid-1;
+            }
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/find-pivot-index/README.md b/leetcode/leetcode/find-pivot-index/README.md
new file mode 100644
index 0000000..8e04546
--- /dev/null
+++ b/leetcode/leetcode/find-pivot-index/README.md
@@ -0,0 +1,47 @@
+<h2>724. Find Pivot Index</h2><h3>Easy</h3><hr><div><p>Given an array of integers <code>nums</code>, calculate the <strong>pivot index</strong> of this array.</p>
+
+<p>The <strong>pivot index</strong> is the index where the sum of all the numbers <strong>strictly</strong> to the left of the index is equal to the sum of all the numbers <strong>strictly</strong> to the index's right.</p>
+
+<p>If the index is on the left edge of the array, then the left sum is <code>0</code> because there are no elements to the left. This also applies to the right edge of the array.</p>
+
+<p>Return <em>the <strong>leftmost pivot index</strong></em>. If no such index exists, return -1.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,7,3,6,5,6]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+The pivot index is 3.
+Left sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11
+Right sum = nums[4] + nums[5] = 5 + 6 = 11
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong>
+There is no index that satisfies the conditions in the problem statement.</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,1,-1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong>
+The pivot index is 0.
+Left sum = 0 (no elements to the left of index 0)
+Right sum = nums[1] + nums[2] = 1 + -1 = 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as&nbsp;1991:&nbsp;<a href="https://leetcode.com/problems/find-the-middle-index-in-array/" target="_blank">https://leetcode.com/problems/find-the-middle-index-in-array/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/find-pivot-index/find-pivot-index.java b/leetcode/leetcode/find-pivot-index/find-pivot-index.java
new file mode 100644
index 0000000..aa802c3
--- /dev/null
+++ b/leetcode/leetcode/find-pivot-index/find-pivot-index.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int pivotIndex(int[] nums) {
+        int sum = 0;
+        for(int i =1;i<nums.length;i++) sum = sum + nums[i];
+        int left = 0;
+        int counter = 1;
+        while(left!=sum && counter<nums.length){
+            left += nums[counter-1];
+            sum = sum - nums[counter];    
+            counter++;
+        }
+        if(left==sum) return counter-1;
+        return -1;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/find-the-duplicate-number/README.md b/leetcode/leetcode/find-the-duplicate-number/README.md
new file mode 100644
index 0000000..4b0c25c
--- /dev/null
+++ b/leetcode/leetcode/find-the-duplicate-number/README.md
@@ -0,0 +1,38 @@
+<h2>287. Find the Duplicate Number</h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>nums</code> containing&nbsp;<code>n + 1</code> integers where each integer is in the range <code>[1, n]</code> inclusive.</p>
+
+<p>There is only <strong>one repeated number</strong> in <code>nums</code>, return <em>this&nbsp;repeated&nbsp;number</em>.</p>
+
+<p>You must solve the problem <strong>without</strong> modifying the array <code>nums</code>&nbsp;and uses only constant extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,3,4,2,2]
+<strong>Output:</strong> 2
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [3,1,3,4,2]
+<strong>Output:</strong> 3
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1]
+<strong>Output:</strong> 1
+</pre><p><strong>Example 4:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,2]
+<strong>Output:</strong> 1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums.length == n + 1</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= n</code></li>
+	<li>All the integers in <code>nums</code> appear only <strong>once</strong> except for <strong>precisely one integer</strong> which appears <strong>two or more</strong> times.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><b>Follow up:</b></p>
+
+<ul>
+	<li>How can we prove that at least one duplicate number must exist in <code>nums</code>?</li>
+	<li>Can you solve the problem in linear runtime complexity?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/find-the-duplicate-number/find-the-duplicate-number.java b/leetcode/leetcode/find-the-duplicate-number/find-the-duplicate-number.java
new file mode 100644
index 0000000..c102e94
--- /dev/null
+++ b/leetcode/leetcode/find-the-duplicate-number/find-the-duplicate-number.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int findDuplicate(int[] arr) {
+        int index =0;;
+        for(int i = 0;i<arr.length;i++){
+            index = Math.abs(arr[i]);
+            if(arr[index]<0) break;
+            arr[index] = -arr[index];
+        }
+        return index;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/find-the-student-that-will-replace-the-chalk/README.md b/leetcode/leetcode/find-the-student-that-will-replace-the-chalk/README.md
new file mode 100644
index 0000000..a72762a
--- /dev/null
+++ b/leetcode/leetcode/find-the-student-that-will-replace-the-chalk/README.md
@@ -0,0 +1,47 @@
+<h2>1894. Find the Student that Will Replace the Chalk</h2><h3>Medium</h3><hr><div><p>There are <code>n</code> students in a class numbered from <code>0</code> to <code>n - 1</code>. The teacher will give each student a problem starting with the student number <code>0</code>, then the student number <code>1</code>, and so on until the teacher reaches the student number <code>n - 1</code>. After that, the teacher will restart the process, starting with the student number <code>0</code> again.</p>
+
+<p>You are given a <strong>0-indexed</strong> integer array <code>chalk</code> and an integer <code>k</code>. There are initially <code>k</code> pieces of chalk. When the student number <code>i</code> is given a problem to solve, they will use <code>chalk[i]</code> pieces of chalk to solve that problem. However, if the current number of chalk pieces is <strong>strictly less</strong> than <code>chalk[i]</code>, then the student number <code>i</code> will be asked to <strong>replace</strong> the chalk.</p>
+
+<p>Return <em>the <strong>index</strong> of the student that will <strong>replace</strong> the chalk</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> chalk = [5,1,5], k = 22
+<strong>Output:</strong> 0
+<strong>Explanation: </strong>The students go in turns as follows:
+- Student number 0 uses 5 chalk, so k = 17.
+- Student number 1 uses 1 chalk, so k = 16.
+- Student number 2 uses 5 chalk, so k = 11.
+- Student number 0 uses 5 chalk, so k = 6.
+- Student number 1 uses 1 chalk, so k = 5.
+- Student number 2 uses 5 chalk, so k = 0.
+Student number 0 does not have enough chalk, so they will have to replace it.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> chalk = [3,4,1,2], k = 25
+<strong>Output:</strong> 1
+<strong>Explanation: </strong>The students go in turns as follows:
+- Student number 0 uses 3 chalk so k = 22.
+- Student number 1 uses 4 chalk so k = 18.
+- Student number 2 uses 1 chalk so k = 17.
+- Student number 3 uses 2 chalk so k = 15.
+- Student number 0 uses 3 chalk so k = 12.
+- Student number 1 uses 4 chalk so k = 8.
+- Student number 2 uses 1 chalk so k = 7.
+- Student number 3 uses 2 chalk so k = 5.
+- Student number 0 uses 3 chalk so k = 2.
+Student number 1 does not have enough chalk, so they will have to replace it.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>chalk.length == n</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= chalk[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/find-the-student-that-will-replace-the-chalk/find-the-student-that-will-replace-the-chalk.java b/leetcode/leetcode/find-the-student-that-will-replace-the-chalk/find-the-student-that-will-replace-the-chalk.java
new file mode 100644
index 0000000..4f25ac7
--- /dev/null
+++ b/leetcode/leetcode/find-the-student-that-will-replace-the-chalk/find-the-student-that-will-replace-the-chalk.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int chalkReplacer(int[] chalk, int k) {
+        long sum = 0;
+        for(int num: chalk) sum+=num;
+        if((int)k%(int)sum==0 && k>=sum) return 0;
+        else if(k>sum) k = k%(int)sum;
+        for(int i=0;i<chalk.length;i++){
+            if(k<chalk[i]) return i;
+            if(k==chalk[i]) return i+1;
+            k-=chalk[i];
+        }
+        return 0;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/find-the-town-judge/README.md b/leetcode/leetcode/find-the-town-judge/README.md
new file mode 100644
index 0000000..efb2073
--- /dev/null
+++ b/leetcode/leetcode/find-the-town-judge/README.md
@@ -0,0 +1,45 @@
+<h2>997. Find the Town Judge</h2><h3>Easy</h3><hr><div><p>In a town, there are <code>n</code> people labeled from <code>1</code> to <code>n</code>. There is a rumor that one of these people is secretly the town judge.</p>
+
+<p>If the town judge exists, then:</p>
+
+<ol>
+	<li>The town judge trusts nobody.</li>
+	<li>Everybody (except for the town judge) trusts the town judge.</li>
+	<li>There is exactly one person that satisfies properties <strong>1</strong> and <strong>2</strong>.</li>
+</ol>
+
+<p>You are given an array <code>trust</code> where <code>trust[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> representing that the person labeled <code>a<sub>i</sub></code> trusts the person labeled <code>b<sub>i</sub></code>.</p>
+
+<p>Return <em>the label of the town judge if the town judge exists and can be identified, or return </em><code>-1</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2, trust = [[1,2]]
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 3, trust = [[1,3],[2,3]]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 3, trust = [[1,3],[2,3],[3,1]]
+<strong>Output:</strong> -1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 1000</code></li>
+	<li><code>0 &lt;= trust.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>trust[i].length == 2</code></li>
+	<li>All the pairs of <code>trust</code> are <strong>unique</strong>.</li>
+	<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
+	<li><code>1 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt;= n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/find-the-town-judge/find-the-town-judge.java b/leetcode/leetcode/find-the-town-judge/find-the-town-judge.java
new file mode 100644
index 0000000..01ccf1f
--- /dev/null
+++ b/leetcode/leetcode/find-the-town-judge/find-the-town-judge.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int findJudge(int n, int[][] trust) {
+        int[] arr = new int[n+1];
+        for(int i = 0;i<trust.length;i++){
+            arr[trust[i][0]]--;
+            arr[trust[i][1]]++;
+        }
+        for(int i =1;i<=n;i++){
+            if(arr[i]==n-1) return i;
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/finding-pairs-with-a-certain-sum/README.md b/leetcode/leetcode/finding-pairs-with-a-certain-sum/README.md
new file mode 100644
index 0000000..1a82f92
--- /dev/null
+++ b/leetcode/leetcode/finding-pairs-with-a-certain-sum/README.md
@@ -0,0 +1,49 @@
+<h2>1865. Finding Pairs With a Certain Sum</h2><h3>Medium</h3><hr><div><p>You are given two integer arrays <code>nums1</code> and <code>nums2</code>. You are tasked to implement a data structure that supports queries of two types:</p>
+
+<ol>
+	<li><strong>Add</strong> a positive integer to an element of a given index in the array <code>nums2</code>.</li>
+	<li><strong>Count</strong> the number of pairs <code>(i, j)</code> such that <code>nums1[i] + nums2[j]</code> equals a given value (<code>0 &lt;= i &lt; nums1.length</code> and <code>0 &lt;= j &lt; nums2.length</code>).</li>
+</ol>
+
+<p>Implement the <code>FindSumPairs</code> class:</p>
+
+<ul>
+	<li><code>FindSumPairs(int[] nums1, int[] nums2)</code> Initializes the <code>FindSumPairs</code> object with two integer arrays <code>nums1</code> and <code>nums2</code>.</li>
+	<li><code>void add(int index, int val)</code> Adds <code>val</code> to <code>nums2[index]</code>, i.e., apply <code>nums2[index] += val</code>.</li>
+	<li><code>int count(int tot)</code> Returns the number of pairs <code>(i, j)</code> such that <code>nums1[i] + nums2[j] == tot</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["FindSumPairs", "count", "add", "count", "count", "add", "add", "count"]
+[[[1, 1, 2, 2, 2, 3], [1, 4, 5, 2, 5, 4]], [7], [3, 2], [8], [4], [0, 1], [1, 1], [7]]
+<strong>Output</strong>
+[null, 8, null, 2, 1, null, null, 11]
+
+<strong>Explanation</strong>
+FindSumPairs findSumPairs = new FindSumPairs([1, 1, 2, 2, 2, 3], [1, 4, 5, 2, 5, 4]);
+findSumPairs.count(7);  // return 8; pairs (2,2), (3,2), (4,2), (2,4), (3,4), (4,4) make 2 + 5 and pairs (5,1), (5,5) make 3 + 4
+findSumPairs.add(3, 2); // now nums2 = [1,4,5,<strong><u>4</u></strong><code>,5,4</code>]
+findSumPairs.count(8);  // return 2; pairs (5,2), (5,4) make 3 + 5
+findSumPairs.count(4);  // return 1; pair (5,0) makes 3 + 1
+findSumPairs.add(0, 1); // now nums2 = [<strong><u><code>2</code></u></strong>,4,5,4<code>,5,4</code>]
+findSumPairs.add(1, 1); // now nums2 = [<code>2</code>,<strong><u>5</u></strong>,5,4<code>,5,4</code>]
+findSumPairs.count(7);  // return 11; pairs (2,1), (2,2), (2,4), (3,1), (3,2), (3,4), (4,1), (4,2), (4,4) make 2 + 5 and pairs (5,3), (5,5) make 3 + 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums1.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= nums2.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums1[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= nums2[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= index &lt; nums2.length</code></li>
+	<li><code>1 &lt;= val &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= tot &lt;= 10<sup>9</sup></code></li>
+	<li>At most <code>1000</code> calls are made to <code>add</code> and <code>count</code> <strong>each</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/finding-pairs-with-a-certain-sum/finding-pairs-with-a-certain-sum.java b/leetcode/leetcode/finding-pairs-with-a-certain-sum/finding-pairs-with-a-certain-sum.java
new file mode 100644
index 0000000..ed98550
--- /dev/null
+++ b/leetcode/leetcode/finding-pairs-with-a-certain-sum/finding-pairs-with-a-certain-sum.java
@@ -0,0 +1,33 @@
+class FindSumPairs {
+    int arr1[];
+    int arr2[];
+    HashMap<Integer, Integer> map;
+    public FindSumPairs(int[] nums1, int[] nums2) {
+        arr1 = nums1;
+        arr2 = nums2;
+        map = new HashMap<Integer, Integer>();
+        for(int num: nums2) map.put(num, map.getOrDefault(num,0)+1);
+    }
+    
+    public void add(int index, int val) {
+        map.put(arr2[index],map.getOrDefault(arr2[index],0) - 1);
+        arr2[index]+=val;
+        map.put(arr2[index],map.getOrDefault(arr2[index],0) + 1);
+            
+    }
+    
+    public int count(int tot) {
+        int count = 0;
+        for(int num: arr1){
+            count+=map.getOrDefault(tot-num,0);
+        }
+        return count;
+    }
+}
+
+/**
+ * Your FindSumPairs object will be instantiated and called as such:
+ * FindSumPairs obj = new FindSumPairs(nums1, nums2);
+ * obj.add(index,val);
+ * int param_2 = obj.count(tot);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/first-bad-version/README.md b/leetcode/leetcode/first-bad-version/README.md
new file mode 100644
index 0000000..d0bd6b1
--- /dev/null
+++ b/leetcode/leetcode/first-bad-version/README.md
@@ -0,0 +1,31 @@
+<h2>278. First Bad Version</h2><h3>Easy</h3><hr><div><p>You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check. Since each version is developed based on the previous version, all the versions after a bad version are also bad.</p>
+
+<p>Suppose you have <code>n</code> versions <code>[1, 2, ..., n]</code> and you want to find out the first bad one, which causes all the following ones to be bad.</p>
+
+<p>You are given an API <code>bool isBadVersion(version)</code> which returns whether <code>version</code> is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 5, bad = 4
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+call isBadVersion(3) -&gt; false
+call isBadVersion(5)&nbsp;-&gt; true
+call isBadVersion(4)&nbsp;-&gt; true
+Then 4 is the first bad version.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 1, bad = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= bad &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/first-bad-version/first-bad-version.java b/leetcode/leetcode/first-bad-version/first-bad-version.java
new file mode 100644
index 0000000..5295c5f
--- /dev/null
+++ b/leetcode/leetcode/first-bad-version/first-bad-version.java
@@ -0,0 +1,14 @@
+/* The isBadVersion API is defined in the parent class VersionControl.
+      boolean isBadVersion(int version); */
+
+public class Solution extends VersionControl {
+    public int firstBadVersion(int n) {
+        int left = 1;
+        while(left<n){
+           int mid = left + (n - left) / 2;
+            if(!(isBadVersion(mid))) left = mid+1;
+            else n=mid;
+        }
+        return left;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/first-missing-positive/README.md b/leetcode/leetcode/first-missing-positive/README.md
new file mode 100644
index 0000000..57506ee
--- /dev/null
+++ b/leetcode/leetcode/first-missing-positive/README.md
@@ -0,0 +1,23 @@
+<h2>41. First Missing Positive</h2><h3>Hard</h3><hr><div><p>Given an unsorted integer array <code>nums</code>, return the smallest missing positive integer.</p>
+
+<p>You must implement an algorithm that runs in <code>O(n)</code> time and uses constant extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,0]
+<strong>Output:</strong> 3
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [3,4,-1,1]
+<strong>Output:</strong> 2
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [7,8,9,11,12]
+<strong>Output:</strong> 1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 5 * 10<sup>5</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/first-missing-positive/first-missing-positive.java b/leetcode/leetcode/first-missing-positive/first-missing-positive.java
new file mode 100644
index 0000000..895eeba
--- /dev/null
+++ b/leetcode/leetcode/first-missing-positive/first-missing-positive.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int firstMissingPositive(int[] arr) {
+        int len = arr.length;
+        boolean  one = false;
+        for(int i =0;i<len;i++){
+            if(arr[i]==1) one = true;
+            else if(arr[i]<=0  || arr[i]>len) arr[i] = 1;
+        }
+        if(!one) return 1;
+        for(int i =0;i<len;i++){
+            int index = Math.abs(arr[i]) - 1;
+            arr[index] = -Math.abs(arr[index]);
+        }
+        for(int i = 0;i<len;i++){
+            if(arr[i]>0) return i+1;
+        }
+        return len+1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/first-unique-character-in-a-string/README.md b/leetcode/leetcode/first-unique-character-in-a-string/README.md
new file mode 100644
index 0000000..fd8f72c
--- /dev/null
+++ b/leetcode/leetcode/first-unique-character-in-a-string/README.md
@@ -0,0 +1,21 @@
+<h2>387. First Unique Character in a String</h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code>, <em>find the first non-repeating character in it and return its index</em>. If it does not exist, return <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "leetcode"
+<strong>Output:</strong> 0
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "loveleetcode"
+<strong>Output:</strong> 2
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> s = "aabb"
+<strong>Output:</strong> -1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> consists of only lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/first-unique-character-in-a-string/first-unique-character-in-a-string.java b/leetcode/leetcode/first-unique-character-in-a-string/first-unique-character-in-a-string.java
new file mode 100644
index 0000000..5332f11
--- /dev/null
+++ b/leetcode/leetcode/first-unique-character-in-a-string/first-unique-character-in-a-string.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int firstUniqChar(String s) {
+        HashMap<Character, Integer> map = new HashMap<>();
+        int n = s.length();
+        for(int i =0;i<n;i++){
+            char c = s.charAt(i);
+            map.put(c,map.getOrDefault(c,0)+1);
+        }
+        for(int i=0;i<n;i++){
+            if(map.get(s.charAt(i)) == 1) return i;
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/flatten-a-multilevel-doubly-linked-list/README.md b/leetcode/leetcode/flatten-a-multilevel-doubly-linked-list/README.md
new file mode 100644
index 0000000..13a463b
--- /dev/null
+++ b/leetcode/leetcode/flatten-a-multilevel-doubly-linked-list/README.md
@@ -0,0 +1,72 @@
+<h2>430. Flatten a Multilevel Doubly Linked List</h2><h3>Medium</h3><hr><div><p>You are given a doubly linked list, which contains nodes that have a next pointer, a previous pointer, and an additional <strong>child pointer</strong>. This child pointer may or may not point to a separate doubly linked list, also containing these special nodes. These child lists may have one or more children of their own, and so on, to produce a <strong>multilevel data structure</strong> as shown in the example below.</p>
+
+<p>Given the <code>head</code> of the first level of the list, <strong>flatten</strong> the list so that all the nodes appear in a single-level, doubly linked list. Let <code>curr</code> be a node with a child list. The nodes in the child list should appear <strong>after</strong> <code>curr</code> and <strong>before</strong> <code>curr.next</code> in the flattened list.</p>
+
+<p>Return <em>the </em><code>head</code><em> of the flattened list. The nodes in the list must have <strong>all</strong> of their child pointers set to </em><code>null</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/09/flatten11.jpg" style="width: 700px; height: 339px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
+<strong>Output:</strong> [1,2,3,7,8,11,12,9,10,4,5,6]
+<strong>Explanation:</strong> The multilevel linked list in the input is shown.
+After flattening the multilevel linked list it becomes:
+<img src="https://assets.leetcode.com/uploads/2021/11/09/flatten12.jpg" style="width: 1000px; height: 69px;">
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/09/flatten2.1jpg" style="width: 200px; height: 200px;">
+<pre><strong>Input:</strong> head = [1,2,null,3]
+<strong>Output:</strong> [1,3,2]
+<strong>Explanation:</strong> The multilevel linked list in the input is shown.
+After flattening the multilevel linked list it becomes:
+<img src="https://assets.leetcode.com/uploads/2021/11/24/list.jpg" style="width: 300px; height: 87px;">
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+<strong>Explanation:</strong> There could be empty list in the input.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of Nodes will not exceed <code>1000</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>How the multilevel linked list is represented in test cases:</strong></p>
+
+<p>We use the multilevel linked list from <strong>Example 1</strong> above:</p>
+
+<pre> 1---2---3---4---5---6--NULL
+         |
+         7---8---9---10--NULL
+             |
+             11--12--NULL</pre>
+
+<p>The serialization of each level is as follows:</p>
+
+<pre>[1,2,3,4,5,6,null]
+[7,8,9,10,null]
+[11,12,null]
+</pre>
+
+<p>To serialize all levels together, we will add nulls in each level to signify no node connects to the upper node of the previous level. The serialization becomes:</p>
+
+<pre>[1,    2,    3, 4, 5, 6, null]
+             |
+[null, null, 7,    8, 9, 10, null]
+                   |
+[            null, 11, 12, null]
+</pre>
+
+<p>Merging the serialization of each level and removing trailing nulls we obtain:</p>
+
+<pre>[1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
+</pre>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/flatten-a-multilevel-doubly-linked-list/flatten-a-multilevel-doubly-linked-list.java b/leetcode/leetcode/flatten-a-multilevel-doubly-linked-list/flatten-a-multilevel-doubly-linked-list.java
new file mode 100644
index 0000000..8482d72
--- /dev/null
+++ b/leetcode/leetcode/flatten-a-multilevel-doubly-linked-list/flatten-a-multilevel-doubly-linked-list.java
@@ -0,0 +1,32 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node prev;
+    public Node next;
+    public Node child;
+};
+*/
+
+class Solution {
+    public Node flatten(Node head) {
+        if(head == null){
+            return head;
+        }
+        if(head.child!=null){
+            Node next = head.next;
+            Node temp = flatten(head.child);
+            head.child = null;
+            head.next  = temp;
+            temp.prev = head;
+            while(temp.next!=null){
+                temp = temp.next;
+            }
+            temp.next = next;
+            if(next!=null) next.prev = temp;   
+        }else{
+            head.next= flatten(head.next);
+        }
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/flatten-binary-tree-to-linked-list/README.md b/leetcode/leetcode/flatten-binary-tree-to-linked-list/README.md
new file mode 100644
index 0000000..6ccdad6
--- /dev/null
+++ b/leetcode/leetcode/flatten-binary-tree-to-linked-list/README.md
@@ -0,0 +1,37 @@
+[Discussion Post (created on 5/11/2021 at 14:1)](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/discuss/1612604/Java-100-FAST-95-Space-Recursion)  
+<h2>114. Flatten Binary Tree to Linked List</h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, flatten the tree into a "linked list":</p>
+
+<ul>
+	<li>The "linked list" should use the same <code>TreeNode</code> class where the <code>right</code> child pointer points to the next node in the list and the <code>left</code> child pointer is always <code>null</code>.</li>
+	<li>The "linked list" should be in the same order as a <a href="https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR" target="_blank"><strong>pre-order</strong><strong> traversal</strong></a> of the binary tree.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/14/flaten.jpg" style="width: 500px; height: 226px;">
+<pre><strong>Input:</strong> root = [1,2,5,3,4,null,6]
+<strong>Output:</strong> [1,null,2,null,3,null,4,null,5,null,6]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [0]
+<strong>Output:</strong> [0]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 2000]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Can you flatten the tree in-place (with <code>O(1)</code> extra space)?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/flatten-binary-tree-to-linked-list/flatten-binary-tree-to-linked-list.java b/leetcode/leetcode/flatten-binary-tree-to-linked-list/flatten-binary-tree-to-linked-list.java
new file mode 100644
index 0000000..28525b6
--- /dev/null
+++ b/leetcode/leetcode/flatten-binary-tree-to-linked-list/flatten-binary-tree-to-linked-list.java
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public void flatten(TreeNode root) {
+        if(root==null){
+            return;
+        }
+        flatten(root.left);
+        flatten(root.right);
+        TreeNode leftTemp = root.left;
+        root.left = null;
+        TreeNode rightTemp = root.right;
+        if(leftTemp!=null){
+            root.right = leftTemp;
+            while(leftTemp.right!=null){
+                leftTemp = leftTemp.right;
+            }
+            leftTemp.right = rightTemp;
+        }else{
+            root.right = rightTemp;
+        }
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/guess-number-higher-or-lower/README.md b/leetcode/leetcode/guess-number-higher-or-lower/README.md
new file mode 100644
index 0000000..bd66730
--- /dev/null
+++ b/leetcode/leetcode/guess-number-higher-or-lower/README.md
@@ -0,0 +1,38 @@
+<h2>374. Guess Number Higher or Lower</h2><h3>Easy</h3><hr><div><p>We are playing the Guess Game. The game is as follows:</p>
+
+<p>I pick a number from <code>1</code> to <code>n</code>. You have to guess which number I picked.</p>
+
+<p>Every time you guess wrong, I will tell you whether the number I picked is higher or lower than your guess.</p>
+
+<p>You call a pre-defined API <code>int guess(int num)</code>, which returns 3 possible results:</p>
+
+<ul>
+	<li><code>-1</code>: The number I picked is lower than your guess (i.e. <code>pick &lt; num</code>).</li>
+	<li><code>1</code>: The number I picked is higher than your guess (i.e. <code>pick &gt; num</code>).</li>
+	<li><code>0</code>: The number I picked is equal to your guess (i.e. <code>pick == num</code>).</li>
+</ul>
+
+<p>Return <em>the number that I picked</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 10, pick = 6
+<strong>Output:</strong> 6
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 1, pick = 1
+<strong>Output:</strong> 1
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> n = 2, pick = 1
+<strong>Output:</strong> 1
+</pre><p><strong>Example 4:</strong></p>
+<pre><strong>Input:</strong> n = 2, pick = 2
+<strong>Output:</strong> 2
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>1 &lt;= pick &lt;= n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/guess-number-higher-or-lower/guess-number-higher-or-lower.java b/leetcode/leetcode/guess-number-higher-or-lower/guess-number-higher-or-lower.java
new file mode 100644
index 0000000..ed8f7b3
--- /dev/null
+++ b/leetcode/leetcode/guess-number-higher-or-lower/guess-number-higher-or-lower.java
@@ -0,0 +1,25 @@
+/** 
+ * Forward declaration of guess API.
+ * @param  num   your guess
+ * @return 	     -1 if num is lower than the guess number
+ *			      1 if num is higher than the guess number
+ *               otherwise return 0
+ * int guess(int num);
+ */
+
+public class Solution extends GuessGame {
+    public int guessNumber(int high) {
+        int low = 1;
+        while(low<=high){
+            int mid = low + (high-low)/2;
+            int res = guess(mid);
+            if(res==0) 
+                return mid;
+            else if(res>0) 
+                low = mid +1;
+            else 
+                high = mid -1;
+        }
+        return -1;
+    }
+}
diff --git a/leetcode/leetcode/implement-strstr/README.md b/leetcode/leetcode/implement-strstr/README.md
new file mode 100644
index 0000000..56439d2
--- /dev/null
+++ b/leetcode/leetcode/implement-strstr/README.md
@@ -0,0 +1,29 @@
+<h2>28. Implement strStr()</h2><h3>Easy</h3><hr><div><p>Implement <a href="http://www.cplusplus.com/reference/cstring/strstr/" target="_blank">strStr()</a>.</p>
+
+<p>Return the index of the first occurrence of needle in haystack, or <code>-1</code> if <code>needle</code> is not part of <code>haystack</code>.</p>
+
+<p><strong>Clarification:</strong></p>
+
+<p>What should we return when <code>needle</code> is an empty string? This is a great question to ask during an interview.</p>
+
+<p>For the purpose of this problem, we will return 0 when <code>needle</code> is an empty string. This is consistent to C's&nbsp;<a href="http://www.cplusplus.com/reference/cstring/strstr/" target="_blank">strstr()</a> and Java's&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(java.lang.String)" target="_blank">indexOf()</a>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> haystack = "hello", needle = "ll"
+<strong>Output:</strong> 2
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> haystack = "aaaaa", needle = "bba"
+<strong>Output:</strong> -1
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> haystack = "", needle = ""
+<strong>Output:</strong> 0
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= haystack.length, needle.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>haystack</code> and&nbsp;<code>needle</code> consist of only lower-case English characters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/implement-strstr/implement-strstr.java b/leetcode/leetcode/implement-strstr/implement-strstr.java
new file mode 100644
index 0000000..ad3bc26
--- /dev/null
+++ b/leetcode/leetcode/implement-strstr/implement-strstr.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int strStr(String haystack, String needle) {
+        if(needle.length() == 0){
+            return 0;
+        }
+        if(haystack.length() == 0){
+            return -1;
+        }
+        return haystack.indexOf(needle);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/insert-into-a-binary-search-tree/README.md b/leetcode/leetcode/insert-into-a-binary-search-tree/README.md
new file mode 100644
index 0000000..8488968
--- /dev/null
+++ b/leetcode/leetcode/insert-into-a-binary-search-tree/README.md
@@ -0,0 +1,36 @@
+<h2>701. Insert into a Binary Search Tree</h2><h3>Medium</h3><hr><div><p>You are given the <code>root</code> node of a binary search tree (BST) and a <code>value</code> to insert into the tree. Return <em>the root node of the BST after the insertion</em>. It is <strong>guaranteed</strong> that the new value does not exist in the original BST.</p>
+
+<p><strong>Notice</strong>&nbsp;that there may exist&nbsp;multiple valid ways for the&nbsp;insertion, as long as the tree remains a BST after insertion. You can return <strong>any of them</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/05/insertbst.jpg" style="width: 752px; height: 221px;">
+<pre><strong>Input:</strong> root = [4,2,7,1,3], val = 5
+<strong>Output:</strong> [4,2,7,1,3,5]
+<strong>Explanation:</strong> Another accepted tree is:
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/05/bst.jpg" style="width: 352px; height: 301px;">
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [40,20,60,10,30,50,70], val = 25
+<strong>Output:</strong> [40,20,60,10,30,50,70,null,null,25]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
+<strong>Output:</strong> [4,2,7,1,3,5]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in&nbsp;the tree will be in the range <code>[0,&nbsp;10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>8</sup> &lt;= Node.val &lt;= 10<sup>8</sup></code></li>
+	<li>All the values <code>Node.val</code> are <strong>unique</strong>.</li>
+	<li><code>-10<sup>8</sup> &lt;= val &lt;= 10<sup>8</sup></code></li>
+	<li>It's <strong>guaranteed</strong> that <code>val</code> does not exist in the original BST.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/insert-into-a-binary-search-tree/insert-into-a-binary-search-tree.java b/leetcode/leetcode/insert-into-a-binary-search-tree/insert-into-a-binary-search-tree.java
new file mode 100644
index 0000000..c851f12
--- /dev/null
+++ b/leetcode/leetcode/insert-into-a-binary-search-tree/insert-into-a-binary-search-tree.java
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode insertIntoBST(TreeNode root, int val) {
+        if(root==null){
+            root = new TreeNode(val);
+            return root;
+        }
+        if(root.val>val){
+            root.left = insertIntoBST(root.left, val);
+        }else{
+            root.right = insertIntoBST(root.right, val);
+        }
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/intersection-of-two-arrays/README.md b/leetcode/leetcode/intersection-of-two-arrays/README.md
new file mode 100644
index 0000000..b873037
--- /dev/null
+++ b/leetcode/leetcode/intersection-of-two-arrays/README.md
@@ -0,0 +1,24 @@
+<h2>349. Intersection of Two Arrays</h2><h3>Easy</h3><hr><div><p>Given two integer arrays <code>nums1</code> and <code>nums2</code>, return <em>an array of their intersection</em>. Each element in the result must be <strong>unique</strong> and you may return the result in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2,2,1], nums2 = [2,2]
+<strong>Output:</strong> [2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+<strong>Output:</strong> [9,4]
+<strong>Explanation:</strong> [4,9] is also accepted.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums1.length, nums2.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums1[i], nums2[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/intersection-of-two-arrays/intersection-of-two-arrays.java b/leetcode/leetcode/intersection-of-two-arrays/intersection-of-two-arrays.java
new file mode 100644
index 0000000..de1dfb3
--- /dev/null
+++ b/leetcode/leetcode/intersection-of-two-arrays/intersection-of-two-arrays.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int[] intersection(int[] nums1, int[] nums2) {
+        Set<Integer> set1  =  new HashSet<Integer>();
+        for(int num: nums1){
+            set1.add(num);
+        }
+        Set<Integer> set2 = new HashSet<Integer>();
+        for(int num: nums2){
+            set2.add(num);
+        }
+        set1.retainAll(set2);
+        int[] res = new int[set1.size()];
+        int i =0;
+        for(int num: set1) res[i++]=num;
+        return res;
+
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/invert-binary-tree/README.md b/leetcode/leetcode/invert-binary-tree/README.md
new file mode 100644
index 0000000..124a904
--- /dev/null
+++ b/leetcode/leetcode/invert-binary-tree/README.md
@@ -0,0 +1,29 @@
+<h2>226. Invert Binary Tree</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, invert the tree, and return <em>its root</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg" style="width: 500px; height: 165px;">
+<pre><strong>Input:</strong> root = [4,2,7,1,3,6,9]
+<strong>Output:</strong> [4,7,2,9,6,3,1]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg" style="width: 500px; height: 120px;">
+<pre><strong>Input:</strong> root = [2,1,3]
+<strong>Output:</strong> [2,3,1]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/invert-binary-tree/invert-binary-tree.java b/leetcode/leetcode/invert-binary-tree/invert-binary-tree.java
new file mode 100644
index 0000000..c5495a1
--- /dev/null
+++ b/leetcode/leetcode/invert-binary-tree/invert-binary-tree.java
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode invertTree(TreeNode root) {
+        if(root == null){
+            return root;
+        }
+        TreeNode temp = root.left;
+        root.left = root.right;
+        root.right = temp;
+        root.left = invertTree(root.left);
+        root.right = invertTree(root.right);
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/kth-largest-element-in-an-array/README.md b/leetcode/leetcode/kth-largest-element-in-an-array/README.md
new file mode 100644
index 0000000..1fada2a
--- /dev/null
+++ b/leetcode/leetcode/kth-largest-element-in-an-array/README.md
@@ -0,0 +1,20 @@
+<h2>215. Kth Largest Element in an Array</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <em>the</em> <code>k<sup>th</sup></code> <em>largest element in the array</em>.</p>
+
+<p>Note that it is the <code>k<sup>th</sup></code> largest element in the sorted order, not the <code>k<sup>th</sup></code> distinct element.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,1,5,6,4], k = 2
+<strong>Output:</strong> 5
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,3,1,2,4,5,5,6], k = 4
+<strong>Output:</strong> 4
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/kth-largest-element-in-an-array/kth-largest-element-in-an-array.java b/leetcode/leetcode/kth-largest-element-in-an-array/kth-largest-element-in-an-array.java
new file mode 100644
index 0000000..2134429
--- /dev/null
+++ b/leetcode/leetcode/kth-largest-element-in-an-array/kth-largest-element-in-an-array.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        PriorityQueue<Integer> maxPQ = new PriorityQueue<>();
+        for(int num: nums){
+            maxPQ.add(num);        
+            if(maxPQ.size() > k) {
+                maxPQ.poll();
+            }
+        }
+        return maxPQ.peek();
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/largest-perimeter-triangle/README.md b/leetcode/leetcode/largest-perimeter-triangle/README.md
new file mode 100644
index 0000000..4d0c5f1
--- /dev/null
+++ b/leetcode/leetcode/largest-perimeter-triangle/README.md
@@ -0,0 +1,24 @@
+<h2>976. Largest Perimeter Triangle</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code>, return <em>the largest perimeter of a triangle with a non-zero area, formed from three of these lengths</em>. If it is impossible to form any triangle of a non-zero area, return <code>0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [2,1,2]
+<strong>Output:</strong> 5
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,1]
+<strong>Output:</strong> 0
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,3,4]
+<strong>Output:</strong> 10
+</pre><p><strong>Example 4:</strong></p>
+<pre><strong>Input:</strong> nums = [3,6,2,3]
+<strong>Output:</strong> 8
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/largest-perimeter-triangle/largest-perimeter-triangle.java b/leetcode/leetcode/largest-perimeter-triangle/largest-perimeter-triangle.java
new file mode 100644
index 0000000..12b5007
--- /dev/null
+++ b/leetcode/leetcode/largest-perimeter-triangle/largest-perimeter-triangle.java
@@ -0,0 +1,9 @@
+class Solution {
+    public int largestPerimeter(int[] nums) {
+        Arrays.sort(nums);
+        for (int i = nums.length - 3; i >= 0; --i)
+            if (nums[i] + nums[i+1] > nums[i+2])
+                return nums[i] + nums[i+1] + nums[i+2];
+        return 0;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/length-of-last-word/README.md b/leetcode/leetcode/length-of-last-word/README.md
new file mode 100644
index 0000000..cf7e981
--- /dev/null
+++ b/leetcode/leetcode/length-of-last-word/README.md
@@ -0,0 +1,35 @@
+<h2>58. Length of Last Word</h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code> consisting&nbsp;of some words separated by some number of spaces, return <em>the length of the <strong>last</strong> word in the string.</em></p>
+
+<p>A <strong>word</strong> is a maximal substring consisting of non-space characters only.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "Hello World"
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The last word is "World" with length 5.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "   fly me   to   the moon  "
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The last word is "moon" with length 4.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "luffy is still joyboy"
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The last word is "joyboy" with length 6.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of only English letters and spaces <code>' '</code>.</li>
+	<li>There will be at least one word in <code>s</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/length-of-last-word/length-of-last-word.java b/leetcode/leetcode/length-of-last-word/length-of-last-word.java
new file mode 100644
index 0000000..a6cbde2
--- /dev/null
+++ b/leetcode/leetcode/length-of-last-word/length-of-last-word.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int lengthOfLastWord(String s) {
+        int result = 0;
+        int counter = s.length() - 1;
+        boolean space  = false;
+        while(s.charAt(counter) != ' ' || ! space){
+            if(s.charAt(counter) != ' '){
+                space = true;
+            }
+            if(space){result++;}
+            counter--;
+            if(counter == -1){
+                break;
+            }
+            
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/linked-list-cycle/README.md b/leetcode/leetcode/linked-list-cycle/README.md
new file mode 100644
index 0000000..3d904c7
--- /dev/null
+++ b/leetcode/leetcode/linked-list-cycle/README.md
@@ -0,0 +1,40 @@
+<h2>141. Linked List Cycle</h2><h3>Easy</h3><hr><div><p>Given <code>head</code>, the head of a linked list, determine if the linked list has a cycle in it.</p>
+
+<p>There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the&nbsp;<code>next</code>&nbsp;pointer. Internally, <code>pos</code>&nbsp;is used to denote the index of the node that&nbsp;tail's&nbsp;<code>next</code>&nbsp;pointer is connected to.&nbsp;<strong>Note that&nbsp;<code>pos</code>&nbsp;is not passed as a parameter</strong>.</p>
+
+<p>Return&nbsp;<code>true</code><em> if there is a cycle in the linked list</em>. Otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png" style="width: 300px; height: 97px; margin-top: 8px; margin-bottom: 8px;">
+<pre><strong>Input:</strong> head = [3,2,0,-4], pos = 1
+<strong>Output:</strong> true
+<strong>Explanation:</strong> There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed).
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png" style="width: 141px; height: 74px;">
+<pre><strong>Input:</strong> head = [1,2], pos = 0
+<strong>Output:</strong> true
+<strong>Explanation:</strong> There is a cycle in the linked list, where the tail connects to the 0th node.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png" style="width: 45px; height: 45px;">
+<pre><strong>Input:</strong> head = [1], pos = -1
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There is no cycle in the linked list.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li><code>pos</code> is <code>-1</code> or a <strong>valid index</strong> in the linked-list.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Can you solve it using <code>O(1)</code> (i.e. constant) memory?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/linked-list-cycle/linked-list-cycle.java b/leetcode/leetcode/linked-list-cycle/linked-list-cycle.java
new file mode 100644
index 0000000..b7d9c5a
--- /dev/null
+++ b/leetcode/leetcode/linked-list-cycle/linked-list-cycle.java
@@ -0,0 +1,23 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast != null && fast.next != null){
+            slow = slow.next;
+            fast = fast.next.next;
+            if(slow == fast) return true;
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/linked-list-random-node/README.md b/leetcode/leetcode/linked-list-random-node/README.md
new file mode 100644
index 0000000..7040a36
--- /dev/null
+++ b/leetcode/leetcode/linked-list-random-node/README.md
@@ -0,0 +1,45 @@
+<h2>382. Linked List Random Node</h2><h3>Medium</h3><hr><div><p>Given a singly linked list, return a random node's value from the linked list. Each node must have the <strong>same probability</strong> of being chosen.</p>
+
+<p>Implement the <code>Solution</code> class:</p>
+
+<ul>
+	<li><code>Solution(ListNode head)</code> Initializes the object with the integer array nums.</li>
+	<li><code>int getRandom()</code> Chooses a node randomly from the list and returns its value. All the nodes of the list should be equally likely to be choosen.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/16/getrand-linked-list.jpg" style="width: 302px; height: 62px;">
+<pre><strong>Input</strong>
+["Solution", "getRandom", "getRandom", "getRandom", "getRandom", "getRandom"]
+[[[1, 2, 3]], [], [], [], [], []]
+<strong>Output</strong>
+[null, 1, 3, 2, 2, 3]
+
+<strong>Explanation</strong>
+Solution solution = new Solution([1, 2, 3]);
+solution.getRandom(); // return 1
+solution.getRandom(); // return 3
+solution.getRandom(); // return 2
+solution.getRandom(); // return 2
+solution.getRandom(); // return 3
+// getRandom() should return either 1, 2, or 3 randomly. Each element should have equal probability of returning.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the linked list will be in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li>At most <code>10<sup>4</sup></code> calls will be made to <code>getRandom</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>What if the linked list is extremely large and its length is unknown to you?</li>
+	<li>Could you solve this efficiently without using extra space?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/linked-list-random-node/linked-list-random-node.java b/leetcode/leetcode/linked-list-random-node/linked-list-random-node.java
new file mode 100644
index 0000000..964e888
--- /dev/null
+++ b/leetcode/leetcode/linked-list-random-node/linked-list-random-node.java
@@ -0,0 +1,39 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode h;
+    public int size;
+
+    public Solution(ListNode head) {
+        h = head;
+        size = 0;
+        while(head!=null){
+            size++;
+            head = head.next;
+        }
+    }
+    
+    public int getRandom() {
+        int counter = (int) ((Math.random() * (size - 0)) + 0);
+        ListNode temp = h;
+        while(counter!=0){
+            temp = temp.next;
+            counter--;
+        }
+        return temp.val;
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution obj = new Solution(head);
+ * int param_1 = obj.getRandom();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/longest-increasing-subsequence/README.md b/leetcode/leetcode/longest-increasing-subsequence/README.md
new file mode 100644
index 0000000..60446c7
--- /dev/null
+++ b/leetcode/leetcode/longest-increasing-subsequence/README.md
@@ -0,0 +1,35 @@
+<h2>300. Longest Increasing Subsequence</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, return the length of the longest strictly increasing subsequence.</p>
+
+<p>A <strong>subsequence</strong> is a sequence that can be derived from an array by deleting some or no elements without changing the order of the remaining elements. For example, <code>[3,6,2,7]</code> is a subsequence of the array <code>[0,3,1,6,2,2,7]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [10,9,2,5,3,7,101,18]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The longest increasing subsequence is [2,3,7,101], therefore the length is 4.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1,0,3,2,3]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [7,7,7,7,7,7,7]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2500</code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><b>Follow up:</b>&nbsp;Can you come up with an algorithm that runs in&nbsp;<code>O(n log(n))</code> time complexity?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/longest-increasing-subsequence/longest-increasing-subsequence.java b/leetcode/leetcode/longest-increasing-subsequence/longest-increasing-subsequence.java
new file mode 100644
index 0000000..6de855a
--- /dev/null
+++ b/leetcode/leetcode/longest-increasing-subsequence/longest-increasing-subsequence.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int lengthOfLIS(int[] arr) {
+        int[] res = new int[arr.length];
+        int totalmax = 0;
+        for(int i = 0;i<arr.length;i++){
+            int max = 1;
+            for(int j = i-1;j!=-1;j--){
+                if(arr[i]>arr[j] &&res[j]>=max) max = res[j]+1;
+            }
+            res[i] = max;
+            totalmax = Math.max(max,totalmax);
+        }
+        return totalmax;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/longest-substring-without-repeating-characters/README.md b/leetcode/leetcode/longest-substring-without-repeating-characters/README.md
new file mode 100644
index 0000000..46ef03f
--- /dev/null
+++ b/leetcode/leetcode/longest-substring-without-repeating-characters/README.md
@@ -0,0 +1,33 @@
+<h2>3. Longest Substring Without Repeating Characters</h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code>, find the length of the <strong>longest substring</strong> without repeating characters.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "abcabcbb"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The answer is "abc", with the length of 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "bbbbb"
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The answer is "b", with the length of 1.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "pwwkew"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The answer is "wke", with the length of 3.
+Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of English letters, digits, symbols and spaces.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.java b/leetcode/leetcode/longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.java
new file mode 100644
index 0000000..7fb859a
--- /dev/null
+++ b/leetcode/leetcode/longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        int max = 0;
+        HashMap<Character,Integer> map = new HashMap<>();
+        int counter = 0;
+        for(int i = 0;i<s.length();i++){
+            char c = s.charAt(i);
+            if(map.containsKey(c)){
+                i = map.get(c);
+                max = Math.max(max,counter);
+                counter = 0;
+                map.clear();
+            }else{
+                map.put(c,i);
+                counter++;
+            }
+        }
+        return Math.max(counter,max);
+        
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/majority-element/README.md b/leetcode/leetcode/majority-element/README.md
new file mode 100644
index 0000000..6c4d3ff
--- /dev/null
+++ b/leetcode/leetcode/majority-element/README.md
@@ -0,0 +1,23 @@
+<h2>169. Majority Element</h2><h3>Easy</h3><hr><div><p>Given an array <code>nums</code> of size <code>n</code>, return <em>the majority element</em>.</p>
+
+<p>The majority element is the element that appears more than <code>⌊n / 2⌋</code> times. You may assume that the majority element always exists in the array.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,3]
+<strong>Output:</strong> 3
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,1,1,1,2,2]
+<strong>Output:</strong> 2
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow-up:</strong> Could you solve the problem in linear time and in <code>O(1)</code> space?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/majority-element/majority-element.java b/leetcode/leetcode/majority-element/majority-element.java
new file mode 100644
index 0000000..6f0aafe
--- /dev/null
+++ b/leetcode/leetcode/majority-element/majority-element.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int majorityElement(int[] nums) {
+        Arrays.sort(nums);
+        int target = nums.length/2;
+        int counter =0;
+        while(target<nums.length){
+            if(nums[counter] == nums[target]){
+                return nums[counter];
+            }
+            ++counter;
+            ++target;
+        }
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/make-two-arrays-equal-by-reversing-sub-arrays/README.md b/leetcode/leetcode/make-two-arrays-equal-by-reversing-sub-arrays/README.md
new file mode 100644
index 0000000..0fd1de1
--- /dev/null
+++ b/leetcode/leetcode/make-two-arrays-equal-by-reversing-sub-arrays/README.md
@@ -0,0 +1,40 @@
+<h2>1460. Make Two Arrays Equal by Reversing Sub-arrays</h2><h3>Easy</h3><hr><div><p>You are given two integer arrays of equal length <code>target</code> and <code>arr</code>. In one step, you can select any <strong>non-empty sub-array</strong> of <code>arr</code> and reverse it. You are allowed to make any number of steps.</p>
+
+<p>Return <code>true</code> <em>if you can make </em><code>arr</code><em> equal to </em><code>target</code><em>&nbsp;or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> target = [1,2,3,4], arr = [2,4,1,3]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> You can follow the next steps to convert arr to target:
+1- Reverse sub-array [2,4,1], arr becomes [1,4,2,3]
+2- Reverse sub-array [4,2], arr becomes [1,2,4,3]
+3- Reverse sub-array [4,3], arr becomes [1,2,3,4]
+There are multiple ways to convert arr to target, this is not the only way to do so.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> target = [7], arr = [7]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> arr is equal to target without any reverses.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> target = [3,7,9], arr = [3,7,11]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> arr does not have value 9 and it can never be converted to target.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>target.length == arr.length</code></li>
+	<li><code>1 &lt;= target.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= target[i] &lt;= 1000</code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/make-two-arrays-equal-by-reversing-sub-arrays/make-two-arrays-equal-by-reversing-sub-arrays.java b/leetcode/leetcode/make-two-arrays-equal-by-reversing-sub-arrays/make-two-arrays-equal-by-reversing-sub-arrays.java
new file mode 100644
index 0000000..8a4c7f3
--- /dev/null
+++ b/leetcode/leetcode/make-two-arrays-equal-by-reversing-sub-arrays/make-two-arrays-equal-by-reversing-sub-arrays.java
@@ -0,0 +1,11 @@
+class Solution {
+    public boolean canBeEqual(int[] target, int[] arr) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: target) map.put(num,map.getOrDefault(num,0)+1);
+        for(int num: arr){
+            map.put(num,map.getOrDefault(num,1)-1);
+            if(map.get(num) == 0) map.remove(num);
+        }
+        return map.size() == 0;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/matrix-diagonal-sum/README.md b/leetcode/leetcode/matrix-diagonal-sum/README.md
new file mode 100644
index 0000000..260caaf
--- /dev/null
+++ b/leetcode/leetcode/matrix-diagonal-sum/README.md
@@ -0,0 +1,39 @@
+<h2>1572. Matrix Diagonal Sum</h2><h3>Easy</h3><hr><div><p>Given a&nbsp;square&nbsp;matrix&nbsp;<code>mat</code>, return the sum of the matrix diagonals.</p>
+
+<p>Only include the sum of all the elements on the primary diagonal and all the elements on the secondary diagonal that are not part of the primary diagonal.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/14/sample_1911.png" style="width: 336px; height: 174px;">
+<pre><strong>Input:</strong> mat = [[<strong>1</strong>,2,<strong>3</strong>],
+&nbsp;             [4,<strong>5</strong>,6],
+&nbsp;             [<strong>7</strong>,8,<strong>9</strong>]]
+<strong>Output:</strong> 25
+<strong>Explanation: </strong>Diagonals sum: 1 + 5 + 9 + 3 + 7 = 25
+Notice that element mat[1][1] = 5 is counted only once.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> mat = [[<strong>1</strong>,1,1,<strong>1</strong>],
+&nbsp;             [1,<strong>1</strong>,<strong>1</strong>,1],
+&nbsp;             [1,<strong>1</strong>,<strong>1</strong>,1],
+&nbsp;             [<strong>1</strong>,1,1,<strong>1</strong>]]
+<strong>Output:</strong> 8
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> mat = [[<strong>5</strong>]]
+<strong>Output:</strong> 5
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == mat.length == mat[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>1 &lt;= mat[i][j] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/matrix-diagonal-sum/matrix-diagonal-sum.java b/leetcode/leetcode/matrix-diagonal-sum/matrix-diagonal-sum.java
new file mode 100644
index 0000000..0d7b173
--- /dev/null
+++ b/leetcode/leetcode/matrix-diagonal-sum/matrix-diagonal-sum.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int diagonalSum(int[][] mat) {
+        int c1 = 0;
+        int c2 = mat.length -1;
+        int sum = 0;
+        while(c1<mat.length){
+            sum = sum + mat[c1][c1] +mat[c1][c2];
+            c1++;
+            c2--;
+        }
+        if(c1%2!=0) sum = sum - mat[c1/2][c1/2];
+        return sum;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/max-consecutive-ones/README.md b/leetcode/leetcode/max-consecutive-ones/README.md
new file mode 100644
index 0000000..3054700
--- /dev/null
+++ b/leetcode/leetcode/max-consecutive-ones/README.md
@@ -0,0 +1,24 @@
+<h2>485. Max Consecutive Ones</h2><h3>Easy</h3><hr><div><p>Given a binary array <code>nums</code>, return <em>the maximum number of consecutive </em><code>1</code><em>'s in the array</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,0,1,1,1]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The first two digits or the last three digits are consecutive 1s. The maximum number of consecutive 1s is 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,0,1,1,0,1]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>nums[i]</code> is either <code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/max-consecutive-ones/max-consecutive-ones.java b/leetcode/leetcode/max-consecutive-ones/max-consecutive-ones.java
new file mode 100644
index 0000000..8124517
--- /dev/null
+++ b/leetcode/leetcode/max-consecutive-ones/max-consecutive-ones.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int findMaxConsecutiveOnes(int[] arr) {
+        int result = 0;
+        short intermediate = 0;
+        for(int i = 0;i<arr.length;i++){
+            if(arr[i] == 1){
+                intermediate++;
+            }else{
+                if(result<intermediate) result = intermediate;
+                intermediate = 0;
+            }
+        }
+        return Math.max(result,intermediate);
+    }
+}
diff --git a/leetcode/leetcode/maximum-binary-tree/README.md b/leetcode/leetcode/maximum-binary-tree/README.md
new file mode 100644
index 0000000..fbed789
--- /dev/null
+++ b/leetcode/leetcode/maximum-binary-tree/README.md
@@ -0,0 +1,42 @@
+<h2>654. Maximum Binary Tree</h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>nums</code> with no duplicates. A <strong>maximum binary tree</strong> can be built recursively from <code>nums</code> using the following algorithm:</p>
+
+<ol>
+	<li>Create a root node whose value is the maximum value in <code>nums</code>.</li>
+	<li>Recursively build the left subtree on the <strong>subarray prefix</strong> to the <strong>left</strong> of the maximum value.</li>
+	<li>Recursively build the right subtree on the <strong>subarray suffix</strong> to the <strong>right</strong> of the maximum value.</li>
+</ol>
+
+<p>Return <em>the <strong>maximum binary tree</strong> built from </em><code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/24/tree1.jpg" style="width: 302px; height: 421px;">
+<pre><strong>Input:</strong> nums = [3,2,1,6,0,5]
+<strong>Output:</strong> [6,3,5,null,2,0,null,null,1]
+<strong>Explanation:</strong> The recursive calls are as follow:
+- The largest value in [3,2,1,6,0,5] is 6. Left prefix is [3,2,1] and right suffix is [0,5].
+    - The largest value in [3,2,1] is 3. Left prefix is [] and right suffix is [2,1].
+        - Empty array, so no child.
+        - The largest value in [2,1] is 2. Left prefix is [] and right suffix is [1].
+            - Empty array, so no child.
+            - Only one element, so child is a node with value 1.
+    - The largest value in [0,5] is 5. Left prefix is [0] and right suffix is [].
+        - Only one element, so child is a node with value 0.
+        - Empty array, so no child.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/24/tree2.jpg" style="width: 182px; height: 301px;">
+<pre><strong>Input:</strong> nums = [3,2,1]
+<strong>Output:</strong> [3,null,2,null,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 1000</code></li>
+	<li>All integers in <code>nums</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-binary-tree/maximum-binary-tree.java b/leetcode/leetcode/maximum-binary-tree/maximum-binary-tree.java
new file mode 100644
index 0000000..32c541f
--- /dev/null
+++ b/leetcode/leetcode/maximum-binary-tree/maximum-binary-tree.java
@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    
+    public TreeNode helperTree(int[] nums, int si, int ei){
+        if(si>ei){
+            return null;
+        }
+        int max = si;
+        for(int i =si+1;i<=ei;i++){
+            if(nums[i]>nums[max]) max = i;
+        }
+        TreeNode root = new TreeNode(nums[max]);
+        root.left = helperTree(nums, si, max-1);
+        root.right = helperTree(nums, max+1,ei);
+        return root;
+        
+    }
+    
+    public TreeNode constructMaximumBinaryTree(int[] nums) {
+        return helperTree(nums,0,nums.length-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-depth-of-binary-tree/README.md b/leetcode/leetcode/maximum-depth-of-binary-tree/README.md
new file mode 100644
index 0000000..3a9697e
--- /dev/null
+++ b/leetcode/leetcode/maximum-depth-of-binary-tree/README.md
@@ -0,0 +1,37 @@
+<h2>104. Maximum Depth of Binary Tree</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>its maximum depth</em>.</p>
+
+<p>A binary tree's <strong>maximum depth</strong>&nbsp;is the number of nodes along the longest path from the root node down to the farthest leaf node.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg" style="width: 400px; height: 277px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,null,2]
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = []
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> root = [0]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.java b/leetcode/leetcode/maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.java
new file mode 100644
index 0000000..3abacb8
--- /dev/null
+++ b/leetcode/leetcode/maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.java
@@ -0,0 +1,21 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int maxDepth(TreeNode root) {
+        if(root == null) return 0;
+        return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-depth-of-n-ary-tree/README.md b/leetcode/leetcode/maximum-depth-of-n-ary-tree/README.md
new file mode 100644
index 0000000..e053aa1
--- /dev/null
+++ b/leetcode/leetcode/maximum-depth-of-n-ary-tree/README.md
@@ -0,0 +1,31 @@
+<h2>559. Maximum Depth of N-ary Tree</h2><h3>Easy</h3><hr><div><p>Given a n-ary tree, find its maximum depth.</p>
+
+<p>The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.</p>
+
+<p><em>Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="width: 100%; max-width: 300px;"></p>
+
+<pre><strong>Input:</strong> root = [1,null,3,2,4,null,5,6]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="width: 296px; height: 241px;"></p>
+
+<pre><strong>Input:</strong> root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
+<strong>Output:</strong> 5
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The total number of nodes is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li>The depth of the n-ary tree is less than or equal to <code>1000</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-depth-of-n-ary-tree/maximum-depth-of-n-ary-tree.java b/leetcode/leetcode/maximum-depth-of-n-ary-tree/maximum-depth-of-n-ary-tree.java
new file mode 100644
index 0000000..62f1143
--- /dev/null
+++ b/leetcode/leetcode/maximum-depth-of-n-ary-tree/maximum-depth-of-n-ary-tree.java
@@ -0,0 +1,35 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+    public int maxDepth(Node root){
+        if(root==null){
+            return 0;
+        }
+        int ans = 0;
+        for(int i=0;i<root.children.size();i++){
+            int temp = maxDepth(root.children.get(i));
+            if(temp>ans){
+                ans = temp;
+            }
+        }
+        return ans+1;
+    }
+    
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-ice-cream-bars/README.md b/leetcode/leetcode/maximum-ice-cream-bars/README.md
new file mode 100644
index 0000000..258b084
--- /dev/null
+++ b/leetcode/leetcode/maximum-ice-cream-bars/README.md
@@ -0,0 +1,39 @@
+<h2>1833. Maximum Ice Cream Bars</h2><h3>Medium</h3><hr><div><p>It is a sweltering summer day, and a boy wants to buy some ice cream bars.</p>
+
+<p>At the store, there are <code>n</code> ice cream bars. You are given an array <code>costs</code> of length <code>n</code>, where <code>costs[i]</code> is the price of the <code>i<sup>th</sup></code> ice cream bar in coins. The boy initially has <code>coins</code> coins to spend, and he wants to buy as many ice cream bars as possible.&nbsp;</p>
+
+<p>Return <em>the <strong>maximum</strong> number of ice cream bars the boy can buy with </em><code>coins</code><em> coins.</em></p>
+
+<p><strong>Note:</strong> The boy can buy the ice cream bars in any order.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> costs = [1,3,2,4,1], coins = 7
+<strong>Output:</strong> 4
+<strong>Explanation: </strong>The boy can buy ice cream bars at indices 0,1,2,4 for a total price of 1 + 3 + 2 + 1 = 7.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> costs = [10,6,8,7,7,8], coins = 5
+<strong>Output:</strong> 0
+<strong>Explanation: </strong>The boy cannot afford any of the ice cream bars.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> costs = [1,6,3,1,2,5], coins = 20
+<strong>Output:</strong> 6
+<strong>Explanation: </strong>The boy can buy all the ice cream bars for a total price of 1 + 6 + 3 + 1 + 2 + 5 = 18.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>costs.length == n</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= costs[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= coins &lt;= 10<sup>8</sup></code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-ice-cream-bars/maximum-ice-cream-bars.java b/leetcode/leetcode/maximum-ice-cream-bars/maximum-ice-cream-bars.java
new file mode 100644
index 0000000..8f1b1e8
--- /dev/null
+++ b/leetcode/leetcode/maximum-ice-cream-bars/maximum-ice-cream-bars.java
@@ -0,0 +1,25 @@
+class Solution {
+    public int maxIceCream(int[] costs, int coins) {
+        /*Arrays.sort(costs);
+        int counter = 0;
+        for(int num: costs){
+            if(coins>=num){
+                counter++;
+                coins-=num;
+            }else break;
+        }
+        return counter;
+        */
+        PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
+        for(int num: costs) pq.add(num);
+        int counter = 0;
+        while(!pq.isEmpty()){
+            int val = pq.peek();
+            if(val>coins) break;
+            counter++;
+            coins-=val;
+            pq.remove();
+        }
+        return counter;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-number-of-coins-you-can-get/README.md b/leetcode/leetcode/maximum-number-of-coins-you-can-get/README.md
new file mode 100644
index 0000000..9d95f1d
--- /dev/null
+++ b/leetcode/leetcode/maximum-number-of-coins-you-can-get/README.md
@@ -0,0 +1,46 @@
+<h2>1561. Maximum Number of Coins You Can Get</h2><h3>Medium</h3><hr><div><p>There are 3n&nbsp;piles of coins of&nbsp;varying size, you and your friends will take piles of coins as follows:</p>
+
+<ul>
+	<li>In each step, you will choose <strong>any&nbsp;</strong>3 piles of coins (not necessarily consecutive).</li>
+	<li>Of your choice,&nbsp;Alice&nbsp;will pick&nbsp;the pile with the maximum number of coins.</li>
+	<li>You will pick the next pile with maximum number of coins.</li>
+	<li>Your friend Bob will pick the last pile.</li>
+	<li>Repeat&nbsp;until&nbsp;there are no more piles of coins.</li>
+</ul>
+
+<p>Given an array of integers <code>piles</code>&nbsp;where <code>piles[i]</code> is the number of coins in the <code>i<sup>th</sup></code> pile.</p>
+
+<p>Return the maximum number of coins which you can have.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> piles = [2,4,1,2,7,8]
+<strong>Output:</strong> 9
+<strong>Explanation: </strong>Choose the triplet (2, 7, 8), Alice Pick the pile with 8 coins, you the pile with <strong>7</strong> coins and Bob the last one.
+Choose the triplet (1, 2, 4), Alice Pick the pile with 4 coins, you the pile with <strong>2</strong> coins and Bob the last one.
+The maximum number of coins which you can have are: 7 + 2 = 9.
+On the other hand if we choose this arrangement (1, <strong>2</strong>, 8), (2, <strong>4</strong>, 7) you only get 2 + 4 = 6 coins which is not optimal.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> piles = [2,4,5]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> piles = [9,8,7,6,5,1,2,3,4]
+<strong>Output:</strong> 18
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= piles.length &lt;= 10^5</code></li>
+	<li><code>piles.length % 3 == 0</code></li>
+	<li><code>1 &lt;= piles[i] &lt;= 10^4</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-number-of-coins-you-can-get/maximum-number-of-coins-you-can-get.java b/leetcode/leetcode/maximum-number-of-coins-you-can-get/maximum-number-of-coins-you-can-get.java
new file mode 100644
index 0000000..6412cff
--- /dev/null
+++ b/leetcode/leetcode/maximum-number-of-coins-you-can-get/maximum-number-of-coins-you-can-get.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int maxCoins(int[] piles){
+        Arrays.sort(piles);
+        int counter = 0;
+        int len = piles.length;
+        int current = piles.length-2;
+        int res = 0;
+        while(counter<len/3){
+            res+=piles[current];
+            current-=2;
+            counter++;
+        }
+        return res;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-product-difference-between-two-pairs/README.md b/leetcode/leetcode/maximum-product-difference-between-two-pairs/README.md
new file mode 100644
index 0000000..a0296f0
--- /dev/null
+++ b/leetcode/leetcode/maximum-product-difference-between-two-pairs/README.md
@@ -0,0 +1,34 @@
+<h2>1913. Maximum Product Difference Between Two Pairs</h2><h3>Easy</h3><hr><div><p>The <strong>product difference</strong> between two pairs <code>(a, b)</code> and <code>(c, d)</code> is defined as <code>(a * b) - (c * d)</code>.</p>
+
+<ul>
+	<li>For example, the product difference between <code>(5, 6)</code> and <code>(2, 7)</code> is <code>(5 * 6) - (2 * 7) = 16</code>.</li>
+</ul>
+
+<p>Given an integer array <code>nums</code>, choose four <strong>distinct</strong> indices <code>w</code>, <code>x</code>, <code>y</code>, and <code>z</code> such that the <strong>product difference</strong> between pairs <code>(nums[w], nums[x])</code> and <code>(nums[y], nums[z])</code> is <strong>maximized</strong>.</p>
+
+<p>Return <em>the <strong>maximum</strong> such product difference</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [5,6,2,7,4]
+<strong>Output:</strong> 34
+<strong>Explanation:</strong> We can choose indices 1 and 3 for the first pair (6, 7) and indices 2 and 4 for the second pair (2, 4).
+The product difference is (6 * 7) - (2 * 4) = 34.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [4,2,5,9,7,4,8]
+<strong>Output:</strong> 64
+<strong>Explanation:</strong> We can choose indices 3 and 6 for the first pair (9, 8) and indices 1 and 5 for the second pair (2, 4).
+The product difference is (9 * 8) - (2 * 4) = 64.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>4 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-product-difference-between-two-pairs/maximum-product-difference-between-two-pairs.java b/leetcode/leetcode/maximum-product-difference-between-two-pairs/maximum-product-difference-between-two-pairs.java
new file mode 100644
index 0000000..331c479
--- /dev/null
+++ b/leetcode/leetcode/maximum-product-difference-between-two-pairs/maximum-product-difference-between-two-pairs.java
@@ -0,0 +1,47 @@
+class Solution {  
+    
+    void swap(int arr[], int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    int partation(int arr[], int si, int ei){
+        int counter = 0;
+        for(int i = si+1;i<=ei;i++){
+            if(arr[si]>arr[i]){
+                counter++;
+            }
+        }
+        swap(arr,si,si+counter);
+        int i = si;
+        int j = ei;
+        while(i<si+counter && si+counter<j){
+            if(arr[i]>=arr[si+counter]){
+                if(arr[j]<arr[si+counter]){
+                    swap(arr,i,j);
+                    i++;
+                }
+                j--;
+            }else{
+                if(arr[j]>=arr[si+counter]){
+                    j--;
+                }
+                i++;
+            }
+        }
+        return si+counter;
+    
+    }
+    public void quickSort(int[] arr, int si, int ei){
+        if(si>=ei){
+            return;
+        }
+        int c = partation(arr,si,ei);
+        quickSort(arr,si,c-1);
+        quickSort(arr,c+1,ei);
+    }
+    public int maxProductDifference(int[] arr) {
+        quickSort(arr,0,arr.length-1);
+        return arr[arr.length -1]* arr[arr.length -2] - arr[0] * arr[1];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-product-of-three-numbers/README.md b/leetcode/leetcode/maximum-product-of-three-numbers/README.md
new file mode 100644
index 0000000..6012892
--- /dev/null
+++ b/leetcode/leetcode/maximum-product-of-three-numbers/README.md
@@ -0,0 +1,21 @@
+<h2>628. Maximum Product of Three Numbers</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code>, <em>find three numbers whose product is maximum and return the maximum product</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> 6
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> 24
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [-1,-2,-3]
+<strong>Output:</strong> -6
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= nums.length &lt;=&nbsp;10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-product-of-three-numbers/maximum-product-of-three-numbers.java b/leetcode/leetcode/maximum-product-of-three-numbers/maximum-product-of-three-numbers.java
new file mode 100644
index 0000000..a5f76ce
--- /dev/null
+++ b/leetcode/leetcode/maximum-product-of-three-numbers/maximum-product-of-three-numbers.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int maximumProduct(int[] nums) {
+        Arrays.sort(nums);
+        int len = nums.length;
+        int num1 = nums[len-1]*nums[len-2]*nums[len-3];
+        int num2 = nums[0]*nums[1]*nums[2];
+        int num3 = nums[0]*nums[1]*nums[len-1];
+        int num4 = nums[0]*nums[len-1]*nums[len-2];
+        return Math.max(Math.max(num1,num2),Math.max(num3,num4));
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-product-of-two-elements-in-an-array/README.md b/leetcode/leetcode/maximum-product-of-two-elements-in-an-array/README.md
new file mode 100644
index 0000000..6ece93c
--- /dev/null
+++ b/leetcode/leetcode/maximum-product-of-two-elements-in-an-array/README.md
@@ -0,0 +1,30 @@
+<h2>1464. Maximum Product of Two Elements in an Array</h2><h3>Easy</h3><hr><div>Given the array of integers <code>nums</code>, you will choose two different indices <code>i</code> and <code>j</code> of that array. <em>Return the maximum value of</em> <code>(nums[i]-1)*(nums[j]-1)</code>.
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,4,5,2]
+<strong>Output:</strong> 12 
+<strong>Explanation:</strong> If you choose the indices i=1 and j=2 (indexed from 0), you will get the maximum value, that is, (nums[1]-1)*(nums[2]-1) = (4-1)*(5-1) = 3*4 = 12. 
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,5,4,5]
+<strong>Output:</strong> 16
+<strong>Explanation:</strong> Choosing the indices i=1 and j=3 (indexed from 0), you will get the maximum value of (5-1)*(5-1) = 16.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,7]
+<strong>Output:</strong> 12
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 500</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10^3</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-product-of-two-elements-in-an-array/maximum-product-of-two-elements-in-an-array.java b/leetcode/leetcode/maximum-product-of-two-elements-in-an-array/maximum-product-of-two-elements-in-an-array.java
new file mode 100644
index 0000000..b6ffce5
--- /dev/null
+++ b/leetcode/leetcode/maximum-product-of-two-elements-in-an-array/maximum-product-of-two-elements-in-an-array.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int maxProduct(int[] nums) {
+        int max = 0;
+        int secondMax = -1;
+        for(int num: nums){
+            if(num>max){
+                secondMax = max;
+                max = num;
+            }else if(num<=max && num>secondMax){
+                secondMax = num;
+            }
+        }
+        return (max-1)*(secondMax-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-product-subarray/README.md b/leetcode/leetcode/maximum-product-subarray/README.md
new file mode 100644
index 0000000..608ace2
--- /dev/null
+++ b/leetcode/leetcode/maximum-product-subarray/README.md
@@ -0,0 +1,30 @@
+<h2>152. Maximum Product Subarray</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, find a contiguous non-empty subarray within the array that has the largest product, and return <em>the product</em>.</p>
+
+<p>It is <strong>guaranteed</strong> that the answer will fit in a <strong>32-bit</strong> integer.</p>
+
+<p>A <strong>subarray</strong> is a contiguous subsequence of the array.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,3,-2,4]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> [2,3] has the largest product 6.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-2,0,-1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The result cannot be 2, because [-2,-1] is not a subarray.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>-10 &lt;= nums[i] &lt;= 10</code></li>
+	<li>The product of any prefix or suffix of <code>nums</code> is <strong>guaranteed</strong> to fit in a <strong>32-bit</strong> integer.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-product-subarray/maximum-product-subarray.java b/leetcode/leetcode/maximum-product-subarray/maximum-product-subarray.java
new file mode 100644
index 0000000..d39dc85
--- /dev/null
+++ b/leetcode/leetcode/maximum-product-subarray/maximum-product-subarray.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int maxProduct(int[] nums) {
+        int ans = Integer.MIN_VALUE;
+        int cProd = 1;
+        for(int i=0;i<nums.length;i++){
+            cProd*=nums[i];
+            ans = Math.max(cProd, ans);
+            if(cProd == 0) cProd = 1;
+        }
+        cProd =1;
+        for(int i=nums.length-1;i>=0;i--){
+            cProd*=nums[i];
+            ans = Math.max(cProd, ans);
+            if(cProd == 0) cProd = 1;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-subarray/README.md b/leetcode/leetcode/maximum-subarray/README.md
new file mode 100644
index 0000000..f214b51
--- /dev/null
+++ b/leetcode/leetcode/maximum-subarray/README.md
@@ -0,0 +1,35 @@
+<h2>53. Maximum Subarray</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code>, find the contiguous subarray (containing at least one number) which has the largest sum and return <em>its sum</em>.</p>
+
+<p>A <strong>subarray</strong> is a <strong>contiguous</strong> part of an array.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-2,1,-3,4,-1,2,1,-5,4]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> [4,-1,2,1] has the largest sum = 6.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [5,4,-1,7,8]
+<strong>Output:</strong> 23
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> If you have figured out the <code>O(n)</code> solution, try coding another solution using the <strong>divide and conquer</strong> approach, which is more subtle.</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/maximum-subarray/maximum-subarray.java b/leetcode/leetcode/maximum-subarray/maximum-subarray.java
new file mode 100644
index 0000000..992862d
--- /dev/null
+++ b/leetcode/leetcode/maximum-subarray/maximum-subarray.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int maxSoFar = Integer.MIN_VALUE;
+        int maxEndingHere = 0;
+        for(int num: nums){
+            maxEndingHere+=num;
+            if(maxEndingHere<num) maxEndingHere = num;
+            if(maxSoFar<maxEndingHere) maxSoFar = maxEndingHere;
+        }
+        return maxSoFar;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/median-of-two-sorted-arrays/README.md b/leetcode/leetcode/median-of-two-sorted-arrays/README.md
new file mode 100644
index 0000000..9bed02b
--- /dev/null
+++ b/leetcode/leetcode/median-of-two-sorted-arrays/README.md
@@ -0,0 +1,49 @@
+<h2>4. Median of Two Sorted Arrays</h2><h3>Hard</h3><hr><div><p>Given two sorted arrays <code>nums1</code> and <code>nums2</code> of size <code>m</code> and <code>n</code> respectively, return <strong>the median</strong> of the two sorted arrays.</p>
+
+<p>The overall run time complexity should be <code>O(log (m+n))</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,3], nums2 = [2]
+<strong>Output:</strong> 2.00000
+<strong>Explanation:</strong> merged array = [1,2,3] and median is 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2], nums2 = [3,4]
+<strong>Output:</strong> 2.50000
+<strong>Explanation:</strong> merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [0,0], nums2 = [0,0]
+<strong>Output:</strong> 0.00000
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [], nums2 = [1]
+<strong>Output:</strong> 1.00000
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [2], nums2 = []
+<strong>Output:</strong> 2.00000
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>nums1.length == m</code></li>
+	<li><code>nums2.length == n</code></li>
+	<li><code>0 &lt;= m &lt;= 1000</code></li>
+	<li><code>0 &lt;= n &lt;= 1000</code></li>
+	<li><code>1 &lt;= m + n &lt;= 2000</code></li>
+	<li><code>-10<sup>6</sup> &lt;= nums1[i], nums2[i] &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/median-of-two-sorted-arrays/median-of-two-sorted-arrays.java b/leetcode/leetcode/median-of-two-sorted-arrays/median-of-two-sorted-arrays.java
new file mode 100644
index 0000000..848d223
--- /dev/null
+++ b/leetcode/leetcode/median-of-two-sorted-arrays/median-of-two-sorted-arrays.java
@@ -0,0 +1,33 @@
+class Solution {
+    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+        int len1 = nums1.length;
+        int len2 = nums2.length;
+        int[] res = new int[len1+len2];
+        int c1 =0;
+        int c2 = 0;
+        for(int i= 0;i<len1+len2;i++){
+            int val1 = Integer.MAX_VALUE;
+            int val2 = Integer.MAX_VALUE;
+            if(c1<len1){
+                val1 = nums1[c1];
+            }
+            if(c2<len2){
+                val2 = nums2[c2];
+            }
+            if(val1>val2){
+                res[i] = val2;
+                c2++;
+            }else{
+                res[i] = val1;
+                c1++;
+            }
+        }
+        if((len1+len2)%2==0){
+            return (double) (res[(len1+len2)/2 ] + res[ (len1+len2)/2 - 1 ])/2;
+        
+        }else{
+            return (double) res[(len1+len2)/2];
+        }
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/merge-in-between-linked-lists/README.md b/leetcode/leetcode/merge-in-between-linked-lists/README.md
new file mode 100644
index 0000000..216e200
--- /dev/null
+++ b/leetcode/leetcode/merge-in-between-linked-lists/README.md
@@ -0,0 +1,32 @@
+<h2>1669. Merge In Between Linked Lists</h2><h3>Medium</h3><hr><div><p>You are given two linked lists: <code>list1</code> and <code>list2</code> of sizes <code>n</code> and <code>m</code> respectively.</p>
+
+<p>Remove <code>list1</code>'s nodes from the <code>a<sup>th</sup></code> node to the <code>b<sup>th</sup></code> node, and put <code>list2</code> in their place.</p>
+
+<p>The blue edges and nodes in the following figure indicate the result:</p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/05/fig1.png" style="height: 130px; width: 504px;">
+<p><em>Build the result list and return its head.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/05/merge_linked_list_ex1.png" style="width: 406px; height: 140px;">
+<pre><strong>Input:</strong> list1 = [0,1,2,3,4,5], a = 3, b = 4, list2 = [1000000,1000001,1000002]
+<strong>Output:</strong> [0,1,2,1000000,1000001,1000002,5]
+<strong>Explanation:</strong> We remove the nodes 3 and 4 and put the entire list2 in their place. The blue edges and nodes in the above figure indicate the result.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/05/merge_linked_list_ex2.png" style="width: 463px; height: 140px;">
+<pre><strong>Input:</strong> list1 = [0,1,2,3,4,5,6], a = 2, b = 5, list2 = [1000000,1000001,1000002,1000003,1000004]
+<strong>Output:</strong> [0,1,1000000,1000001,1000002,1000003,1000004,6]
+<strong>Explanation:</strong> The blue edges and nodes in the above figure indicate the result.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= list1.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= a &lt;= b &lt; list1.length - 1</code></li>
+	<li><code>1 &lt;= list2.length &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/merge-in-between-linked-lists/merge-in-between-linked-lists.java b/leetcode/leetcode/merge-in-between-linked-lists/merge-in-between-linked-lists.java
new file mode 100644
index 0000000..1440917
--- /dev/null
+++ b/leetcode/leetcode/merge-in-between-linked-lists/merge-in-between-linked-lists.java
@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
+        ListNode temp = list1;
+        int counter = 1;
+        while(counter!=a){
+            temp = temp.next;
+            ++counter;
+        }
+        ListNode temp2 = temp.next;
+        temp.next = list2;
+        while(temp.next!=null){
+            temp = temp.next;
+        }
+        while(counter!=b){
+            temp2 = temp2.next;
+            ++counter;
+        }
+        temp.next = temp2.next;
+        return list1;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/merge-two-sorted-lists/README.md b/leetcode/leetcode/merge-two-sorted-lists/README.md
new file mode 100644
index 0000000..0a79189
--- /dev/null
+++ b/leetcode/leetcode/merge-two-sorted-lists/README.md
@@ -0,0 +1,30 @@
+<h2>21. Merge Two Sorted Lists</h2><h3>Easy</h3><hr><div><p>Merge two sorted linked lists and return it as a <strong>sorted</strong> list. The list should be made by splicing together the nodes of the first two lists.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg" style="width: 662px; height: 302px;">
+<pre><strong>Input:</strong> l1 = [1,2,4], l2 = [1,3,4]
+<strong>Output:</strong> [1,1,2,3,4,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> l1 = [], l2 = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> l1 = [], l2 = [0]
+<strong>Output:</strong> [0]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in both lists is in the range <code>[0, 50]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li>Both <code>l1</code> and <code>l2</code> are sorted in <strong>non-decreasing</strong> order.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/merge-two-sorted-lists/merge-two-sorted-lists.java b/leetcode/leetcode/merge-two-sorted-lists/merge-two-sorted-lists.java
new file mode 100644
index 0000000..943b8fd
--- /dev/null
+++ b/leetcode/leetcode/merge-two-sorted-lists/merge-two-sorted-lists.java
@@ -0,0 +1,36 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        if(l1==null) return l2;
+        if(l2==null) return l1;
+        ListNode head = new ListNode();
+        ListNode main = head;
+        
+        while(l1!=null || l2!=null){
+            if(l1==null){
+                main.next = l2;
+                break;
+            }else if(l2==null){
+                main.next = l1;
+                break;
+            }else if(l1.val>l2.val){
+                main.next = new ListNode(l2.val);
+                l2 = l2.next;
+            }else{
+                main.next = new ListNode(l1.val);
+                l1 = l1.next;
+            }    
+            main = main.next;
+        }
+        return head.next;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/middle-of-the-linked-list/README.md b/leetcode/leetcode/middle-of-the-linked-list/README.md
new file mode 100644
index 0000000..5ac8a92
--- /dev/null
+++ b/leetcode/leetcode/middle-of-the-linked-list/README.md
@@ -0,0 +1,27 @@
+<h2>876. Middle of the Linked List</h2><h3>Easy</h3><hr><div><p>Given the <code>head</code> of a singly linked list, return <em>the middle node of the linked list</em>.</p>
+
+<p>If there are two middle nodes, return <strong>the second middle</strong> node.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/07/23/lc-midlist1.jpg" style="width: 544px; height: 65px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5]
+<strong>Output:</strong> [3,4,5]
+<strong>Explanation:</strong> The middle node of the list is node 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/07/23/lc-midlist2.jpg" style="width: 664px; height: 65px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5,6]
+<strong>Output:</strong> [4,5,6]
+<strong>Explanation:</strong> Since the list has two middle nodes with values 3 and 4, we return the second one.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 100]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/middle-of-the-linked-list/middle-of-the-linked-list.java b/leetcode/leetcode/middle-of-the-linked-list/middle-of-the-linked-list.java
new file mode 100644
index 0000000..f1dc778
--- /dev/null
+++ b/leetcode/leetcode/middle-of-the-linked-list/middle-of-the-linked-list.java
@@ -0,0 +1,21 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode middleNode(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast!=null && fast.next!=null){
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return slow;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/minimize-maximum-pair-sum-in-array/README.md b/leetcode/leetcode/minimize-maximum-pair-sum-in-array/README.md
new file mode 100644
index 0000000..71ee0ad
--- /dev/null
+++ b/leetcode/leetcode/minimize-maximum-pair-sum-in-array/README.md
@@ -0,0 +1,41 @@
+<h2>1877. Minimize Maximum Pair Sum in Array</h2><h3>Medium</h3><hr><div><p>The <strong>pair sum</strong> of a pair <code>(a,b)</code> is equal to <code>a + b</code>. The <strong>maximum pair sum</strong> is the largest <strong>pair sum</strong> in a list of pairs.</p>
+
+<ul>
+	<li>For example, if we have pairs <code>(1,5)</code>, <code>(2,3)</code>, and <code>(4,4)</code>, the <strong>maximum pair sum</strong> would be <code>max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8</code>.</li>
+</ul>
+
+<p>Given an array <code>nums</code> of <strong>even</strong> length <code>n</code>, pair up the elements of <code>nums</code> into <code>n / 2</code> pairs such that:</p>
+
+<ul>
+	<li>Each element of <code>nums</code> is in <strong>exactly one</strong> pair, and</li>
+	<li>The <strong>maximum pair sum </strong>is <strong>minimized</strong>.</li>
+</ul>
+
+<p>Return <em>the minimized <strong>maximum pair sum</strong> after optimally pairing up the elements</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,5,2,3]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> The elements can be paired up into pairs (3,3) and (5,2).
+The maximum pair sum is max(3+3, 5+2) = max(6, 7) = 7.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,5,4,2,4,6]
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> The elements can be paired up into pairs (3,5), (4,4), and (6,2).
+The maximum pair sum is max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>n</code> is <strong>even</strong>.</li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>5</sup></code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/minimize-maximum-pair-sum-in-array/minimize-maximum-pair-sum-in-array.java b/leetcode/leetcode/minimize-maximum-pair-sum-in-array/minimize-maximum-pair-sum-in-array.java
new file mode 100644
index 0000000..c106b2a
--- /dev/null
+++ b/leetcode/leetcode/minimize-maximum-pair-sum-in-array/minimize-maximum-pair-sum-in-array.java
@@ -0,0 +1,18 @@
+class Solution {   
+        
+    public int minPairSum(int[] arr) {
+        Arrays.sort(arr);
+        int result = 0;
+        int min = 0;
+        int max = arr.length-1;
+        while(min<=max){
+            if(result<arr[min] + arr[max]){
+                result = arr[min] + arr[max];
+            }
+            min++;
+            max--;
+        }
+        return result;
+        
+    }
+}
diff --git a/leetcode/leetcode/minimum-absolute-difference/README.md b/leetcode/leetcode/minimum-absolute-difference/README.md
new file mode 100644
index 0000000..1596a10
--- /dev/null
+++ b/leetcode/leetcode/minimum-absolute-difference/README.md
@@ -0,0 +1,37 @@
+<h2>1200. Minimum Absolute Difference</h2><h3>Easy</h3><hr><div><p>Given an&nbsp;array&nbsp;of <strong>distinct</strong>&nbsp;integers <code>arr</code>, find all pairs of elements with the minimum absolute difference of any two elements.&nbsp;</p>
+
+<p>Return a list of pairs in ascending order(with respect to pairs), each pair <code>[a, b]</code> follows</p>
+
+<ul>
+	<li><code>a, b</code> are from <code>arr</code></li>
+	<li><code>a &lt; b</code></li>
+	<li><code>b - a</code>&nbsp;equals to the minimum absolute difference of any two elements in <code>arr</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [4,2,1,3]
+<strong>Output:</strong> [[1,2],[2,3],[3,4]]
+<strong>Explanation: </strong>The minimum absolute difference is 1. List all pairs with difference equal to 1 in ascending order.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,3,6,10,15]
+<strong>Output:</strong> [[1,3]]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [3,8,-10,23,19,-4,-14,27]
+<strong>Output:</strong> [[-14,-10],[19,23],[23,27]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= arr.length &lt;= 10^5</code></li>
+	<li><code>-10^6 &lt;= arr[i] &lt;= 10^6</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/minimum-absolute-difference/minimum-absolute-difference.java b/leetcode/leetcode/minimum-absolute-difference/minimum-absolute-difference.java
new file mode 100644
index 0000000..c53432e
--- /dev/null
+++ b/leetcode/leetcode/minimum-absolute-difference/minimum-absolute-difference.java
@@ -0,0 +1,18 @@
+class Solution {
+    public List<List<Integer>> minimumAbsDifference(int[] arr) {
+        Arrays.sort(arr);
+        List<List<Integer>> list =new ArrayList<>();
+        int min_diff = Integer.MAX_VALUE;
+        for(int i =1;i<arr.length;i++){
+            int diff = arr[i] - arr[i-1];
+            if(diff == min_diff){
+                list.add(Arrays.asList(arr[i-1],arr[i]));
+            }else if(diff<min_diff){
+                list.clear();
+                list.add(Arrays.asList(arr[i-1],arr[i]));
+                min_diff = diff;
+            }
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/minimum-moves-to-equal-array-elements-ii/README.md b/leetcode/leetcode/minimum-moves-to-equal-array-elements-ii/README.md
new file mode 100644
index 0000000..8752122
--- /dev/null
+++ b/leetcode/leetcode/minimum-moves-to-equal-array-elements-ii/README.md
@@ -0,0 +1,31 @@
+<h2>462. Minimum Moves to Equal Array Elements II</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> of size <code>n</code>, return <em>the minimum number of moves required to make all array elements equal</em>.</p>
+
+<p>In one move, you can increment or decrement an element of the array by <code>1</code>.</p>
+
+<p>Test cases are designed so that the answer will fit in a <strong>32-bit</strong> integer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+Only two moves are needed (remember each move increments or decrements one element):
+[<u>1</u>,2,3]  =&gt;  [2,2,<u>3</u>]  =&gt;  [2,2,2]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,10,2,9]
+<strong>Output:</strong> 16
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/minimum-moves-to-equal-array-elements-ii/minimum-moves-to-equal-array-elements-ii.java b/leetcode/leetcode/minimum-moves-to-equal-array-elements-ii/minimum-moves-to-equal-array-elements-ii.java
new file mode 100644
index 0000000..b2cb424
--- /dev/null
+++ b/leetcode/leetcode/minimum-moves-to-equal-array-elements-ii/minimum-moves-to-equal-array-elements-ii.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int minMoves2(int[] nums) {
+        Arrays.sort(nums);
+        int len = nums.length;
+        int median = 0;
+        if(len%2!=0) median = nums[len/2];
+        else median = (nums[len/2] + nums[len/2 -1])/2;
+        int res = 0;
+        for(int i = 0;i<len;i++){
+            res += Math.abs(nums[i]-median);
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/minimum-number-of-operations-to-move-all-balls-to-each-box/README.md b/leetcode/leetcode/minimum-number-of-operations-to-move-all-balls-to-each-box/README.md
new file mode 100644
index 0000000..561fba7
--- /dev/null
+++ b/leetcode/leetcode/minimum-number-of-operations-to-move-all-balls-to-each-box/README.md
@@ -0,0 +1,33 @@
+<h2>1769. Minimum Number of Operations to Move All Balls to Each Box</h2><h3>Medium</h3><hr><div><p>You have <code>n</code> boxes. You are given a binary string <code>boxes</code> of length <code>n</code>, where <code>boxes[i]</code> is <code>'0'</code> if the <code>i<sup>th</sup></code> box is <strong>empty</strong>, and <code>'1'</code> if it contains <strong>one</strong> ball.</p>
+
+<p>In one operation, you can move <strong>one</strong> ball from a box to an adjacent box. Box <code>i</code> is adjacent to box <code>j</code> if <code>abs(i - j) == 1</code>. Note that after doing so, there may be more than one ball in some boxes.</p>
+
+<p>Return an array <code>answer</code> of size <code>n</code>, where <code>answer[i]</code> is the <strong>minimum</strong> number of operations needed to move all the balls to the <code>i<sup>th</sup></code> box.</p>
+
+<p>Each <code>answer[i]</code> is calculated considering the <strong>initial</strong> state of the boxes.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> boxes = "110"
+<strong>Output:</strong> [1,1,3]
+<strong>Explanation:</strong> The answer for each box is as follows:
+1) First box: you will have to move one ball from the second box to the first box in one operation.
+2) Second box: you will have to move one ball from the first box to the second box in one operation.
+3) Third box: you will have to move one ball from the first box to the third box in two operations, and move one ball from the second box to the third box in one operation.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> boxes = "001011"
+<strong>Output:</strong> [11,8,5,4,3,4]</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == boxes.length</code></li>
+	<li><code>1 &lt;= n &lt;= 2000</code></li>
+	<li><code>boxes[i]</code> is either <code>'0'</code> or <code>'1'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/minimum-number-of-operations-to-move-all-balls-to-each-box/minimum-number-of-operations-to-move-all-balls-to-each-box.java b/leetcode/leetcode/minimum-number-of-operations-to-move-all-balls-to-each-box/minimum-number-of-operations-to-move-all-balls-to-each-box.java
new file mode 100644
index 0000000..40a882e
--- /dev/null
+++ b/leetcode/leetcode/minimum-number-of-operations-to-move-all-balls-to-each-box/minimum-number-of-operations-to-move-all-balls-to-each-box.java
@@ -0,0 +1,26 @@
+class Solution {
+    public int[] minOperations(String boxes) {
+        int[] result =  new int[boxes.length()];
+        int smallResult;
+        for(int i = 0;i<boxes.length();i++){
+            smallResult = 0;
+            for(int j = 0;j<boxes.length();j++){
+                if(i==j){
+                    continue;
+                }
+                if(boxes.charAt(j) == '1'){
+                    if(i-j<0){
+                        smallResult  = smallResult + j-i;
+                    }else{
+                        smallResult = smallResult + i - j;
+                    };
+                }
+                
+            }
+            result[i]  =smallResult;
+            
+        }
+    return result;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/minimum-number-of-steps-to-make-two-strings-anagram/README.md b/leetcode/leetcode/minimum-number-of-steps-to-make-two-strings-anagram/README.md
new file mode 100644
index 0000000..91c6477
--- /dev/null
+++ b/leetcode/leetcode/minimum-number-of-steps-to-make-two-strings-anagram/README.md
@@ -0,0 +1,49 @@
+<h2>1347. Minimum Number of Steps to Make Two Strings Anagram</h2><h3>Medium</h3><hr><div><p>Given two equal-size strings <code>s</code> and <code>t</code>. In one step you can choose <strong>any character</strong> of <code>t</code> and replace it with <strong>another character</strong>.</p>
+
+<p>Return <em>the minimum number of steps</em> to make <code>t</code>&nbsp;an anagram of <code>s</code>.</p>
+
+<p>An&nbsp;<strong>Anagram</strong>&nbsp;of a&nbsp;string&nbsp;is a string that contains the same characters with a different (or the same) ordering.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "bab", t = "aba"
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> Replace the first 'a' in t with b, t = "bba" which is anagram of s.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "leetcode", t = "practice"
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> Replace 'p', 'r', 'a', 'i' and 'c' from t with proper characters to make t anagram of s.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "anagram", t = "mangaar"
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> "anagram" and "mangaar" are anagrams. 
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> s = "xxyyzz", t = "xxyyzz"
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> s = "friend", t = "family"
+<strong>Output:</strong> 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 50000</code></li>
+	<li><code>s.length == t.length</code></li>
+	<li><code>s</code> and <code>t</code> contain lower-case English letters only.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/minimum-number-of-steps-to-make-two-strings-anagram/minimum-number-of-steps-to-make-two-strings-anagram.java b/leetcode/leetcode/minimum-number-of-steps-to-make-two-strings-anagram/minimum-number-of-steps-to-make-two-strings-anagram.java
new file mode 100644
index 0000000..9952213
--- /dev/null
+++ b/leetcode/leetcode/minimum-number-of-steps-to-make-two-strings-anagram/minimum-number-of-steps-to-make-two-strings-anagram.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int minSteps(String s, String t) {
+        int[] arr = new int[26];
+        for(int i=0;i<s.length();i++){
+            arr[((int) s.charAt(i)) - 97]++;
+            arr[((int) t.charAt(i)) - 97]--;
+        }
+        int counter = 0;
+        boolean divideBy2 = false;
+        for(int num: arr){
+            if(num<0) {
+                counter-=num;
+                divideBy2 = true;
+            }
+            else counter+=num;
+            
+        }
+        
+        return divideBy2 ? counter/2: counter;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/minimum-operations-to-make-array-equal/README.md b/leetcode/leetcode/minimum-operations-to-make-array-equal/README.md
new file mode 100644
index 0000000..8da7e66
--- /dev/null
+++ b/leetcode/leetcode/minimum-operations-to-make-array-equal/README.md
@@ -0,0 +1,29 @@
+<h2>1551. Minimum Operations to Make Array Equal</h2><h3>Medium</h3><hr><div><p>You have an array <code>arr</code> of length <code>n</code> where <code>arr[i] = (2 * i) + 1</code> for all valid values of <code>i</code> (i.e.,&nbsp;<code>0 &lt;= i &lt; n</code>).</p>
+
+<p>In one operation, you can select two indices <code>x</code> and <code>y</code> where <code>0 &lt;= x, y &lt; n</code> and subtract <code>1</code> from <code>arr[x]</code> and add <code>1</code> to <code>arr[y]</code> (i.e., perform <code>arr[x] -=1 </code>and <code>arr[y] += 1</code>). The goal is to make all the elements of the array <strong>equal</strong>. It is <strong>guaranteed</strong> that all the elements of the array can be made equal using some operations.</p>
+
+<p>Given an integer <code>n</code>, the length of the array, return <em>the minimum number of operations</em> needed to make all the elements of arr equal.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> arr = [1, 3, 5]
+First operation choose x = 2 and y = 0, this leads arr to be [2, 3, 4]
+In the second operation choose x = 2 and y = 0 again, thus arr = [3, 3, 3].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 6
+<strong>Output:</strong> 9
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/minimum-operations-to-make-array-equal/minimum-operations-to-make-array-equal.java b/leetcode/leetcode/minimum-operations-to-make-array-equal/minimum-operations-to-make-array-equal.java
new file mode 100644
index 0000000..ffd06c3
--- /dev/null
+++ b/leetcode/leetcode/minimum-operations-to-make-array-equal/minimum-operations-to-make-array-equal.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int minOperations(int n) {
+        int median;
+        if(n%2==0){
+            median = ((2*(n/2) )+1 + (2*(n/2 - 1)) + 1)/2;
+        }else{
+            median = 2*(n/2)+1;
+        }
+        int c1 = 0;
+        int ans = 0;
+        while(c1<n/2){
+            ans+= median - ((2*c1) + 1);
+            c1++;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/missing-number/README.md b/leetcode/leetcode/missing-number/README.md
new file mode 100644
index 0000000..222737e
--- /dev/null
+++ b/leetcode/leetcode/missing-number/README.md
@@ -0,0 +1,43 @@
+<h2>268. Missing Number</h2><h3>Easy</h3><hr><div><p>Given an array <code>nums</code> containing <code>n</code> distinct numbers in the range <code>[0, n]</code>, return <em>the only number in the range that is missing from the array.</em></p>
+
+<p><b>Follow up:</b> Could you implement a solution using only <code>O(1)</code> extra space complexity and <code>O(n)</code> runtime complexity?</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,0,1]
+<strong>Output:</strong> 2
+<b>Explanation</b><strong>:</strong> n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1]
+<strong>Output:</strong> 2
+<b>Explanation</b><strong>:</strong> n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [9,6,4,2,3,5,7,0,1]
+<strong>Output:</strong> 8
+<b>Explanation</b><strong>:</strong> n = 9 since there are 9 numbers, so all numbers are in the range [0,9]. 8 is the missing number in the range since it does not appear in nums.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0]
+<strong>Output:</strong> 1
+<b>Explanation</b><strong>:</strong> n = 1 since there is 1 number, so all numbers are in the range [0,1]. 1 is the missing number in the range since it does not appear in nums.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= nums[i] &lt;= n</code></li>
+	<li>All the numbers of <code>nums</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/missing-number/missing-number.java b/leetcode/leetcode/missing-number/missing-number.java
new file mode 100644
index 0000000..91d0cfd
--- /dev/null
+++ b/leetcode/leetcode/missing-number/missing-number.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int missingNumber(int[] nums) {
+        int n = nums.length;
+        int sum = 0;
+        for(int num: nums){
+            sum +=num;
+        }
+        return (n+1)*(n)/2 - sum;
+    }
+}
diff --git a/leetcode/leetcode/move-zeroes/README.md b/leetcode/leetcode/move-zeroes/README.md
new file mode 100644
index 0000000..e61040f
--- /dev/null
+++ b/leetcode/leetcode/move-zeroes/README.md
@@ -0,0 +1,23 @@
+[Discussion Post (created on 16/11/2021 at 23:22)](https://leetcode.com/problems/move-zeroes/discuss/1631711/O(N)-JAVA)  
+<h2>283. Move Zeroes</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code>, move all <code>0</code>'s to the end of it while maintaining the relative order of the non-zero elements.</p>
+
+<p><strong>Note</strong> that you must do this in-place without making a copy of the array.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [0,1,0,3,12]
+<strong>Output:</strong> [1,3,12,0,0]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [0]
+<strong>Output:</strong> [0]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you minimize the total number of operations done?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/move-zeroes/move-zeroes.java b/leetcode/leetcode/move-zeroes/move-zeroes.java
new file mode 100644
index 0000000..2482bc2
--- /dev/null
+++ b/leetcode/leetcode/move-zeroes/move-zeroes.java
@@ -0,0 +1,14 @@
+class Solution {
+    public void swap(int[] arr, int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    public void moveZeroes(int[] nums) {
+        int zeros = 0;
+        for(int i=0;i<nums.length;i++){
+            if(nums[i]==0) zeros++;
+            else swap(nums,i,i-zeros);
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/n-ary-tree-postorder-traversal/README.md b/leetcode/leetcode/n-ary-tree-postorder-traversal/README.md
new file mode 100644
index 0000000..6b23460
--- /dev/null
+++ b/leetcode/leetcode/n-ary-tree-postorder-traversal/README.md
@@ -0,0 +1,29 @@
+<h2>590. N-ary Tree Postorder Traversal</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of an n-ary tree, return <em>the postorder traversal of its nodes' values</em>.</p>
+
+<p>Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="width: 100%; max-width: 300px;">
+<pre><strong>Input:</strong> root = [1,null,3,2,4,null,5,6]
+<strong>Output:</strong> [5,6,3,2,4,1]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="width: 296px; height: 241px;">
+<pre><strong>Input:</strong> root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
+<strong>Output:</strong> [2,6,14,11,7,3,12,8,4,13,9,10,5,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li>The height of the n-ary tree is less than or equal to <code>1000</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/n-ary-tree-postorder-traversal/n-ary-tree-postorder-traversal.java b/leetcode/leetcode/n-ary-tree-postorder-traversal/n-ary-tree-postorder-traversal.java
new file mode 100644
index 0000000..13d360d
--- /dev/null
+++ b/leetcode/leetcode/n-ary-tree-postorder-traversal/n-ary-tree-postorder-traversal.java
@@ -0,0 +1,32 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+    public List<Integer> postorder(Node root) {
+        ArrayList<Integer> list = new ArrayList<Integer>();
+        if(root==null){
+            return list;
+        }
+        for(int i=0;i<root.children.size();i++){
+            list.addAll(postorder(root.children.get(i)));
+        }
+        list.add(root.val);
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/n-ary-tree-preorder-traversal/README.md b/leetcode/leetcode/n-ary-tree-preorder-traversal/README.md
new file mode 100644
index 0000000..d20897a
--- /dev/null
+++ b/leetcode/leetcode/n-ary-tree-preorder-traversal/README.md
@@ -0,0 +1,33 @@
+<h2>589. N-ary Tree Preorder Traversal</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of an n-ary tree, return <em>the preorder traversal of its nodes' values</em>.</p>
+
+<p>Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><img src="https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png" style="width: 100%; max-width: 300px;"></p>
+
+<pre><strong>Input:</strong> root = [1,null,3,2,4,null,5,6]
+<strong>Output:</strong> [1,3,5,6,2,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png" style="width: 296px; height: 241px;"></p>
+
+<pre><strong>Input:</strong> root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
+<strong>Output:</strong> [1,2,3,6,7,11,14,4,8,12,5,9,13,10]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li>The height of the n-ary tree is less than or equal to <code>1000</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Recursive solution is trivial, could you do it iteratively?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/n-ary-tree-preorder-traversal/n-ary-tree-preorder-traversal.java b/leetcode/leetcode/n-ary-tree-preorder-traversal/n-ary-tree-preorder-traversal.java
new file mode 100644
index 0000000..3b15f1b
--- /dev/null
+++ b/leetcode/leetcode/n-ary-tree-preorder-traversal/n-ary-tree-preorder-traversal.java
@@ -0,0 +1,32 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+    public List<Integer> preorder(Node root) {
+        List<Integer> list = new ArrayList<Integer>();
+        if(root==null){
+            return list;
+        }
+        list.add(root.val);
+        for(int i =0;i<root.children.size();i++){
+            list.addAll(preorder(root.children.get(i)));
+        }
+        return list;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/n-repeated-element-in-size-2n-array/README.md b/leetcode/leetcode/n-repeated-element-in-size-2n-array/README.md
new file mode 100644
index 0000000..162022f
--- /dev/null
+++ b/leetcode/leetcode/n-repeated-element-in-size-2n-array/README.md
@@ -0,0 +1,31 @@
+<h2>961. N-Repeated Element in Size 2N Array</h2><h3>Easy</h3><hr><div><p>You are given an integer array <code>nums</code> with the following properties:</p>
+
+<ul>
+	<li><code>nums.length == 2 * n</code>.</li>
+	<li><code>nums</code> contains <code>n + 1</code> <strong>unique</strong> elements.</li>
+	<li>Exactly one element of <code>nums</code> is repeated <code>n</code> times.</li>
+</ul>
+
+<p>Return <em>the element that is repeated </em><code>n</code><em> times</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3,3]
+<strong>Output:</strong> 3
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [2,1,2,5,3,2]
+<strong>Output:</strong> 2
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [5,1,5,2,5,3,5,4]
+<strong>Output:</strong> 5
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 5000</code></li>
+	<li><code>nums.length == 2 * n</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+	<li><code>nums</code> contains <code>n + 1</code> <strong>unique</strong> elements and one of them is repeated exactly <code>n</code> times.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/n-repeated-element-in-size-2n-array/n-repeated-element-in-size-2n-array.java b/leetcode/leetcode/n-repeated-element-in-size-2n-array/n-repeated-element-in-size-2n-array.java
new file mode 100644
index 0000000..15571ec
--- /dev/null
+++ b/leetcode/leetcode/n-repeated-element-in-size-2n-array/n-repeated-element-in-size-2n-array.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int repeatedNTimes(int[] arr) {
+        
+        for(int i=2;i<arr.length;i++){
+            if( (arr[i]^arr[i-1])==0 || (arr[i]^arr[i-2])==0 ) {
+                return arr[i];
+            }
+        }
+        return arr[0];
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/number-complement/README.md b/leetcode/leetcode/number-complement/README.md
new file mode 100644
index 0000000..52a078b
--- /dev/null
+++ b/leetcode/leetcode/number-complement/README.md
@@ -0,0 +1,33 @@
+<h2>476. Number Complement</h2><h3>Easy</h3><hr><div><p>The <strong>complement</strong> of an integer is the integer you get when you flip all the <code>0</code>'s to <code>1</code>'s and all the <code>1</code>'s to <code>0</code>'s in its binary representation.</p>
+
+<ul>
+	<li>For example, The integer <code>5</code> is <code>"101"</code> in binary and its <strong>complement</strong> is <code>"010"</code> which is the integer <code>2</code>.</li>
+</ul>
+
+<p>Given an integer <code>num</code>, return <em>its complement</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 5
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The binary representation of 5 is 101 (no leading zero bits), and its complement is 010. So you need to output 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = 1
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The binary representation of 1 is 1 (no leading zero bits), and its complement is 0. So you need to output 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= num &lt; 2<sup>31</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as 1009: <a href="https://leetcode.com/problems/complement-of-base-10-integer/" target="_blank">https://leetcode.com/problems/complement-of-base-10-integer/</a></p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/number-complement/number-complement.java b/leetcode/leetcode/number-complement/number-complement.java
new file mode 100644
index 0000000..5e2a13f
--- /dev/null
+++ b/leetcode/leetcode/number-complement/number-complement.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int findComplement(int n) {
+        if(n==0) return 1;
+        int res = 0;
+        int c = 0;
+        while(n!=0){
+            if(n%2==0) res += (int)Math.pow(2,c);
+            c++;
+            n = n/2;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/number-of-laser-beams-in-a-bank/README.md b/leetcode/leetcode/number-of-laser-beams-in-a-bank/README.md
new file mode 100644
index 0000000..68aae67
--- /dev/null
+++ b/leetcode/leetcode/number-of-laser-beams-in-a-bank/README.md
@@ -0,0 +1,48 @@
+<h2>2125. Number of Laser Beams in a Bank</h2><h3>Medium</h3><hr><div><p>Anti-theft security devices are activated inside a bank. You are given a <strong>0-indexed</strong> binary string array <code>bank</code> representing the floor plan of the bank, which is an <code>m x n</code> 2D matrix. <code>bank[i]</code> represents the <code>i<sup>th</sup></code> row, consisting of <code>'0'</code>s and <code>'1'</code>s. <code>'0'</code> means the cell is empty, while<code>'1'</code> means the cell has a security device.</p>
+
+<p>There is <strong>one</strong> laser beam between any <strong>two</strong> security devices <strong>if both</strong> conditions are met:</p>
+
+<ul>
+	<li>The two devices are located on two <strong>different rows</strong>: <code>r<sub>1</sub></code> and <code>r<sub>2</sub></code>, where <code>r<sub>1</sub> &lt; r<sub>2</sub></code>.</li>
+	<li>For <strong>each</strong> row <code>i</code> where <code>r<sub>1</sub> &lt; i &lt; r<sub>2</sub></code>, there are <strong>no security devices</strong> in the <code>i<sup>th</sup></code> row.</li>
+</ul>
+
+<p>Laser beams are independent, i.e., one beam does not interfere nor join with another.</p>
+
+<p>Return <em>the total number of laser beams in the bank</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/24/laser1.jpg" style="width: 400px; height: 368px;">
+<pre><strong>Input:</strong> bank = ["011001","000000","010100","001000"]
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> Between each of the following device pairs, there is one beam. In total, there are 8 beams:
+ * bank[0][1] -- bank[2][1]
+ * bank[0][1] -- bank[2][3]
+ * bank[0][2] -- bank[2][1]
+ * bank[0][2] -- bank[2][3]
+ * bank[0][5] -- bank[2][1]
+ * bank[0][5] -- bank[2][3]
+ * bank[2][1] -- bank[3][2]
+ * bank[2][3] -- bank[3][2]
+Note that there is no beam between any device on the 0<sup>th</sup> row with any on the 3<sup>rd</sup> row.
+This is because the 2<sup>nd</sup> row contains security devices, which breaks the second condition.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/24/laser2.jpg" style="width: 244px; height: 325px;">
+<pre><strong>Input:</strong> bank = ["000","111","000"]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There does not exist two devices located on two different rows.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == bank.length</code></li>
+	<li><code>n == bank[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 500</code></li>
+	<li><code>bank[i][j]</code> is either <code>'0'</code> or <code>'1'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/number-of-laser-beams-in-a-bank/number-of-laser-beams-in-a-bank.java b/leetcode/leetcode/number-of-laser-beams-in-a-bank/number-of-laser-beams-in-a-bank.java
new file mode 100644
index 0000000..c27df62
--- /dev/null
+++ b/leetcode/leetcode/number-of-laser-beams-in-a-bank/number-of-laser-beams-in-a-bank.java
@@ -0,0 +1,20 @@
+class Solution {
+    int count(String s){
+        int counter = 0;
+        for(int i = 0;i<s.length();i++){
+            if(s.charAt(i)=='1') counter++;
+        }
+        return counter;
+    }
+    public int numberOfBeams(String[] bank) {
+        int res = 0;
+        int prev = 0;
+        for(int i = 0;i<bank.length;i++){
+            int current = count(bank[i]);
+            if(current == 0) continue;
+            res+=(prev*current);
+            prev = current;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/number-of-segments-in-a-string/README.md b/leetcode/leetcode/number-of-segments-in-a-string/README.md
new file mode 100644
index 0000000..86291b5
--- /dev/null
+++ b/leetcode/leetcode/number-of-segments-in-a-string/README.md
@@ -0,0 +1,39 @@
+<h2>434. Number of Segments in a String</h2><h3>Easy</h3><hr><div><p>You are given a string <code>s</code>, return <em>the number of segments in the string</em>.&nbsp;</p>
+
+<p>A <strong>segment</strong> is defined to be a contiguous sequence of <strong>non-space characters</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "Hello, my name is John"
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The five segments are ["Hello,", "my", "name", "is", "John"]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "Hello"
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "love live! mu'sic forever"
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> s = ""
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length &lt;= 300</code></li>
+	<li><code>s</code> consists of lower-case and upper-case English letters, digits or one of the following characters <code>"!@#$%^&amp;*()_+-=',.:"</code>.</li>
+	<li>The only space character in <code>s</code> is <code>' '</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/number-of-segments-in-a-string/number-of-segments-in-a-string.java b/leetcode/leetcode/number-of-segments-in-a-string/number-of-segments-in-a-string.java
new file mode 100644
index 0000000..efa8aaf
--- /dev/null
+++ b/leetcode/leetcode/number-of-segments-in-a-string/number-of-segments-in-a-string.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int countSegments(String s) {
+        String[] result = s.split(" ");
+        int counter = 0;
+        int res=0;
+        while(counter<result.length){
+            if(!(result[counter].equals(""))){
+                res++;
+            }
+            counter++;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/number-of-steps-to-reduce-a-number-to-zero/README.md b/leetcode/leetcode/number-of-steps-to-reduce-a-number-to-zero/README.md
new file mode 100644
index 0000000..f95cc0c
--- /dev/null
+++ b/leetcode/leetcode/number-of-steps-to-reduce-a-number-to-zero/README.md
@@ -0,0 +1,42 @@
+<h2>1342. Number of Steps to Reduce a Number to Zero</h2><h3>Easy</h3><hr><div><p>Given an integer <code>num</code>, return <em>the number of steps to reduce it to zero</em>.</p>
+
+<p>In one step, if the current number is even, you have to divide it by <code>2</code>, otherwise, you have to subtract <code>1</code> from it.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 14
+<strong>Output:</strong> 6
+<strong>Explanation:</strong>&nbsp;
+Step 1) 14 is even; divide by 2 and obtain 7.&nbsp;
+Step 2) 7 is odd; subtract 1 and obtain 6.
+Step 3) 6 is even; divide by 2 and obtain 3.&nbsp;
+Step 4) 3 is odd; subtract 1 and obtain 2.&nbsp;
+Step 5) 2 is even; divide by 2 and obtain 1.&nbsp;
+Step 6) 1 is odd; subtract 1 and obtain 0.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = 8
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>&nbsp;
+Step 1) 8 is even; divide by 2 and obtain 4.&nbsp;
+Step 2) 4 is even; divide by 2 and obtain 2.&nbsp;
+Step 3) 2 is even; divide by 2 and obtain 1.&nbsp;
+Step 4) 1 is odd; subtract 1 and obtain 0.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> num = 123
+<strong>Output:</strong> 12
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= num &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/number-of-steps-to-reduce-a-number-to-zero/number-of-steps-to-reduce-a-number-to-zero.java b/leetcode/leetcode/number-of-steps-to-reduce-a-number-to-zero/number-of-steps-to-reduce-a-number-to-zero.java
new file mode 100644
index 0000000..e3994d1
--- /dev/null
+++ b/leetcode/leetcode/number-of-steps-to-reduce-a-number-to-zero/number-of-steps-to-reduce-a-number-to-zero.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int numberOfSteps(int num) {
+        int step = 0;
+        while(num!=0){
+            if(num%2==0){
+                num = num>>1;
+            }else{
+                num--;
+            }
+            step++;
+        }
+        return step;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/odd-even-linked-list/README.md b/leetcode/leetcode/odd-even-linked-list/README.md
new file mode 100644
index 0000000..734ab69
--- /dev/null
+++ b/leetcode/leetcode/odd-even-linked-list/README.md
@@ -0,0 +1,30 @@
+<h2>328. Odd Even Linked List</h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a singly linked list, group all the nodes with odd indices together followed by the nodes with even indices, and return <em>the reordered list</em>.</p>
+
+<p>The <strong>first</strong> node is considered <strong>odd</strong>, and the <strong>second</strong> node is <strong>even</strong>, and so on.</p>
+
+<p>Note that the relative order inside both the even and odd groups should remain as it was in the input.</p>
+
+<p>You must solve the problem&nbsp;in <code>O(1)</code>&nbsp;extra space complexity and <code>O(n)</code> time complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/10/oddeven-linked-list.jpg" style="width: 300px; height: 123px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5]
+<strong>Output:</strong> [1,3,5,2,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/10/oddeven2-linked-list.jpg" style="width: 500px; height: 142px;">
+<pre><strong>Input:</strong> head = [2,1,3,5,6,4,7]
+<strong>Output:</strong> [2,3,6,7,1,5,4]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n ==&nbsp;</code>number of nodes in the linked list</li>
+	<li><code>0 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>6</sup> &lt;= Node.val &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/odd-even-linked-list/odd-even-linked-list.java b/leetcode/leetcode/odd-even-linked-list/odd-even-linked-list.java
new file mode 100644
index 0000000..315ec05
--- /dev/null
+++ b/leetcode/leetcode/odd-even-linked-list/odd-even-linked-list.java
@@ -0,0 +1,35 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode oddEvenList(ListNode head) {
+        if(head == null || head.next==null) return head;
+        ListNode oddH = head;
+        ListNode evenH = head.next;
+        ListNode oddT = head;
+        ListNode evenT = head.next;
+        head = head.next.next;
+        while( head!=null){
+            oddT.next = head;
+            evenT.next = head.next;
+            if(head.next !=null) head = head.next.next;
+            else break;
+            oddT = oddT.next;
+            evenT = evenT.next;
+        }
+        if(head!=null) {
+            oddT.next = head;
+            oddT = oddT.next;
+        }
+        oddT.next = evenH;
+        evenT.next = null;
+        return oddH;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/palindrome-linked-list/README.md b/leetcode/leetcode/palindrome-linked-list/README.md
new file mode 100644
index 0000000..c5558e6
--- /dev/null
+++ b/leetcode/leetcode/palindrome-linked-list/README.md
@@ -0,0 +1,25 @@
+<h2>234. Palindrome Linked List</h2><h3>Easy</h3><hr><div><p>Given the <code>head</code> of a singly linked list, return <code>true</code> if it is a palindrome.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal1linked-list.jpg" style="width: 422px; height: 62px;">
+<pre><strong>Input:</strong> head = [1,2,2,1]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/03/pal2linked-list.jpg" style="width: 182px; height: 62px;">
+<pre><strong>Input:</strong> head = [1,2]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 10<sup>5</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 9</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you do it in <code>O(n)</code> time and <code>O(1)</code> space?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/palindrome-linked-list/palindrome-linked-list.java b/leetcode/leetcode/palindrome-linked-list/palindrome-linked-list.java
new file mode 100644
index 0000000..1d25a47
--- /dev/null
+++ b/leetcode/leetcode/palindrome-linked-list/palindrome-linked-list.java
@@ -0,0 +1,47 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ 
+
+   1 <- 2    3
+         p    h  n          
+ */
+class Solution {
+    public boolean isPalindrome(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast != null && fast.next != null){
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        fast = head;
+        slow = reverse(slow);
+        while(slow!=null){
+            if(slow.val != fast.val){
+                return false;
+            } 
+            slow = slow.next;
+            fast = fast.next;
+        }
+        return true;
+    }
+    
+    public ListNode reverse(ListNode head){
+        ListNode prev = null;
+        ListNode next = head.next;
+        while(next!=null){
+            head.next = prev;
+            prev = head;
+            head = next;
+            next = next.next;
+        }
+        head.next = prev;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/palindrome-number/README.md b/leetcode/leetcode/palindrome-number/README.md
new file mode 100644
index 0000000..4bc94ca
--- /dev/null
+++ b/leetcode/leetcode/palindrome-number/README.md
@@ -0,0 +1,40 @@
+<h2>9. Palindrome Number</h2><h3>Easy</h3><hr><div><p>Given an integer <code>x</code>, return <code>true</code> if <code>x</code> is palindrome integer.</p>
+
+<p>An integer is a <strong>palindrome</strong> when it reads the same backward as forward. For example, <code>121</code> is palindrome while <code>123</code> is not.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> x = 121
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> x = -121
+<strong>Output:</strong> false
+<strong>Explanation:</strong> From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> x = 10
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Reads 01 from right to left. Therefore it is not a palindrome.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> x = -101
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup>&nbsp;&lt;= x &lt;= 2<sup>31</sup>&nbsp;- 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you solve it without converting the integer to a string?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/palindrome-number/palindrome-number.java b/leetcode/leetcode/palindrome-number/palindrome-number.java
new file mode 100644
index 0000000..0ab255c
--- /dev/null
+++ b/leetcode/leetcode/palindrome-number/palindrome-number.java
@@ -0,0 +1,14 @@
+class Solution {
+    public boolean isPalindrome(int x) {
+        if(x<0){
+            return false;
+        }
+        int result = 0;
+        int temp  = x;
+        while(x!=0){
+            result = result*10 + x%10;
+            x/=10;
+        }
+        return result==temp;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/partition-list/README.md b/leetcode/leetcode/partition-list/README.md
new file mode 100644
index 0000000..8d223d1
--- /dev/null
+++ b/leetcode/leetcode/partition-list/README.md
@@ -0,0 +1,26 @@
+<h2>86. Partition List</h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a linked list and a value <code>x</code>, partition it such that all nodes <strong>less than</strong> <code>x</code> come before nodes <strong>greater than or equal</strong> to <code>x</code>.</p>
+
+<p>You should <strong>preserve</strong> the original relative order of the nodes in each of the two partitions.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/partition.jpg" style="width: 662px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,4,3,2,5,2], x = 3
+<strong>Output:</strong> [1,2,2,4,3,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [2,1], x = 2
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 200]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li><code>-200 &lt;= x &lt;= 200</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/partition-list/partition-list.java b/leetcode/leetcode/partition-list/partition-list.java
new file mode 100644
index 0000000..ce4498d
--- /dev/null
+++ b/leetcode/leetcode/partition-list/partition-list.java
@@ -0,0 +1,33 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode partition(ListNode head, int x) {
+        ListNode temp = head;
+        ListNode before = new ListNode();
+        ListNode after = new ListNode();
+        ListNode beforetemp = before;
+        ListNode aftertemp = after;
+        
+        while(temp!=null){
+            if(temp.val<x){
+                beforetemp.next = temp;
+                beforetemp = beforetemp.next;
+            }else{
+                aftertemp.next = temp;
+                aftertemp = aftertemp.next;
+            }
+            temp = temp.next;
+        }
+        aftertemp.next = null;
+        beforetemp.next = after.next;
+        return before.next;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/partitioning-into-minimum-number-of-deci-binary-numbers/README.md b/leetcode/leetcode/partitioning-into-minimum-number-of-deci-binary-numbers/README.md
new file mode 100644
index 0000000..7e1b842
--- /dev/null
+++ b/leetcode/leetcode/partitioning-into-minimum-number-of-deci-binary-numbers/README.md
@@ -0,0 +1,33 @@
+<h2>1689. Partitioning Into Minimum Number Of Deci-Binary Numbers</h2><h3>Medium</h3><hr><div><p>A decimal number is called <strong>deci-binary</strong> if each of its digits is either <code>0</code> or <code>1</code> without any leading zeros. For example, <code>101</code> and <code>1100</code> are <strong>deci-binary</strong>, while <code>112</code> and <code>3001</code> are not.</p>
+
+<p>Given a string <code>n</code> that represents a positive decimal integer, return <em>the <strong>minimum</strong> number of positive <strong>deci-binary</strong> numbers needed so that they sum up to </em><code>n</code><em>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = "32"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 10 + 11 + 11 = 32
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = "82734"
+<strong>Output:</strong> 8
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = "27346209830709182346"
+<strong>Output:</strong> 9
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>n</code> consists of only digits.</li>
+	<li><code>n</code> does not contain any leading zeros and represents a positive integer.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/partitioning-into-minimum-number-of-deci-binary-numbers/partitioning-into-minimum-number-of-deci-binary-numbers.java b/leetcode/leetcode/partitioning-into-minimum-number-of-deci-binary-numbers/partitioning-into-minimum-number-of-deci-binary-numbers.java
new file mode 100644
index 0000000..001c05a
--- /dev/null
+++ b/leetcode/leetcode/partitioning-into-minimum-number-of-deci-binary-numbers/partitioning-into-minimum-number-of-deci-binary-numbers.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int minPartitions(String n) {
+        int max = 0;
+        for(int i = 0;i<n.length();i++){
+            if(  (int) n.charAt(i) - 48   > max){
+                max =  (int) n.charAt(i) - 48;
+            }
+            if(max == 9){
+                return max;
+            }
+        }
+        return max;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/pascals-triangle-ii/README.md b/leetcode/leetcode/pascals-triangle-ii/README.md
new file mode 100644
index 0000000..3b2fb2d
--- /dev/null
+++ b/leetcode/leetcode/pascals-triangle-ii/README.md
@@ -0,0 +1,25 @@
+<h2>119. Pascal's Triangle II</h2><h3>Easy</h3><hr><div><p>Given an integer <code>rowIndex</code>, return the <code>rowIndex<sup>th</sup></code> (<strong>0-indexed</strong>) row of the <strong>Pascal's triangle</strong>.</p>
+
+<p>In <strong>Pascal's triangle</strong>, each number is the sum of the two numbers directly above it as shown:</p>
+<img alt="" src="https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif" style="height:240px; width:260px">
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> rowIndex = 3
+<strong>Output:</strong> [1,3,3,1]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> rowIndex = 0
+<strong>Output:</strong> [1]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> rowIndex = 1
+<strong>Output:</strong> [1,1]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= rowIndex &lt;= 33</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you optimize your algorithm to use only <code>O(rowIndex)</code> extra space?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/pascals-triangle-ii/pascals-triangle-ii.java b/leetcode/leetcode/pascals-triangle-ii/pascals-triangle-ii.java
new file mode 100644
index 0000000..e394ed8
--- /dev/null
+++ b/leetcode/leetcode/pascals-triangle-ii/pascals-triangle-ii.java
@@ -0,0 +1,22 @@
+class Solution {
+    public List<Integer> getRow(int rowIndex) {
+        List<Integer> prev = new ArrayList<>();
+        prev.add(1);
+        if(rowIndex == 0) return prev;
+        prev.add(1);
+        if(rowIndex == 1) return prev;
+        List<Integer> res = new ArrayList<>();
+        while(rowIndex!=1){
+            res.clear();
+            res.add(1);
+            for(int i = 1;i<prev.size();i++){
+                res.add(prev.get(i-1)+prev.get(i));
+            }
+            res.add(1);
+            prev.clear();
+            prev.addAll(res);
+            rowIndex--;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/pascals-triangle/README.md b/leetcode/leetcode/pascals-triangle/README.md
new file mode 100644
index 0000000..a1948e8
--- /dev/null
+++ b/leetcode/leetcode/pascals-triangle/README.md
@@ -0,0 +1,19 @@
+<h2>118. Pascal's Triangle</h2><h3>Easy</h3><hr><div><p>Given an integer <code>numRows</code>, return the first numRows of <strong>Pascal's triangle</strong>.</p>
+
+<p>In <strong>Pascal's triangle</strong>, each number is the sum of the two numbers directly above it as shown:</p>
+<img alt="" src="https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif" style="height:240px; width:260px">
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> numRows = 5
+<strong>Output:</strong> [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> numRows = 1
+<strong>Output:</strong> [[1]]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= numRows &lt;= 30</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/pascals-triangle/pascals-triangle.java b/leetcode/leetcode/pascals-triangle/pascals-triangle.java
new file mode 100644
index 0000000..3abb1cd
--- /dev/null
+++ b/leetcode/leetcode/pascals-triangle/pascals-triangle.java
@@ -0,0 +1,23 @@
+class Solution {
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> list = new ArrayList<>();
+        int start = 1;
+        List<Integer> first = new ArrayList(start);
+        first.add(1);
+        list.add(first);
+        if(numRows==start) return list;
+        while(numRows!=1){
+            start = start+1;
+            List<Integer> newList = new ArrayList<Integer>(start);
+            newList.add(1);
+            for(int i=1;i<start - 1;i++){
+                newList.add(list.get(start-2).get(i-1)+list.get(start-2).get(i));
+            }
+            newList.add(1);
+            list.add(newList);
+            numRows--;
+        }
+        return list;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/path-sum/README.md b/leetcode/leetcode/path-sum/README.md
new file mode 100644
index 0000000..f367325
--- /dev/null
+++ b/leetcode/leetcode/path-sum/README.md
@@ -0,0 +1,38 @@
+<h2>112. Path Sum</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree and an integer <code>targetSum</code>, return <code>true</code> if the tree has a <strong>root-to-leaf</strong> path such that adding up all the values along the path equals <code>targetSum</code>.</p>
+
+<p>A <strong>leaf</strong> is a node with no children.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum1.jpg" style="width: 500px; height: 356px;">
+<pre><strong>Input:</strong> root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The root-to-leaf path with the target sum is shown.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg">
+<pre><strong>Input:</strong> root = [1,2,3], targetSum = 5
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There two root-to-leaf paths in the tree:
+(1 --&gt; 2): The sum is 3.
+(1 --&gt; 3): The sum is 4.
+There is no root-to-leaf path with sum = 5.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [], targetSum = 0
+<strong>Output:</strong> false
+<strong>Explanation:</strong> Since the tree is empty, there are no root-to-leaf paths.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[0, 5000]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+	<li><code>-1000 &lt;= targetSum &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/plus-one/README.md b/leetcode/leetcode/plus-one/README.md
new file mode 100644
index 0000000..6fd0b5a
--- /dev/null
+++ b/leetcode/leetcode/plus-one/README.md
@@ -0,0 +1,50 @@
+<h2>66. Plus One</h2><h3>Easy</h3><hr><div><p>You are given a <strong>large integer</strong> represented as an integer array <code>digits</code>, where each <code>digits[i]</code> is the <code>i<sup>th</sup></code> digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading <code>0</code>'s.</p>
+
+<p>Increment the large integer by one and return <em>the resulting array of digits</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> digits = [1,2,3]
+<strong>Output:</strong> [1,2,4]
+<strong>Explanation:</strong> The array represents the integer 123.
+Incrementing by one gives 123 + 1 = 124.
+Thus, the result should be [1,2,4].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> digits = [4,3,2,1]
+<strong>Output:</strong> [4,3,2,2]
+<strong>Explanation:</strong> The array represents the integer 4321.
+Incrementing by one gives 4321 + 1 = 4322.
+Thus, the result should be [4,3,2,2].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> digits = [0]
+<strong>Output:</strong> [1]
+<strong>Explanation:</strong> The array represents the integer 0.
+Incrementing by one gives 0 + 1 = 1.
+Thus, the result should be [1].
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> digits = [9]
+<strong>Output:</strong> [1,0]
+<strong>Explanation:</strong> The array represents the integer 9.
+Incrementing by one gives 9 + 1 = 10.
+Thus, the result should be [1,0].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= digits.length &lt;= 100</code></li>
+	<li><code>0 &lt;= digits[i] &lt;= 9</code></li>
+	<li><code>digits</code> does not contain any leading <code>0</code>'s.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/plus-one/plus-one.java b/leetcode/leetcode/plus-one/plus-one.java
new file mode 100644
index 0000000..4ecde16
--- /dev/null
+++ b/leetcode/leetcode/plus-one/plus-one.java
@@ -0,0 +1,26 @@
+class Solution {
+    public int[] plusOne(int[] digits) {
+        int carry = 1;
+        for(int i = digits.length-1;i!=-1;i--){
+            if(digits[i]==9) {
+                digits[i]=0;
+                carry = 1;
+            }
+            else {
+                digits[i]+=carry;
+                carry = 0;
+            }
+            if(carry==0) break;
+        }
+        if(carry==1){
+            int[] newArr = new int[digits.length+1];
+            int counter = 0;
+            newArr[counter++] = 1;
+            for(int num: digits){
+                newArr[counter++] = num;
+            }
+            return newArr;
+        }
+        return digits;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/power-of-two/README.md b/leetcode/leetcode/power-of-two/README.md
new file mode 100644
index 0000000..58d82a9
--- /dev/null
+++ b/leetcode/leetcode/power-of-two/README.md
@@ -0,0 +1,46 @@
+<h2>231. Power of Two</h2><h3>Easy</h3><hr><div><p>Given an integer <code>n</code>, return <em><code>true</code> if it is a power of two. Otherwise, return <code>false</code></em>.</p>
+
+<p>An integer <code>n</code> is a power of two, if there exists an integer <code>x</code> such that <code>n == 2<sup>x</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> true
+<strong>Explanation: </strong>2<sup>0</sup> = 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 16
+<strong>Output:</strong> true
+<strong>Explanation: </strong>2<sup>4</sup> = 16
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you solve it without loops/recursion?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/power-of-two/power-of-two.java b/leetcode/leetcode/power-of-two/power-of-two.java
new file mode 100644
index 0000000..87fee4b
--- /dev/null
+++ b/leetcode/leetcode/power-of-two/power-of-two.java
@@ -0,0 +1,12 @@
+class Solution {
+    public boolean isPowerOfTwo(int n) {
+        if(n==1){
+            return true;
+        }
+        
+        if(n%2!=0 || n==0){
+            return false;
+        }
+        return isPowerOfTwo(n/2);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/power-of-two/power-of-two.py b/leetcode/leetcode/power-of-two/power-of-two.py
new file mode 100644
index 0000000..52909fb
--- /dev/null
+++ b/leetcode/leetcode/power-of-two/power-of-two.py
@@ -0,0 +1,7 @@
+class Solution:
+    def isPowerOfTwo(self, n: int) -> bool:
+        if n==0: return False
+        while(n!=1):
+            if n%2==1: return False
+            n = n/2
+        return True
\ No newline at end of file
diff --git a/leetcode/leetcode/range-sum-of-bst/README.md b/leetcode/leetcode/range-sum-of-bst/README.md
new file mode 100644
index 0000000..2436e88
--- /dev/null
+++ b/leetcode/leetcode/range-sum-of-bst/README.md
@@ -0,0 +1,27 @@
+<h2>938. Range Sum of BST</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> node of a binary search tree and two integers <code>low</code> and <code>high</code>, return <em>the sum of values of all nodes with a value in the <strong>inclusive</strong> range </em><code>[low, high]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/05/bst1.jpg" style="width: 400px; height: 222px;">
+<pre><strong>Input:</strong> root = [10,5,15,3,7,null,18], low = 7, high = 15
+<strong>Output:</strong> 32
+<strong>Explanation:</strong> Nodes 7, 10, and 15 are in the range [7, 15]. 7 + 10 + 15 = 32.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/05/bst2.jpg" style="width: 400px; height: 335px;">
+<pre><strong>Input:</strong> root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
+<strong>Output:</strong> 23
+<strong>Explanation:</strong> Nodes 6, 7, and 10 are in the range [6, 10]. 6 + 7 + 10 = 23.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 2 * 10<sup>4</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= low &lt;= high &lt;= 10<sup>5</sup></code></li>
+	<li>All <code>Node.val</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/range-sum-of-bst/range-sum-of-bst.java b/leetcode/leetcode/range-sum-of-bst/range-sum-of-bst.java
new file mode 100644
index 0000000..580a801
--- /dev/null
+++ b/leetcode/leetcode/range-sum-of-bst/range-sum-of-bst.java
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int rangeSumBST(TreeNode root, int low, int high) {
+        if(root==null) return 0;
+        int sum = 0;
+        if(root.val>high) sum += rangeSumBST(root.left,low,high);
+        if(root.val<low) sum += rangeSumBST(root.right,low,high);
+        if(root.val<=high && root.val>=low) {
+            sum+=root.val;
+            sum+=rangeSumBST(root.left,low,high);
+            sum+=rangeSumBST(root.right,low,high);
+        }
+        return sum;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/reduce-array-size-to-the-half/README.md b/leetcode/leetcode/reduce-array-size-to-the-half/README.md
new file mode 100644
index 0000000..f00283a
--- /dev/null
+++ b/leetcode/leetcode/reduce-array-size-to-the-half/README.md
@@ -0,0 +1,30 @@
+<h2>1338. Reduce Array Size to The Half</h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>arr</code>. You can choose a set of integers and remove all the occurrences of these integers in the array.</p>
+
+<p>Return <em>the minimum size of the set so that <strong>at least</strong> half of the integers of the array are removed</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [3,3,3,3,5,5,5,2,2,7]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Choosing {3,7} will make the new array [5,5,5,2,2] which has size 5 (i.e equal to half of the size of the old array).
+Possible sets of size 2 are {3,5},{3,2},{5,2}.
+Choosing set {2,7} is not possible as it will make the new array [3,3,3,3,5,5,5] which has a size greater than half of the size of the old array.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [7,7,7,7,7,7]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The only possible set you can choose is {7}. This will make the new array empty.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>arr.length</code> is even.</li>
+	<li><code>1 &lt;= arr[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/reduce-array-size-to-the-half/reduce-array-size-to-the-half.java b/leetcode/leetcode/reduce-array-size-to-the-half/reduce-array-size-to-the-half.java
new file mode 100644
index 0000000..ee3291c
--- /dev/null
+++ b/leetcode/leetcode/reduce-array-size-to-the-half/reduce-array-size-to-the-half.java
@@ -0,0 +1,20 @@
+class Solution {
+    public int minSetSize(int[] arr) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: arr){
+            map.put(num, map.getOrDefault(num,0)+1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>(map.size(), Collections.reverseOrder());
+        for (Map.Entry mapElement : map.entrySet()){
+            pq.add((int)mapElement.getValue());
+        }
+        int ans = 0;
+        int counter = 0;
+        while(counter<arr.length/2){
+            counter+=pq.peek();
+            pq.remove();
+            ans++;
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-all-adjacent-duplicates-in-string/README.md b/leetcode/leetcode/remove-all-adjacent-duplicates-in-string/README.md
new file mode 100644
index 0000000..d155076
--- /dev/null
+++ b/leetcode/leetcode/remove-all-adjacent-duplicates-in-string/README.md
@@ -0,0 +1,30 @@
+[Discussion Post (created on 23/9/2021 at 20:49)](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/discuss/1536585/JAVA-StringBuilder-Time%3A-O(N)-Space-O(1))  
+<h2>1047. Remove All Adjacent Duplicates In String</h2><h3>Easy</h3><hr><div><p>You are given a string <code>s</code> consisting of lowercase English letters. A <strong>duplicate removal</strong> consists of choosing two <strong>adjacent</strong> and <strong>equal</strong> letters and removing them.</p>
+
+<p>We repeatedly make <strong>duplicate removals</strong> on <code>s</code> until we no longer can.</p>
+
+<p>Return <em>the final string after all such duplicate removals have been made</em>. It can be proven that the answer is <strong>unique</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "abbaca"
+<strong>Output:</strong> "ca"
+<strong>Explanation:</strong> 
+For example, in "abbaca" we could remove "bb" since the letters are adjacent and equal, and this is the only possible move.  The result of this move is that the string is "aaca", of which only "aa" is possible, so the final string is "ca".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "azxxzy"
+<strong>Output:</strong> "ay"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-all-adjacent-duplicates-in-string/remove-all-adjacent-duplicates-in-string.java b/leetcode/leetcode/remove-all-adjacent-duplicates-in-string/remove-all-adjacent-duplicates-in-string.java
new file mode 100644
index 0000000..81fa2a7
--- /dev/null
+++ b/leetcode/leetcode/remove-all-adjacent-duplicates-in-string/remove-all-adjacent-duplicates-in-string.java
@@ -0,0 +1,17 @@
+class Solution {
+    public String removeDuplicates(String s) {
+        StringBuilder res = new StringBuilder();
+        int counter = -1;
+        for(int i =0; i<s.length();i++){
+            if(counter!=-1 && res.charAt(counter) == s.charAt(i)){
+                res.deleteCharAt(counter);
+                 counter--;
+            }else{
+                res.append(s.charAt(i));
+                counter++;
+            }
+        }
+        return res.toString();
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-all-occurrences-of-a-substring/README.md b/leetcode/leetcode/remove-all-occurrences-of-a-substring/README.md
new file mode 100644
index 0000000..8f8e2b0
--- /dev/null
+++ b/leetcode/leetcode/remove-all-occurrences-of-a-substring/README.md
@@ -0,0 +1,43 @@
+<h2>1910. Remove All Occurrences of a Substring</h2><h3>Medium</h3><hr><div><p>Given two strings <code>s</code> and <code>part</code>, perform the following operation on <code>s</code> until <strong>all</strong> occurrences of the substring <code>part</code> are removed:</p>
+
+<ul>
+	<li>Find the <strong>leftmost</strong> occurrence of the substring <code>part</code> and <strong>remove</strong> it from <code>s</code>.</li>
+</ul>
+
+<p>Return <code>s</code><em> after removing all occurrences of </em><code>part</code>.</p>
+
+<p>A <strong>substring</strong> is a contiguous sequence of characters in a string.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "daabcbaabcbc", part = "abc"
+<strong>Output:</strong> "dab"
+<strong>Explanation</strong>: The following operations are done:
+- s = "da<strong><u>abc</u></strong>baabcbc", remove "abc" starting at index 2, so s = "dabaabcbc".
+- s = "daba<strong><u>abc</u></strong>bc", remove "abc" starting at index 4, so s = "dababc".
+- s = "dab<strong><u>abc</u></strong>", remove "abc" starting at index 3, so s = "dab".
+Now s has no occurrences of "abc".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "axxxxyyyyb", part = "xy"
+<strong>Output:</strong> "ab"
+<strong>Explanation</strong>: The following operations are done:
+- s = "axxx<strong><u>xy</u></strong>yyyb", remove "xy" starting at index 4 so s = "axxxyyyb".
+- s = "axx<strong><u>xy</u></strong>yyb", remove "xy" starting at index 3 so s = "axxyyb".
+- s = "ax<strong><u>xy</u></strong>yb", remove "xy" starting at index 2 so s = "axyb".
+- s = "a<strong><u>xy</u></strong>b", remove "xy" starting at index 1 so s = "ab".
+Now s has no occurrences of "xy".
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= part.length &lt;= 1000</code></li>
+	<li><code>s</code>​​​​​​ and <code>part</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-all-occurrences-of-a-substring/remove-all-occurrences-of-a-substring.java b/leetcode/leetcode/remove-all-occurrences-of-a-substring/remove-all-occurrences-of-a-substring.java
new file mode 100644
index 0000000..1e831a1
--- /dev/null
+++ b/leetcode/leetcode/remove-all-occurrences-of-a-substring/remove-all-occurrences-of-a-substring.java
@@ -0,0 +1,9 @@
+
+class Solution {
+    public String removeOccurrences(String s, String part) {
+        if(!(s.contains(part))){
+           return s;
+        }
+           return removeOccurrences(s.substring(0, s.indexOf(part)) + s.substring(s.indexOf(part)+part.length(),s.length()),part);
+    }
+}
diff --git a/leetcode/leetcode/remove-duplicates-from-sorted-array/README.md b/leetcode/leetcode/remove-duplicates-from-sorted-array/README.md
new file mode 100644
index 0000000..d170b12
--- /dev/null
+++ b/leetcode/leetcode/remove-duplicates-from-sorted-array/README.md
@@ -0,0 +1,51 @@
+<h2>26. Remove Duplicates from Sorted Array</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> sorted in <strong>non-decreasing order</strong>, remove the duplicates <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank"><strong>in-place</strong></a> such that each unique element appears only <strong>once</strong>. The <strong>relative order</strong> of the elements should be kept the <strong>same</strong>.</p>
+
+<p>Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the <strong>first part</strong> of the array <code>nums</code>. More formally, if there are <code>k</code> elements after removing the duplicates, then the first <code>k</code> elements of <code>nums</code>&nbsp;should hold the final result. It does not matter what you leave beyond the first&nbsp;<code>k</code>&nbsp;elements.</p>
+
+<p>Return <code>k</code><em> after placing the final result in the first </em><code>k</code><em> slots of </em><code>nums</code>.</p>
+
+<p>Do <strong>not</strong> allocate extra space for another array. You must do this by <strong>modifying the input array <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a></strong> with O(1) extra memory.</p>
+
+<p><strong>Custom Judge:</strong></p>
+
+<p>The judge will test your solution with the following code:</p>
+
+<pre>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 &lt; k; i++) {
+    assert nums[i] == expectedNums[i];
+}
+</pre>
+
+<p>If all assertions pass, then your solution will be <strong>accepted</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,2]
+<strong>Output:</strong> 2, nums = [1,2,_]
+<strong>Explanation:</strong> 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).
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,0,1,1,1,2,2,3,3,4]
+<strong>Output:</strong> 5, nums = [0,1,2,3,4,_,_,_,_,_]
+<strong>Explanation:</strong> 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).
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-100 &lt;= nums[i] &lt;= 100</code></li>
+	<li><code>nums</code> is sorted in <strong>non-decreasing</strong> order.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-duplicates-from-sorted-array/remove-duplicates-from-sorted-array.java b/leetcode/leetcode/remove-duplicates-from-sorted-array/remove-duplicates-from-sorted-array.java
new file mode 100644
index 0000000..cdc65b6
--- /dev/null
+++ b/leetcode/leetcode/remove-duplicates-from-sorted-array/remove-duplicates-from-sorted-array.java
@@ -0,0 +1,21 @@
+class Solution {
+    public void swap(int[] arr, int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    public int removeDuplicates(int[] arr) {
+        if(arr.length==0) return 0;
+        int counter = 0;
+        int i = 0;
+        for(i =0;i<arr.length-1;i++){
+            if(arr[i] == arr[i+1]){
+                counter++;
+            }else{
+                swap(arr,i,i-counter);
+            }
+        }
+        swap(arr,i,i-counter);
+        return arr.length - counter;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-duplicates-from-sorted-list-ii/README.md b/leetcode/leetcode/remove-duplicates-from-sorted-list-ii/README.md
new file mode 100644
index 0000000..028bfda
--- /dev/null
+++ b/leetcode/leetcode/remove-duplicates-from-sorted-list-ii/README.md
@@ -0,0 +1,24 @@
+<h2>82. Remove Duplicates from Sorted List II</h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a sorted linked list, <em>delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list</em>. Return <em>the linked list <strong>sorted</strong> as well</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist1.jpg" style="width: 500px; height: 142px;">
+<pre><strong>Input:</strong> head = [1,2,3,3,4,4,5]
+<strong>Output:</strong> [1,2,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/linkedlist2.jpg" style="width: 500px; height: 205px;">
+<pre><strong>Input:</strong> head = [1,1,1,2,3]
+<strong>Output:</strong> [2,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 300]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li>The list is guaranteed to be <strong>sorted</strong> in ascending order.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-duplicates-from-sorted-list-ii/remove-duplicates-from-sorted-list-ii.java b/leetcode/leetcode/remove-duplicates-from-sorted-list-ii/remove-duplicates-from-sorted-list-ii.java
new file mode 100644
index 0000000..2b71eb7
--- /dev/null
+++ b/leetcode/leetcode/remove-duplicates-from-sorted-list-ii/remove-duplicates-from-sorted-list-ii.java
@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        if(head==null || head.next == null) return head;
+        ListNode res = new ListNode();
+        ListNode prev = res;
+        res.next = head;
+        while(head!=null && head.next!=null){
+            if(head.val != head.next.val){
+                prev = prev.next;
+                head = head.next;
+            }else{
+                while(head.next!= null && head.val == head.next.val){
+                    head = head.next;
+                }
+                prev.next = head.next;
+                head = prev.next;
+            }
+        }
+        return res.next;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-element/README.md b/leetcode/leetcode/remove-element/README.md
new file mode 100644
index 0000000..7ff1687
--- /dev/null
+++ b/leetcode/leetcode/remove-element/README.md
@@ -0,0 +1,55 @@
+<h2>27. Remove Element</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> and an integer <code>val</code>, remove all occurrences of <code>val</code> in <code>nums</code> <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank"><strong>in-place</strong></a>. The relative order of the elements may be changed.</p>
+
+<p>Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the <strong>first part</strong> of the array <code>nums</code>. More formally, if there are <code>k</code> elements after removing the duplicates, then the first <code>k</code> elements of <code>nums</code> should hold the final result. It does not matter what you leave beyond the first <code>k</code> elements.</p>
+
+<p>Return <code>k</code><em> after placing the final result in the first </em><code>k</code><em> slots of </em><code>nums</code>.</p>
+
+<p>Do <strong>not</strong> allocate extra space for another array. You must do this by <strong>modifying the input array <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a></strong> with O(1) extra memory.</p>
+
+<p><strong>Custom Judge:</strong></p>
+
+<p>The judge will test your solution with the following code:</p>
+
+<pre>int[] nums = [...]; // Input array
+int val = ...; // Value to remove
+int[] expectedNums = [...]; // The expected answer with correct length.
+                            // It is sorted with no values equaling val.
+
+int k = removeElement(nums, val); // Calls your implementation
+
+assert k == expectedNums.length;
+sort(nums, 0, k); // Sort the first k elements of nums
+for (int i = 0; i &lt; actualLength; i++) {
+    assert nums[i] == expectedNums[i];
+}
+</pre>
+
+<p>If all assertions pass, then your solution will be <strong>accepted</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,2,2,3], val = 3
+<strong>Output:</strong> 2, nums = [2,2,_,_]
+<strong>Explanation:</strong> Your function should return k = 2, with the first two elements of nums being 2.
+It does not matter what you leave beyond the returned k (hence they are underscores).
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1,2,2,3,0,4,2], val = 2
+<strong>Output:</strong> 5, nums = [0,1,4,0,3,_,_,_]
+<strong>Explanation:</strong> Your function should return k = 5, with the first five elements of nums containing 0, 0, 1, 3, and 4.
+Note that the five elements can be returned in any order.
+It does not matter what you leave beyond the returned k (hence they are underscores).
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 50</code></li>
+	<li><code>0 &lt;= val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-element/remove-element.java b/leetcode/leetcode/remove-element/remove-element.java
new file mode 100644
index 0000000..2903c10
--- /dev/null
+++ b/leetcode/leetcode/remove-element/remove-element.java
@@ -0,0 +1,16 @@
+class Solution {
+    public void swap(int[] arr, int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    public int removeElement(int[] nums, int val) {
+        int number = 0;
+        int res = 0;
+        for(int i = 0;i<nums.length;i++){
+            if(nums[i]==val) number++;
+            else{ swap(nums,i,i-number);res++;}
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-linked-list-elements/README.md b/leetcode/leetcode/remove-linked-list-elements/README.md
new file mode 100644
index 0000000..3bfd36e
--- /dev/null
+++ b/leetcode/leetcode/remove-linked-list-elements/README.md
@@ -0,0 +1,30 @@
+<h2>203. Remove Linked List Elements</h2><h3>Easy</h3><hr><div><p>Given the <code>head</code> of a linked list and an integer <code>val</code>, remove all the nodes of the linked list that has <code>Node.val == val</code>, and return <em>the new head</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/06/removelinked-list.jpg" style="width: 500px; height: 142px;">
+<pre><strong>Input:</strong> head = [1,2,6,3,4,5,6], val = 6
+<strong>Output:</strong> [1,2,3,4,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [], val = 1
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [7,7,7,7], val = 7
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 50</code></li>
+	<li><code>0 &lt;= val &lt;= 50</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-linked-list-elements/remove-linked-list-elements.java b/leetcode/leetcode/remove-linked-list-elements/remove-linked-list-elements.java
new file mode 100644
index 0000000..3b7eac2
--- /dev/null
+++ b/leetcode/leetcode/remove-linked-list-elements/remove-linked-list-elements.java
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode removeElements(ListNode head, int val) {
+        if(head==null) return head;
+        ListNode temp =  head;
+        while(temp.next!=null){
+            if(temp.next.val==val){
+                temp.next = temp.next.next;
+            }else{
+                temp = temp.next;
+            }
+        }
+        if(head.val==val) return head.next;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-nth-node-from-end-of-list/README.md b/leetcode/leetcode/remove-nth-node-from-end-of-list/README.md
new file mode 100644
index 0000000..8f0abb0
--- /dev/null
+++ b/leetcode/leetcode/remove-nth-node-from-end-of-list/README.md
@@ -0,0 +1,34 @@
+<h2>19. Remove Nth Node From End of List</h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a linked list, remove the <code>n<sup>th</sup></code> node from the end of the list and return its head.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/remove_ex1.jpg" style="width: 542px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5], n = 2
+<strong>Output:</strong> [1,2,3,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [1], n = 1
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,2], n = 1
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is <code>sz</code>.</li>
+	<li><code>1 &lt;= sz &lt;= 30</code></li>
+	<li><code>0 &lt;= Node.val &lt;= 100</code></li>
+	<li><code>1 &lt;= n &lt;= sz</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you do this in one pass?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.java b/leetcode/leetcode/remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.java
new file mode 100644
index 0000000..3ce8018
--- /dev/null
+++ b/leetcode/leetcode/remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.java
@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        int size = 0;
+        ListNode temp = head;
+        while(temp!=null){
+            temp = temp.next;
+            size++;
+        }
+        if(size == 1 || size == n) return head.next;
+        int counter =0;
+        temp  = head;
+        while(counter<size-n-1){
+            counter++;
+            temp = temp.next;
+        }
+        temp.next = (temp.next).next;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/reorder-list/README.md b/leetcode/leetcode/reorder-list/README.md
new file mode 100644
index 0000000..3ee80eb
--- /dev/null
+++ b/leetcode/leetcode/reorder-list/README.md
@@ -0,0 +1,33 @@
+<h2>143. Reorder List</h2><h3>Medium</h3><hr><div><p>You are given the head of a singly linked-list. The list can be represented as:</p>
+
+<pre>L<sub>0</sub> → L<sub>1</sub> → … → L<sub>n - 1</sub> → L<sub>n</sub>
+</pre>
+
+<p><em>Reorder the list to be on the following form:</em></p>
+
+<pre>L<sub>0</sub> → L<sub>n</sub> → L<sub>1</sub> → L<sub>n - 1</sub> → L<sub>2</sub> → L<sub>n - 2</sub> → …
+</pre>
+
+<p>You may not modify the values in the list's nodes. Only nodes themselves may be changed.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/04/reorder1linked-list.jpg" style="width: 422px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4]
+<strong>Output:</strong> [1,4,2,3]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/09/reorder2-linked-list.jpg" style="width: 542px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5]
+<strong>Output:</strong> [1,5,2,4,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[1, 5 * 10<sup>4</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/reorder-list/reorder-list.java b/leetcode/leetcode/reorder-list/reorder-list.java
new file mode 100644
index 0000000..dbce7e6
--- /dev/null
+++ b/leetcode/leetcode/reorder-list/reorder-list.java
@@ -0,0 +1,51 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode reverse(ListNode head){
+        if(head == null || head.next == null) return head;
+        ListNode prev = null;
+        ListNode curr = head;
+        ListNode next = head.next;
+        while(next!=null){
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+            next = next.next;
+        }
+        curr.next =prev;
+        return curr;
+    }
+    public void reorderList(ListNode head) {
+        if(head==null || head.next == null) return;
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while(fast!=null && fast.next!=null){
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        ListNode head2 = reverse(slow);
+        slow.next  = null;
+        ListNode res = head;
+        ListNode n1 = head.next;
+        ListNode n2 = head2.next;
+        while(n1!=null&& n2!=null){
+            head.next = head2;
+            head2.next = n1;
+            head = n1;
+            head2 = n2;
+            n1 = n1.next;
+            n2 = n2.next;
+        }
+        head.next = head2;
+        head2.next = null;
+    
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/reordered-power-of-2/README.md b/leetcode/leetcode/reordered-power-of-2/README.md
new file mode 100644
index 0000000..3f4133f
--- /dev/null
+++ b/leetcode/leetcode/reordered-power-of-2/README.md
@@ -0,0 +1,42 @@
+<h2>869. Reordered Power of 2</h2><h3>Medium</h3><hr><div><p>You are given an integer <code>n</code>. We reorder the digits in any order (including the original order) such that the leading digit is not zero.</p>
+
+<p>Return <code>true</code> <em>if and only if we can do this so that the resulting number is a power of two</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 10
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 16
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> n = 24
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> n = 46
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/reordered-power-of-2/reordered-power-of-2.java b/leetcode/leetcode/reordered-power-of-2/reordered-power-of-2.java
new file mode 100644
index 0000000..e8747b9
--- /dev/null
+++ b/leetcode/leetcode/reordered-power-of-2/reordered-power-of-2.java
@@ -0,0 +1,21 @@
+class Solution {
+    int[] count(int n){
+        int[] arr = new int[10];
+        while(n>0){
+            arr[n%10]++;
+            n/=10;
+        }
+        return arr;
+    }
+    public boolean reorderedPowerOf2(int n) {
+        int[] digits = count(n);
+        int num =1;
+        for(int i = 1;i<31;i++){
+            if(Arrays.equals(digits,count(num))){
+                return true;
+            }
+            num = num<<1;
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-integer/README.md b/leetcode/leetcode/reverse-integer/README.md
new file mode 100644
index 0000000..12aeeff
--- /dev/null
+++ b/leetcode/leetcode/reverse-integer/README.md
@@ -0,0 +1,25 @@
+<h2>7. Reverse Integer</h2><h3>Easy</h3><hr><div><p>Given a signed 32-bit integer <code>x</code>, return <code>x</code><em> with its digits reversed</em>. If reversing <code>x</code> causes the value to go outside the signed 32-bit integer range <code>[-2<sup>31</sup>, 2<sup>31</sup> - 1]</code>, then return <code>0</code>.</p>
+
+<p><strong>Assume the environment does not allow you to store 64-bit integers (signed or unsigned).</strong></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> x = 123
+<strong>Output:</strong> 321
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> x = -123
+<strong>Output:</strong> -321
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> x = 120
+<strong>Output:</strong> 21
+</pre><p><strong>Example 4:</strong></p>
+<pre><strong>Input:</strong> x = 0
+<strong>Output:</strong> 0
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-2<sup>31</sup> &lt;= x &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-integer/reverse-integer.java b/leetcode/leetcode/reverse-integer/reverse-integer.java
new file mode 100644
index 0000000..61161d1
--- /dev/null
+++ b/leetcode/leetcode/reverse-integer/reverse-integer.java
@@ -0,0 +1,11 @@
+class Solution {
+    public int reverse(int x) {
+        long result = 0;        
+        while(x!=0){
+            result = result*10 + (x%10);
+            x = x /10;
+        }
+        if(result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) return 0;
+        return (int) result;
+    }
+}
diff --git a/leetcode/leetcode/reverse-linked-list-ii/README.md b/leetcode/leetcode/reverse-linked-list-ii/README.md
new file mode 100644
index 0000000..52e9be3
--- /dev/null
+++ b/leetcode/leetcode/reverse-linked-list-ii/README.md
@@ -0,0 +1,28 @@
+[Discussion Post (created on 9/11/2021 at 21:9)](https://leetcode.com/problems/reverse-linked-list-ii/discuss/1619975/Java-100-Fast)  
+<h2>92. Reverse Linked List II</h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a singly linked list and two integers <code>left</code> and <code>right</code> where <code>left &lt;= right</code>, reverse the nodes of the list from position <code>left</code> to position <code>right</code>, and return <em>the reversed list</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/rev2ex2.jpg" style="width: 542px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5], left = 2, right = 4
+<strong>Output:</strong> [1,4,3,2,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [5], left = 1, right = 1
+<strong>Output:</strong> [5]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is <code>n</code>.</li>
+	<li><code>1 &lt;= n &lt;= 500</code></li>
+	<li><code>-500 &lt;= Node.val &lt;= 500</code></li>
+	<li><code>1 &lt;= left &lt;= right &lt;= n</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Could you do it in one pass?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-linked-list-ii/reverse-linked-list-ii.java b/leetcode/leetcode/reverse-linked-list-ii/reverse-linked-list-ii.java
new file mode 100644
index 0000000..a45ca3b
--- /dev/null
+++ b/leetcode/leetcode/reverse-linked-list-ii/reverse-linked-list-ii.java
@@ -0,0 +1,55 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    
+    
+    public ListNode reverse(ListNode head){
+        if(head ==null || head.next==null) return head;
+        ListNode prev = null;
+        ListNode current = head;
+        ListNode next = head.next;
+        while(next!=null){
+            current.next = prev;
+            prev = current;
+            current = next;
+            next = next.next;
+        }
+        current.next = prev;
+        return current;
+    }
+    
+    public ListNode reverseBetween(ListNode head, int left, int right) {
+        ListNode temp = head;
+        ListNode prev = null;
+        int counter = 1;
+        while(counter!=left){
+            prev = temp;
+            temp = temp.next;
+            counter++;
+        }
+        ListNode rev = temp;
+        while(counter!=right){
+            temp = temp.next;
+            counter++;
+        }
+        ListNode tail = temp.next;
+        temp.next = null;
+        ListNode newHead = reverse(rev);
+        rev.next = tail;
+        if(prev==null){
+            head = newHead;
+        }else{
+            prev.next = newHead;
+        }
+        return head;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-linked-list/README.md b/leetcode/leetcode/reverse-linked-list/README.md
new file mode 100644
index 0000000..243642c
--- /dev/null
+++ b/leetcode/leetcode/reverse-linked-list/README.md
@@ -0,0 +1,32 @@
+<h2>206. Reverse Linked List</h2><h3>Easy</h3><hr><div><p>Given the <code>head</code> of a singly linked list, reverse the list, and return <em>the reversed list</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg" style="width: 542px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5]
+<strong>Output:</strong> [5,4,3,2,1]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg" style="width: 182px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2]
+<strong>Output:</strong> [2,1]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is the range <code>[0, 5000]</code>.</li>
+	<li><code>-5000 &lt;= Node.val &lt;= 5000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> A linked list can be reversed either iteratively or recursively. Could you implement both?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-linked-list/reverse-linked-list.java b/leetcode/leetcode/reverse-linked-list/reverse-linked-list.java
new file mode 100644
index 0000000..273d95b
--- /dev/null
+++ b/leetcode/leetcode/reverse-linked-list/reverse-linked-list.java
@@ -0,0 +1,26 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode reverseList(ListNode head) {
+        if(head == null || head.next ==null) return head;
+        ListNode prev = null;
+        ListNode current  = head;
+        ListNode Next = head.next;
+        while(Next!=null){
+            current.next = prev;
+            prev = current;
+            current = Next;
+            Next = Next.next;
+        }
+        current.next = prev;
+        return current;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-nodes-in-k-group/README.md b/leetcode/leetcode/reverse-nodes-in-k-group/README.md
new file mode 100644
index 0000000..bf92ff7
--- /dev/null
+++ b/leetcode/leetcode/reverse-nodes-in-k-group/README.md
@@ -0,0 +1,31 @@
+<h2>25. Reverse Nodes in k-Group</h2><h3>Hard</h3><hr><div><p>Given the <code>head</code> of a linked list, reverse the nodes of the list <code>k</code> at a time, and return <em>the modified list</em>.</p>
+
+<p><code>k</code> is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of <code>k</code> then left-out nodes, in the end, should remain as it is.</p>
+
+<p>You may not alter the values in the list's nodes, only nodes themselves may be changed.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex1.jpg" style="width: 542px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5], k = 2
+<strong>Output:</strong> [2,1,4,3,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/reverse_ex2.jpg" style="width: 542px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5], k = 3
+<strong>Output:</strong> [3,2,1,4,5]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is <code>n</code>.</li>
+	<li><code>1 &lt;= k &lt;= n &lt;= 5000</code></li>
+	<li><code>0 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow-up:</strong> Can you solve the problem in <code>O(1)</code> extra memory space?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-nodes-in-k-group/reverse-nodes-in-k-group.java b/leetcode/leetcode/reverse-nodes-in-k-group/reverse-nodes-in-k-group.java
new file mode 100644
index 0000000..70f5f24
--- /dev/null
+++ b/leetcode/leetcode/reverse-nodes-in-k-group/reverse-nodes-in-k-group.java
@@ -0,0 +1,43 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode reverse(ListNode head){
+        ListNode prev = null;
+        ListNode curr = head;
+        ListNode next = head.next;
+        while(next!=null){
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+            next = next.next;
+        }
+        curr.next = prev;
+        return curr;
+    }
+    public ListNode reverseKGroup(ListNode head, int k) {
+        if(head==null || head.next == null || k == 1) return head;
+        ListNode temp = head;
+        int counter = 0;
+        while(counter!=k-1){
+            temp = temp.next;
+            counter++;
+            if(temp==null) break;
+        }
+        if(counter==k-1 && temp!=null) {
+            ListNode next = temp.next;
+            ListNode curr = head;
+            temp.next = null;
+            head = reverse(head);
+            curr.next = reverseKGroup(next,k);
+        }
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-string/README.md b/leetcode/leetcode/reverse-string/README.md
new file mode 100644
index 0000000..b534d35
--- /dev/null
+++ b/leetcode/leetcode/reverse-string/README.md
@@ -0,0 +1,20 @@
+<h2>344. Reverse String</h2><h3>Easy</h3><hr><div><p>Write a function that reverses a string. The input string is given as an array of characters <code>s</code>.</p>
+
+<p>You must do this by modifying the input array <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> with <code>O(1)</code> extra memory.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = ["h","e","l","l","o"]
+<strong>Output:</strong> ["o","l","l","e","h"]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> s = ["H","a","n","n","a","h"]
+<strong>Output:</strong> ["h","a","n","n","a","H"]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>s[i]</code> is a <a href="https://en.wikipedia.org/wiki/ASCII#Printable_characters" target="_blank">printable ascii character</a>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-string/reverse-string.java b/leetcode/leetcode/reverse-string/reverse-string.java
new file mode 100644
index 0000000..18b720f
--- /dev/null
+++ b/leetcode/leetcode/reverse-string/reverse-string.java
@@ -0,0 +1,13 @@
+class Solution {
+    public void reverseString(char[] s) {
+        int low = 0;
+        int high = s.length - 1;
+        while(low<high){
+            Character temp = s[low];
+            s[low] = s[high];
+            s[high] = temp;
+            low++;
+            high--;
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-words-in-a-string/README.md b/leetcode/leetcode/reverse-words-in-a-string/README.md
new file mode 100644
index 0000000..04be76e
--- /dev/null
+++ b/leetcode/leetcode/reverse-words-in-a-string/README.md
@@ -0,0 +1,54 @@
+[Discussion Post (created on 20/9/2021 at 12:46)](https://leetcode.com/problems/reverse-words-in-a-string/discuss/1531091/JAVA-O(n)-time-O(1)-space)  
+<h2>151. Reverse Words in a String</h2><h3>Medium</h3><hr><div><p>Given an input string <code>s</code>, reverse the order of the <strong>words</strong>.</p>
+
+<p>A <strong>word</strong> is defined as a sequence of non-space characters. The <strong>words</strong> in <code>s</code> will be separated by at least one space.</p>
+
+<p>Return <em>a string of the words in reverse order concatenated by a single space.</em></p>
+
+<p><b>Note</b> that <code>s</code> may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "the sky is blue"
+<strong>Output:</strong> "blue is sky the"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "  hello world  "
+<strong>Output:</strong> "world hello"
+<strong>Explanation:</strong> Your reversed string should not contain leading or trailing spaces.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "a good   example"
+<strong>Output:</strong> "example good a"
+<strong>Explanation:</strong> You need to reduce multiple spaces between two words to a single space in the reversed string.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> s = "  Bob    Loves  Alice   "
+<strong>Output:</strong> "Alice Loves Bob"
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> s = "Alice does not even like bob"
+<strong>Output:</strong> "bob like even not does Alice"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> contains English letters (upper-case and lower-case), digits, and spaces <code>' '</code>.</li>
+	<li>There is <strong>at least one</strong> word in <code>s</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><b data-stringify-type="bold">Follow-up:&nbsp;</b>If the string data type is mutable in your language, can&nbsp;you solve it&nbsp;<b data-stringify-type="bold">in-place</b>&nbsp;with&nbsp;<code data-stringify-type="code">O(1)</code>&nbsp;extra space?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/reverse-words-in-a-string/reverse-words-in-a-string.java b/leetcode/leetcode/reverse-words-in-a-string/reverse-words-in-a-string.java
new file mode 100644
index 0000000..dbb6631
--- /dev/null
+++ b/leetcode/leetcode/reverse-words-in-a-string/reverse-words-in-a-string.java
@@ -0,0 +1,22 @@
+class Solution {
+    public String reverseWords(String s) {
+        int i = s.length() -1;
+        StringBuilder res = new StringBuilder();
+        while(i>=0){
+            while(i>=0 && s.charAt(i)==' ') i--;
+            int j = i;
+            if(i<0) break;
+            while(i>=0 && s.charAt(i)!=' ') i--;
+            if(res.length() == 0){
+                res.append(s.substring(i+1,j+1));
+            }
+            else{
+                res.append(" ");
+                res.append(s.substring(i+1,j+1));
+            }
+        }
+        
+        return res.toString();
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/rotate-array/README.md b/leetcode/leetcode/rotate-array/README.md
new file mode 100644
index 0000000..49cca61
--- /dev/null
+++ b/leetcode/leetcode/rotate-array/README.md
@@ -0,0 +1,39 @@
+<h2>189. Rotate Array</h2><h3>Medium</h3><hr><div><p>Given an array, rotate the array to the right by <code>k</code> steps, where <code>k</code> is non-negative.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,5,6,7], k = 3
+<strong>Output:</strong> [5,6,7,1,2,3,4]
+<strong>Explanation:</strong>
+rotate 1 steps to the right: [7,1,2,3,4,5,6]
+rotate 2 steps to the right: [6,7,1,2,3,4,5]
+rotate 3 steps to the right: [5,6,7,1,2,3,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,-100,3,99], k = 2
+<strong>Output:</strong> [3,99,-1,-100]
+<strong>Explanation:</strong> 
+rotate 1 steps to the right: [99,-1,-100,3]
+rotate 2 steps to the right: [3,99,-1,-100]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+	<li><code>0 &lt;= k &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>Try to come up with as many solutions as you can. There are at least <strong>three</strong> different ways to solve this problem.</li>
+	<li>Could you do it in-place with <code>O(1)</code> extra space?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/rotate-array/rotate-array.java b/leetcode/leetcode/rotate-array/rotate-array.java
new file mode 100644
index 0000000..2368044
--- /dev/null
+++ b/leetcode/leetcode/rotate-array/rotate-array.java
@@ -0,0 +1,21 @@
+class Solution {
+    public void swap(int[] arr,int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    public void reverse(int[] arr, int start, int end){
+        while(start<end){
+            swap(arr,start,end);
+            start++;
+            end--;
+        }
+    }
+    public void rotate(int[] nums, int k) {
+        int len =nums.length;
+        k = k%len;
+        reverse(nums,0,len-1);
+        reverse(nums,0,k-1);
+        reverse(nums,k,len-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/rotate-list/README.md b/leetcode/leetcode/rotate-list/README.md
new file mode 100644
index 0000000..fab98cf
--- /dev/null
+++ b/leetcode/leetcode/rotate-list/README.md
@@ -0,0 +1,24 @@
+<h2>61. Rotate List</h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a linked&nbsp;list, rotate the list to the right by <code>k</code> places.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/rotate1.jpg" style="width: 450px; height: 191px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5], k = 2
+<strong>Output:</strong> [4,5,1,2,3]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/roate2.jpg" style="width: 305px; height: 350px;">
+<pre><strong>Input:</strong> head = [0,1,2], k = 4
+<strong>Output:</strong> [2,0,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 500]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+	<li><code>0 &lt;= k &lt;= 2 * 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/rotate-list/rotate-list.java b/leetcode/leetcode/rotate-list/rotate-list.java
new file mode 100644
index 0000000..90e039b
--- /dev/null
+++ b/leetcode/leetcode/rotate-list/rotate-list.java
@@ -0,0 +1,39 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    
+
+    
+    public ListNode rotateRight(ListNode head, int k) {
+        if(head ==null || head.next == null|| k==0) return head;
+        ListNode temp = head;
+        int size = 0;
+        while(temp!=null){
+            temp = temp.next;
+            size ++;
+        }
+        k = k%size;
+        if(k==0) return head;
+        temp = head;
+        int counter = 0;
+        while(counter<size-k-1){
+            temp = temp.next;
+            counter++;
+        }
+        ListNode temp2  =temp.next;
+        temp.next = null;
+        temp = temp2;
+        while(temp.next != null) temp = temp.next;
+        temp.next = head;
+        head = temp2;
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/running-sum-of-1d-array/README.md b/leetcode/leetcode/running-sum-of-1d-array/README.md
new file mode 100644
index 0000000..ae57887
--- /dev/null
+++ b/leetcode/leetcode/running-sum-of-1d-array/README.md
@@ -0,0 +1,30 @@
+<h2>1480. Running Sum of 1d Array</h2><h3>Easy</h3><hr><div><p>Given an array <code>nums</code>. We define a running sum of an array as&nbsp;<code>runningSum[i] = sum(nums[0]…nums[i])</code>.</p>
+
+<p>Return the running sum of <code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> [1,3,6,10]
+<strong>Explanation:</strong> Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,1,1,1]
+<strong>Output:</strong> [1,2,3,4,5]
+<strong>Explanation:</strong> Running sum is obtained as follows: [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1].</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,1,2,10,1]
+<strong>Output:</strong> [3,4,6,16,17]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>-10^6&nbsp;&lt;= nums[i] &lt;=&nbsp;10^6</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/running-sum-of-1d-array/running-sum-of-1d-array.java b/leetcode/leetcode/running-sum-of-1d-array/running-sum-of-1d-array.java
new file mode 100644
index 0000000..4e6a59e
--- /dev/null
+++ b/leetcode/leetcode/running-sum-of-1d-array/running-sum-of-1d-array.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int[] runningSum(int[] nums) {
+        int result[] = new int[nums.length];
+        result[0] = nums[0];
+        for(int i=1;i<nums.length;i++){
+            result[i] = result[i-1] + nums[i];
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/same-tree/README.md b/leetcode/leetcode/same-tree/README.md
new file mode 100644
index 0000000..9572f3d
--- /dev/null
+++ b/leetcode/leetcode/same-tree/README.md
@@ -0,0 +1,31 @@
+<h2>100. Same Tree</h2><h3>Easy</h3><hr><div><p>Given the roots of two binary trees <code>p</code> and <code>q</code>, write a function to check if they are the same or not.</p>
+
+<p>Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex1.jpg" style="width: 622px; height: 182px;">
+<pre><strong>Input:</strong> p = [1,2,3], q = [1,2,3]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex2.jpg" style="width: 382px; height: 182px;">
+<pre><strong>Input:</strong> p = [1,2], q = [1,null,2]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/20/ex3.jpg" style="width: 622px; height: 182px;">
+<pre><strong>Input:</strong> p = [1,2,1], q = [1,1,2]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in both trees is in the range <code>[0, 100]</code>.</li>
+	<li><code>-10<sup>4</sup> &lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/same-tree/same-tree.java b/leetcode/leetcode/same-tree/same-tree.java
new file mode 100644
index 0000000..5b82723
--- /dev/null
+++ b/leetcode/leetcode/same-tree/same-tree.java
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        if(p==null && q==null) return true;
+        if(p==null || q==null) return false;
+        if(p.val == q.val){
+            return (isSameTree(p.left, q.left) && isSameTree(p.right, q.right));
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/search-insert-position/README.md b/leetcode/leetcode/search-insert-position/README.md
new file mode 100644
index 0000000..8c54391
--- /dev/null
+++ b/leetcode/leetcode/search-insert-position/README.md
@@ -0,0 +1,33 @@
+<h2>35. Search Insert Position</h2><h3>Easy</h3><hr><div><p>Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.</p>
+
+<p>You must&nbsp;write an algorithm with&nbsp;<code>O(log n)</code> runtime complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3,5,6], target = 5
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3,5,6], target = 2
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3,5,6], target = 7
+<strong>Output:</strong> 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+	<li><code>nums</code> contains <strong>distinct</strong> values sorted in <strong>ascending</strong> order.</li>
+	<li><code>-10<sup>4</sup> &lt;= target &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/search-insert-position/search-insert-position.java b/leetcode/leetcode/search-insert-position/search-insert-position.java
new file mode 100644
index 0000000..1793eef
--- /dev/null
+++ b/leetcode/leetcode/search-insert-position/search-insert-position.java
@@ -0,0 +1,13 @@
+class Solution {
+    public int searchInsert(int[] arr, int target) {
+        int low = 0;
+        int high = arr.length - 1;
+        while(low<=high){
+            int mid  = (low+high)/2;
+            if(arr[mid] == target) return mid;
+            else if(arr[mid]>target) high = mid -1;
+            else low = mid+1;
+        }
+        return low;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/second-largest-digit-in-a-string/README.md b/leetcode/leetcode/second-largest-digit-in-a-string/README.md
new file mode 100644
index 0000000..4223e4b
--- /dev/null
+++ b/leetcode/leetcode/second-largest-digit-in-a-string/README.md
@@ -0,0 +1,28 @@
+[Discussion Post (created on 12/8/2021 at 13:12)](https://leetcode.com/problems/second-largest-digit-in-a-string/discuss/1458934/JAVA-Time%3A-1-ms-(99.84)-Space%3A-37.8-MB-(74.92))  
+<h2>1796. Second Largest Digit in a String</h2><h3>Easy</h3><hr><div><p>Given an alphanumeric string <code>s</code>, return <em>the <strong>second largest</strong> numerical digit that appears in </em><code>s</code><em>, or </em><code>-1</code><em> if it does not exist</em>.</p>
+
+<p>An <strong>alphanumeric</strong><strong> </strong>string is a string consisting of lowercase English letters and digits.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "dfa12321afd"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The digits that appear in s are [1, 2, 3]. The second largest digit is 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "abc1111"
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> The digits that appear in s are [1]. There is no second largest digit. 
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 500</code></li>
+	<li><code>s</code> consists of only lowercase English letters and/or digits.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/second-largest-digit-in-a-string/second-largest-digit-in-a-string.java b/leetcode/leetcode/second-largest-digit-in-a-string/second-largest-digit-in-a-string.java
new file mode 100644
index 0000000..0229cef
--- /dev/null
+++ b/leetcode/leetcode/second-largest-digit-in-a-string/second-largest-digit-in-a-string.java
@@ -0,0 +1,22 @@
+class Solution {
+    public int secondHighest(String s) {
+        int firstLargest = -1;
+        int secondLargest = -1;
+        for(int i = 0;i<s.length();i++){
+            int result = 0;
+            if(s.charAt(i) > 47 && s.charAt(i)<58){
+                result = s.charAt(i) - 48;  
+                if(result>firstLargest){
+                    secondLargest = firstLargest;
+                    firstLargest = result;
+                }else if(result>secondLargest && result<firstLargest){
+                    secondLargest = result;
+                }
+            }
+        }
+        if(firstLargest == secondLargest){
+            return -1 ;
+        }
+        return secondLargest;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/shuffle-an-array/README.md b/leetcode/leetcode/shuffle-an-array/README.md
new file mode 100644
index 0000000..1a73a22
--- /dev/null
+++ b/leetcode/leetcode/shuffle-an-array/README.md
@@ -0,0 +1,39 @@
+<h2>384. Shuffle an Array</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, design an algorithm to randomly shuffle the array. All permutations of the array should be <strong>equally likely</strong> as a result of the shuffling.</p>
+
+<p>Implement the <code>Solution</code> class:</p>
+
+<ul>
+	<li><code>Solution(int[] nums)</code> Initializes the object with the integer array <code>nums</code>.</li>
+	<li><code>int[] reset()</code> Resets the array to its original configuration and returns it.</li>
+	<li><code>int[] shuffle()</code> Returns a random shuffling of the array.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["Solution", "shuffle", "reset", "shuffle"]
+[[[1, 2, 3]], [], [], []]
+<strong>Output</strong>
+[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]
+
+<strong>Explanation</strong>
+Solution solution = new Solution([1, 2, 3]);
+solution.shuffle();    // Shuffle the array [1,2,3] and return its result.
+                       // Any permutation of [1,2,3] must be equally likely to be returned.
+                       // Example: return [3, 1, 2]
+solution.reset();      // Resets the array back to its original configuration [1,2,3]. Return [1, 2, 3]
+solution.shuffle();    // Returns the random shuffling of array [1,2,3]. Example: return [1, 3, 2]
+
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 200</code></li>
+	<li><code>-10<sup>6</sup> &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+	<li>All the elements of <code>nums</code> are <strong>unique</strong>.</li>
+	<li>At most <code>5 * 10<sup>4</sup></code> calls <strong>in total</strong> will be made to <code>reset</code> and <code>shuffle</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/shuffle-an-array/shuffle-an-array.java b/leetcode/leetcode/shuffle-an-array/shuffle-an-array.java
new file mode 100644
index 0000000..0823abb
--- /dev/null
+++ b/leetcode/leetcode/shuffle-an-array/shuffle-an-array.java
@@ -0,0 +1,33 @@
+class Solution {
+    public int[] arr;
+    public Solution(int[] nums) {
+        arr = nums;
+    }
+    
+    public int[] reset() {
+        return arr;
+    }
+    
+    public int[] shuffle() {
+        if(arr.length < 2) return arr;
+        int[] nums = arr.clone();
+        for(int i =0;i<arr.length;i++){
+            int random =(int)(Math.random()*(arr.length-0)+0);
+            swap(nums, i, random);
+        }
+        return nums;
+    }
+    
+    public void swap(int[] arr, int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution obj = new Solution(nums);
+ * int[] param_1 = obj.reset();
+ * int[] param_2 = obj.shuffle();
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/sign-of-the-product-of-an-array/README.md b/leetcode/leetcode/sign-of-the-product-of-an-array/README.md
new file mode 100644
index 0000000..1480c4d
--- /dev/null
+++ b/leetcode/leetcode/sign-of-the-product-of-an-array/README.md
@@ -0,0 +1,42 @@
+<h2>1822. Sign of the Product of an Array</h2><h3>Easy</h3><hr><div><p>There is a function <code>signFunc(x)</code> that returns:</p>
+
+<ul>
+	<li><code>1</code> if <code>x</code> is positive.</li>
+	<li><code>-1</code> if <code>x</code> is negative.</li>
+	<li><code>0</code> if <code>x</code> is equal to <code>0</code>.</li>
+</ul>
+
+<p>You are given an integer array <code>nums</code>. Let <code>product</code> be the product of all values in the array <code>nums</code>.</p>
+
+<p>Return <code>signFunc(product)</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,-2,-3,-4,3,2,1]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The product of all values in the array is 144, and signFunc(144) = 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,5,0,2,-3]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The product of all values in the array is 0, and signFunc(0) = 0
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,1,-1,1,-1]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> The product of all values in the array is -1, and signFunc(-1) = -1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>-100 &lt;= nums[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/sign-of-the-product-of-an-array/sign-of-the-product-of-an-array.java b/leetcode/leetcode/sign-of-the-product-of-an-array/sign-of-the-product-of-an-array.java
new file mode 100644
index 0000000..44960a0
--- /dev/null
+++ b/leetcode/leetcode/sign-of-the-product-of-an-array/sign-of-the-product-of-an-array.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int arraySign(int[] nums) {
+        int sign = 1;
+        for(short i = 0;i<nums.length;i++){
+            if(nums[i]<0) sign = -sign;
+            else if(nums[i] ==0) return 0;
+        }
+        return sign;
+    }
+}
diff --git a/leetcode/leetcode/simple-bank-system/README.md b/leetcode/leetcode/simple-bank-system/README.md
new file mode 100644
index 0000000..349d77e
--- /dev/null
+++ b/leetcode/leetcode/simple-bank-system/README.md
@@ -0,0 +1,50 @@
+<h2>2043. Simple Bank System</h2><h3>Medium</h3><hr><div><p>You have been tasked with writing a program for a popular bank that will automate all its incoming transactions (transfer, deposit, and withdraw). The bank has <code>n</code> accounts numbered from <code>1</code> to <code>n</code>. The initial balance of each account is stored in a <strong>0-indexed</strong> integer array <code>balance</code>, with the <code>(i + 1)<sup>th</sup></code> account having an initial balance of <code>balance[i]</code>.</p>
+
+<p>Execute all the <strong>valid</strong> transactions. A transaction is <strong>valid</strong> if:</p>
+
+<ul>
+	<li>The given account number(s) are between <code>1</code> and <code>n</code>, and</li>
+	<li>The amount of money withdrawn or transferred from is <strong>less than or equal</strong> to the balance of the account.</li>
+</ul>
+
+<p>Implement the <code>Bank</code> class:</p>
+
+<ul>
+	<li><code>Bank(long[] balance)</code> Initializes the object with the <strong>0-indexed</strong> integer array <code>balance</code>.</li>
+	<li><code>boolean transfer(int account1, int account2, long money)</code> Transfers <code>money</code> dollars from the account numbered <code>account1</code> to the account numbered <code>account2</code>. Return <code>true</code> if the transaction was successful, <code>false</code> otherwise.</li>
+	<li><code>boolean deposit(int account, long money)</code> Deposit <code>money</code> dollars into the account numbered <code>account</code>. Return <code>true</code> if the transaction was successful, <code>false</code> otherwise.</li>
+	<li><code>boolean withdraw(int account, long money)</code> Withdraw <code>money</code> dollars from the account numbered <code>account</code>. Return <code>true</code> if the transaction was successful, <code>false</code> otherwise.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["Bank", "withdraw", "transfer", "deposit", "transfer", "withdraw"]
+[[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]
+<strong>Output</strong>
+[null, true, true, true, false, false]
+
+<strong>Explanation</strong>
+Bank bank = new Bank([10, 100, 20, 50, 30]);
+bank.withdraw(3, 10);    // return true, account 3 has a balance of $20, so it is valid to withdraw $10.
+                         // Account 3 has $20 - $10 = $10.
+bank.transfer(5, 1, 20); // return true, account 5 has a balance of $30, so it is valid to transfer $20.
+                         // Account 5 has $30 - $20 = $10, and account 1 has $10 + $20 = $30.
+bank.deposit(5, 20);     // return true, it is valid to deposit $20 to account 5.
+                         // Account 5 has $10 + $20 = $30.
+bank.transfer(3, 4, 15); // return false, the current balance of account 3 is $10,
+                         // so it is invalid to transfer $15 from it.
+bank.withdraw(10, 50);   // return false, it is invalid because account 10 does not exist.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == balance.length</code></li>
+	<li><code>1 &lt;= n, account, account1, account2 &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= balance[i], money &lt;= 10<sup>12</sup></code></li>
+	<li>At most <code>10<sup>4</sup></code> calls will be made to <strong>each</strong> function <code>transfer</code>, <code>deposit</code>, <code>withdraw</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/simple-bank-system/simple-bank-system.java b/leetcode/leetcode/simple-bank-system/simple-bank-system.java
new file mode 100644
index 0000000..25c9007
--- /dev/null
+++ b/leetcode/leetcode/simple-bank-system/simple-bank-system.java
@@ -0,0 +1,43 @@
+class Bank {
+    public long[] bal;
+    public Bank(long[] balance) {
+        bal = balance;
+    }
+    
+    public boolean transfer(int account1, int account2, long money) {
+        if(account1<=bal.length && account2<=bal.length){
+            if(bal[account1-1]>=money){
+                bal[account1-1]-=money;
+                bal[account2-1]+=money;
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    public boolean deposit(int account, long money) {
+        if(account<=bal.length){
+            bal[account-1]+=money;
+            return true;    
+        }
+        return false;
+    }
+    
+    public boolean withdraw(int account, long money) {
+        if(account<=bal.length){
+            if(bal[account-1]>=money){
+                bal[account-1]-=money;
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+/**
+ * Your Bank object will be instantiated and called as such:
+ * Bank obj = new Bank(balance);
+ * boolean param_1 = obj.transfer(account1,account2,money);
+ * boolean param_2 = obj.deposit(account,money);
+ * boolean param_3 = obj.withdraw(account,money);
+ */
\ No newline at end of file
diff --git a/leetcode/leetcode/single-element-in-a-sorted-array/README.md b/leetcode/leetcode/single-element-in-a-sorted-array/README.md
new file mode 100644
index 0000000..7c05cf6
--- /dev/null
+++ b/leetcode/leetcode/single-element-in-a-sorted-array/README.md
@@ -0,0 +1,20 @@
+<h2>540. Single Element in a Sorted Array</h2><h3>Medium</h3><hr><div><p>You are given a sorted array consisting of only integers where every element appears exactly twice, except for one element which appears exactly&nbsp;once. Find this single element that appears only once.</p>
+
+<p><b>Follow up:</b> Your solution should run in O(log n) time and O(1) space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,2,3,3,4,4,8,8]
+<strong>Output:</strong> 2
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [3,3,7,7,10,11,11]
+<strong>Output:</strong> 10
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10^5</code></li>
+	<li><code>0 &lt;= nums[i]&nbsp;&lt;= 10^5</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/single-element-in-a-sorted-array/single-element-in-a-sorted-array.java b/leetcode/leetcode/single-element-in-a-sorted-array/single-element-in-a-sorted-array.java
new file mode 100644
index 0000000..250b57c
--- /dev/null
+++ b/leetcode/leetcode/single-element-in-a-sorted-array/single-element-in-a-sorted-array.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int singleNonDuplicate(int[] nums) {
+        int len = nums.length;
+        if(len==1) return nums[0];
+        else if(nums[0] != nums[1]) return nums[0];
+        else if(nums[len-1] != nums[len-2]) return nums[len-1];
+        else{
+            int counter = 1;
+            while(counter<len){
+                if(nums[counter-1]!=nums[counter]) return nums[counter-1];
+                counter+=2;
+            }
+        }
+        return 0;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/single-number-ii/README.md b/leetcode/leetcode/single-number-ii/README.md
new file mode 100644
index 0000000..8c2c862
--- /dev/null
+++ b/leetcode/leetcode/single-number-ii/README.md
@@ -0,0 +1,21 @@
+<h2>137. Single Number II</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> where&nbsp;every element appears <strong>three times</strong> except for one, which appears <strong>exactly once</strong>. <em>Find the single element and return it</em>.</p>
+
+<p>You must&nbsp;implement a solution with a linear runtime complexity and use&nbsp;only constant&nbsp;extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,3,2]
+<strong>Output:</strong> 3
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [0,1,0,1,0,1,99]
+<strong>Output:</strong> 99
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-2<sup>31</sup> &lt;= nums[i] &lt;= 2<sup>31</sup> - 1</code></li>
+	<li>Each element in <code>nums</code> appears exactly <strong>three times</strong> except for one element which appears <strong>once</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/single-number-ii/single-number-ii.java b/leetcode/leetcode/single-number-ii/single-number-ii.java
new file mode 100644
index 0000000..724dc22
--- /dev/null
+++ b/leetcode/leetcode/single-number-ii/single-number-ii.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int singleNumber(int[] nums) {
+        int len = nums.length;
+        if(len==1) return nums[0];
+        Arrays.sort(nums);
+        if(nums[1]!=nums[0]) return nums[0];
+        else if(nums[len-1] != nums[len-2]) return nums[len-1];
+        else{
+            int counter = 1;
+            while(counter<len){
+                if(!(nums[counter-1] == nums[counter])){
+                    return nums[counter-1];
+                }
+                counter += 3;
+            }
+        }
+        return 0;
+    }
+}
diff --git a/leetcode/leetcode/single-number/README.md b/leetcode/leetcode/single-number/README.md
new file mode 100644
index 0000000..12484e9
--- /dev/null
+++ b/leetcode/leetcode/single-number/README.md
@@ -0,0 +1,24 @@
+<h2>136. Single Number</h2><h3>Easy</h3><hr><div><p>Given a <strong>non-empty</strong>&nbsp;array of integers <code>nums</code>, every element appears <em>twice</em> except for one. Find that single one.</p>
+
+<p>You must&nbsp;implement a solution with a linear runtime complexity and use&nbsp;only constant&nbsp;extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,1]
+<strong>Output:</strong> 1
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [4,1,2,1,2]
+<strong>Output:</strong> 4
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> 1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-3 * 10<sup>4</sup> &lt;= nums[i] &lt;= 3 * 10<sup>4</sup></code></li>
+	<li>Each element in the array appears twice except for one element which appears only once.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/single-number/single-number.java b/leetcode/leetcode/single-number/single-number.java
new file mode 100644
index 0000000..0bd61c3
--- /dev/null
+++ b/leetcode/leetcode/single-number/single-number.java
@@ -0,0 +1,9 @@
+class Solution {
+    public int singleNumber(int[] nums) {
+        int res = 0;
+        for(int num: nums){
+            res = res^num;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/sort-an-array/README.md b/leetcode/leetcode/sort-an-array/README.md
new file mode 100644
index 0000000..95ef07f
--- /dev/null
+++ b/leetcode/leetcode/sort-an-array/README.md
@@ -0,0 +1,18 @@
+<h2>912. Sort an Array</h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>nums</code>, sort the array in ascending order.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [5,2,3,1]
+<strong>Output:</strong> [1,2,3,5]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [5,1,1,2,0,0]
+<strong>Output:</strong> [0,0,1,1,2,5]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>-5 * 10<sup>4</sup> &lt;= nums[i] &lt;= 5 * 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/sort-an-array/sort-an-array.java b/leetcode/leetcode/sort-an-array/sort-an-array.java
new file mode 100644
index 0000000..e0efa61
--- /dev/null
+++ b/leetcode/leetcode/sort-an-array/sort-an-array.java
@@ -0,0 +1,54 @@
+class Solution {
+    
+    public void swap(int[] arr, int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    
+    public int partation(int[] arr, int si, int ei){
+        int counter = 0;
+        for(int i = si+1;i<=ei;i++){
+            if(arr[i]<arr[si]){
+                counter++;
+            }
+        }
+        swap(arr,si,si+counter);
+        int i  =si;
+        int j = ei;
+        while(i<si+counter && j>si+counter){
+            if(arr[i]<arr[si+counter]){
+                if(arr[j]>=arr[si+counter]){
+                    i++;
+                    j--;
+                }else{
+                    i++;
+                }
+            }else{
+                if(arr[j]>=arr[si+counter]){
+                    j--;
+                }else{
+                    swap(arr,i,j);
+                    i++;
+                    j--;
+                }
+            }
+        }
+        return si+counter;
+        
+    }
+    public void quickSort(int[] arr, int si, int ei){
+        if(si>=ei){
+            return;
+        }else{
+            int c = partation(arr,si,ei);
+            quickSort(arr,si,c-1);
+            quickSort(arr,c+1,ei);
+        }
+    }
+    
+    public int[] sortArray(int[] nums) {
+        quickSort(nums,0,nums.length-1);
+        return nums;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/sort-array-by-parity/sort-array-by-parity.java b/leetcode/leetcode/sort-array-by-parity/sort-array-by-parity.java
new file mode 100644
index 0000000..39d682a
--- /dev/null
+++ b/leetcode/leetcode/sort-array-by-parity/sort-array-by-parity.java
@@ -0,0 +1,27 @@
+class Solution {
+    public void swap(int[] arr, int i , int j ){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    public int[] sortArrayByParity(int[] nums) {
+        int i = 0;
+        int j = nums.length -1;
+        while(i<j){
+            if(nums[i]%2==0){
+                if(nums[j]%2!=0){
+                    j--;
+                }
+                    i++;
+                
+            }else{
+                if(nums[j]%2==0){
+                    swap(nums,i,j);
+                    i++;
+                }
+                j--;
+            }
+        }
+        return nums;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/sort-colors/README.md b/leetcode/leetcode/sort-colors/README.md
new file mode 100644
index 0000000..91a96c6
--- /dev/null
+++ b/leetcode/leetcode/sort-colors/README.md
@@ -0,0 +1,33 @@
+[Discussion Post (created on 25/1/2022 at 11:5)](https://leetcode.com/problems/sort-colors/discuss/1797782/Java-Fastest-100-3-pointers-aprroach)  
+<h2>75. Sort Colors</h2><h3>Medium</h3><hr><div><p>Given an array <code>nums</code> with <code>n</code> objects colored red, white, or blue, sort them <strong><a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in-place</a> </strong>so that objects of the same color are adjacent, with the colors in the order red, white, and blue.</p>
+
+<p>We will use the integers <code>0</code>, <code>1</code>, and <code>2</code> to represent the color red, white, and blue, respectively.</p>
+
+<p>You must solve this problem without using the library's sort function.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [2,0,2,1,1,0]
+<strong>Output:</strong> [0,0,1,1,2,2]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [2,0,1]
+<strong>Output:</strong> [0,1,2]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [0]
+<strong>Output:</strong> [0]
+</pre><p><strong>Example 4:</strong></p>
+<pre><strong>Input:</strong> nums = [1]
+<strong>Output:</strong> [1]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 300</code></li>
+	<li><code>nums[i]</code> is <code>0</code>, <code>1</code>, or <code>2</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong>&nbsp;Could you come up with a one-pass algorithm using only&nbsp;constant extra space?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/sort-colors/sort-colors.java b/leetcode/leetcode/sort-colors/sort-colors.java
new file mode 100644
index 0000000..1787cf4
--- /dev/null
+++ b/leetcode/leetcode/sort-colors/sort-colors.java
@@ -0,0 +1,45 @@
+class Solution {
+    public void swap(int[] arr, int i, int j){
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+    public void sortColors(int[] nums) {
+        int i = 0;
+        int j = nums.length -1 ;
+        int zeros = 0;
+        while(i<j){
+            if(nums[i] == 0 && nums[j] == 0){
+                i++;
+                zeros++;
+            }else if(nums[i] != 0 && nums[j] == 0){
+                swap(nums,i,j);
+                i++;
+                j--;
+                zeros++;
+            }else if(nums[i] == 0 && nums[j] != 0){
+                i++;
+                j--;
+                zeros++;
+            } else{
+                j--;
+            }
+        }
+        i = zeros;
+        j = nums.length - 1;
+        while(i<j){
+            if(nums[i] == 2 && nums[j] == 2){
+                j--;
+            } else if(nums[i] != 2 && nums[j] == 2){
+                i++;
+                j--;
+            } else if(nums[i] == 2 && nums[j] != 2){
+                swap(nums,i,j);
+                i++;
+                j--;
+            } else{
+                i++;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/sort-list/README.md b/leetcode/leetcode/sort-list/README.md
new file mode 100644
index 0000000..2f86dc3
--- /dev/null
+++ b/leetcode/leetcode/sort-list/README.md
@@ -0,0 +1,33 @@
+[Discussion Post (created on 5/11/2021 at 17:0)](https://leetcode.com/problems/sort-list/discuss/1612876/Java-Merge-Sort)  
+<h2>148. Sort List</h2><h3>Medium</h3><hr><div><p>Given the <code>head</code> of a linked list, return <em>the list after sorting it in <strong>ascending order</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg" style="width: 450px; height: 194px;">
+<pre><strong>Input:</strong> head = [4,2,1,3]
+<strong>Output:</strong> [1,2,3,4]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg" style="width: 550px; height: 184px;">
+<pre><strong>Input:</strong> head = [-1,5,3,4,0]
+<strong>Output:</strong> [-1,0,3,4,5]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>5</sup> &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Can you sort the linked list in <code>O(n logn)</code> time and <code>O(1)</code> memory (i.e. constant space)?</p>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/sort-list/sort-list.java b/leetcode/leetcode/sort-list/sort-list.java
new file mode 100644
index 0000000..7371493
--- /dev/null
+++ b/leetcode/leetcode/sort-list/sort-list.java
@@ -0,0 +1,56 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2){
+        if(l1==null) return l2;
+        if(l2==null) return l1;
+        if(l1.val>l2.val){
+            ListNode temp = l1;
+            l1 = l2;
+            l2 = temp;
+        }
+        ListNode res = l1;
+        ListNode temp  = l1;
+        l1 = l1.next;
+        while(l2!=null){
+            if(l1 == null){
+                temp.next = l2;
+                break;
+            }
+            if(l1.val>l2.val){
+                temp.next = l2;
+                l2 =l2.next;
+                temp = temp.next;
+                temp.next = l1;
+            }else{
+                temp = l1;
+                l1 = l1.next;
+            }
+        }
+        return res;   
+    }
+    
+    public ListNode sortList(ListNode head) {
+        if(head==null || head.next==null) return head;
+        ListNode prev = null;
+        ListNode slow = head;
+        ListNode fast = head;
+        while(fast!=null && fast.next !=null){
+            prev = slow;
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        prev.next = null;
+        ListNode l1 = sortList(head);
+        ListNode l2 = sortList(slow);
+        return mergeTwoLists(l1,l2);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/subdomain-visit-count/README.md b/leetcode/leetcode/subdomain-visit-count/README.md
new file mode 100644
index 0000000..ddbdea1
--- /dev/null
+++ b/leetcode/leetcode/subdomain-visit-count/README.md
@@ -0,0 +1,38 @@
+<h2>811. Subdomain Visit Count</h2><h3>Medium</h3><hr><div><p>A website domain <code>"discuss.leetcode.com"</code> consists of various subdomains. At the top level, we have <code>"com"</code>, at the next level, we have <code>"leetcode.com"</code>&nbsp;and at the lowest level, <code>"discuss.leetcode.com"</code>. When we visit a domain like <code>"discuss.leetcode.com"</code>, we will also visit the parent domains <code>"leetcode.com"</code> and <code>"com"</code> implicitly.</p>
+
+<p>A <strong>count-paired domain</strong> is a domain that has one of the two formats <code>"rep d1.d2.d3"</code> or <code>"rep d1.d2"</code> where <code>rep</code> is the number of visits to the domain and <code>d1.d2.d3</code> is the domain itself.</p>
+
+<ul>
+	<li>For example, <code>"9001 discuss.leetcode.com"</code> is a <strong>count-paired domain</strong> that indicates that <code>discuss.leetcode.com</code> was visited <code>9001</code> times.</li>
+</ul>
+
+<p>Given an array of <strong>count-paired domains</strong> <code>cpdomains</code>, return <em>an array of the <strong>count-paired domains</strong> of each subdomain in the input</em>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> cpdomains = ["9001 discuss.leetcode.com"]
+<strong>Output:</strong> ["9001 leetcode.com","9001 discuss.leetcode.com","9001 com"]
+<strong>Explanation:</strong> We only have one website domain: "discuss.leetcode.com".
+As discussed above, the subdomain "leetcode.com" and "com" will also be visited. So they will all be visited 9001 times.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> cpdomains = ["900 google.mail.com", "50 yahoo.com", "1 intel.mail.com", "5 wiki.org"]
+<strong>Output:</strong> ["901 mail.com","50 yahoo.com","900 google.mail.com","5 wiki.org","5 org","1 intel.mail.com","951 com"]
+<strong>Explanation:</strong> We will visit "google.mail.com" 900 times, "yahoo.com" 50 times, "intel.mail.com" once and "wiki.org" 5 times.
+For the subdomains, we will visit "mail.com" 900 + 1 = 901 times, "com" 900 + 50 + 1 = 951 times, and "org" 5 times.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= cpdomain.length &lt;= 100</code></li>
+	<li><code>1 &lt;= cpdomain[i].length &lt;= 100</code></li>
+	<li><code>cpdomain[i]</code> follows either the <code>"rep<sub>i</sub> d1<sub>i</sub>.d2<sub>i</sub>.d3<sub>i</sub>"</code> format or the <code>"rep<sub>i</sub> d1<sub>i</sub>.d2<sub>i</sub>"</code> format.</li>
+	<li><code>rep<sub>i</sub></code> is an integer in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>d1<sub>i</sub></code>, <code>d2<sub>i</sub></code>, and <code>d3<sub>i</sub></code> consist of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/subdomain-visit-count/subdomain-visit-count.java b/leetcode/leetcode/subdomain-visit-count/subdomain-visit-count.java
new file mode 100644
index 0000000..1edcf03
--- /dev/null
+++ b/leetcode/leetcode/subdomain-visit-count/subdomain-visit-count.java
@@ -0,0 +1,21 @@
+class Solution {
+    public List<String> subdomainVisits(String[] cpdomains) {
+        HashMap<String,Integer> map = new HashMap<String,Integer>();
+        for(String str: cpdomains){
+            String[] words = str.trim().split("[ .]+");
+		    int value = Integer.parseInt(words[0]);
+		    String domain = "";
+            for(int i = words.length-1;i>0;i--){
+                domain = words[i] + domain;
+                map.put(domain, map.getOrDefault(domain,0)+value);
+                domain = "." + domain;
+            }
+        }
+        List<String> list = new ArrayList<String>(map.size());
+        for (Map.Entry<String, Integer> set : map.entrySet()) {
+            list.add(Integer.toString(set.getValue())+ " "+ set.getKey());
+        }
+        return list;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/sum-of-digits-of-string-after-convert/README.md b/leetcode/leetcode/sum-of-digits-of-string-after-convert/README.md
new file mode 100644
index 0000000..6db8fca
--- /dev/null
+++ b/leetcode/leetcode/sum-of-digits-of-string-after-convert/README.md
@@ -0,0 +1,51 @@
+<h2>1945. Sum of Digits of String After Convert</h2><h3>Easy</h3><hr><div><p>You are given a string <code>s</code> consisting of lowercase English letters, and an integer <code>k</code>.</p>
+
+<p>First, <strong>convert</strong> <code>s</code> into an integer by replacing each letter with its position in the alphabet (i.e., replace <code>'a'</code> with <code>1</code>, <code>'b'</code> with <code>2</code>, ..., <code>'z'</code> with <code>26</code>). Then, <strong>transform</strong> the integer by replacing it with the <strong>sum of its digits</strong>. Repeat the <strong>transform</strong> operation <code>k</code><strong> times</strong> in total.</p>
+
+<p>For example, if <code>s = "zbax"</code> and <code>k = 2</code>, then the resulting integer would be <code>8</code> by the following operations:</p>
+
+<ul>
+	<li><strong>Convert</strong>: <code>"zbax" ➝ "(26)(2)(1)(24)" ➝ "262124" ➝ 262124</code></li>
+	<li><strong>Transform #1</strong>: <code>262124 ➝ 2 + 6 + 2 + 1 + 2 + 4&nbsp;➝ 17</code></li>
+	<li><strong>Transform #2</strong>: <code>17 ➝ 1 + 7 ➝ 8</code></li>
+</ul>
+
+<p>Return <em>the resulting integer after performing the operations described above</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "iiii", k = 1
+<strong>Output:</strong> 36
+<strong>Explanation:</strong> The operations are as follows:
+- Convert: "iiii" ➝ "(9)(9)(9)(9)" ➝ "9999" ➝ 9999
+- Transform #1: 9999 ➝ 9 + 9 + 9 + 9 ➝ 36
+Thus the resulting integer is 36.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "leetcode", k = 2
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The operations are as follows:
+- Convert: "leetcode" ➝ "(12)(5)(5)(20)(3)(15)(4)(5)" ➝ "12552031545" ➝ 12552031545
+- Transform #1: 12552031545 ➝ 1 + 2 + 5 + 5 + 2 + 0 + 3 + 1 + 5 + 4 + 5 ➝ 33
+- Transform #2: 33 ➝ 3 + 3 ➝ 6
+Thus the resulting integer is 6.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "zbax", k = 2
+<strong>Output:</strong> 8
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 100</code></li>
+	<li><code>1 &lt;= k &lt;= 10</code></li>
+	<li><code>s</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/sum-of-digits-of-string-after-convert/sum-of-digits-of-string-after-convert.java b/leetcode/leetcode/sum-of-digits-of-string-after-convert/sum-of-digits-of-string-after-convert.java
new file mode 100644
index 0000000..2bc639c
--- /dev/null
+++ b/leetcode/leetcode/sum-of-digits-of-string-after-convert/sum-of-digits-of-string-after-convert.java
@@ -0,0 +1,35 @@
+class Solution {
+    
+    public int transform(int num, int k){
+        if(k==0){
+            return num;
+        } 
+        int shortResult=0;
+        while(num!=0){
+            shortResult += num%10;
+            num/=10;
+        }
+        return transform(shortResult,k-1);
+        
+    }
+    
+    public int getLucky(String s, int k) {
+        int sum = 0;
+        int temp;
+        for(int i = 0; i<s.length();i++){
+            temp = (int) s.charAt(i) - 96;
+            if(temp<10){
+                sum = sum + temp;
+            } else{
+                while(temp!=0){
+                    sum = sum + temp%10;
+                    temp/=10;
+                }
+            }
+        }
+        if(k==1){
+            return sum;
+        }
+        return transform(sum,k-1);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/sum-of-left-leaves/README.md b/leetcode/leetcode/sum-of-left-leaves/README.md
new file mode 100644
index 0000000..b9e7ba5
--- /dev/null
+++ b/leetcode/leetcode/sum-of-left-leaves/README.md
@@ -0,0 +1,24 @@
+<h2>404. Sum of Left Leaves</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary tree, return the sum of all left leaves.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/04/08/leftsum-tree.jpg" style="width: 277px; height: 302px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> 24
+<strong>Explanation:</strong> There are two left leaves in the binary tree, with values 9 and 15 respectively.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 1000]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/sum-of-left-leaves/sum-of-left-leaves.java b/leetcode/leetcode/sum-of-left-leaves/sum-of-left-leaves.java
new file mode 100644
index 0000000..7776556
--- /dev/null
+++ b/leetcode/leetcode/sum-of-left-leaves/sum-of-left-leaves.java
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int sumOfLeftLeaves(TreeNode root) {
+        if(root == null) return 0;
+        int sum = 0;
+        if(root.left!=null && root.left.left==null && root.left.right == null ) sum+=root.left.val;
+        sum+=sumOfLeftLeaves(root.right);
+        sum+=sumOfLeftLeaves(root.left);
+        return sum;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/sum-of-nodes-with-even-valued-grandparent/README.md b/leetcode/leetcode/sum-of-nodes-with-even-valued-grandparent/README.md
new file mode 100644
index 0000000..820f3ad
--- /dev/null
+++ b/leetcode/leetcode/sum-of-nodes-with-even-valued-grandparent/README.md
@@ -0,0 +1,26 @@
+<h2>1315. Sum of Nodes with Even-Valued Grandparent</h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, return <em>the sum of values of nodes with an <strong>even-valued grandparent</strong></em>. If there are no nodes with an <strong>even-valued grandparent</strong>, return <code>0</code>.</p>
+
+<p>A <strong>grandparent</strong> of a node is the parent of its parent if it exists.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/even1-tree.jpg" style="width: 504px; height: 302px;">
+<pre><strong>Input:</strong> root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
+<strong>Output:</strong> 18
+<strong>Explanation:</strong> The red nodes are the nodes with even-value grandparent while the blue nodes are the even-value grandparents.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/even2-tree.jpg" style="width: 64px; height: 65px;">
+<pre><strong>Input:</strong> root = [1]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/sum-of-nodes-with-even-valued-grandparent/sum-of-nodes-with-even-valued-grandparent.java b/leetcode/leetcode/sum-of-nodes-with-even-valued-grandparent/sum-of-nodes-with-even-valued-grandparent.java
new file mode 100644
index 0000000..14d6d23
--- /dev/null
+++ b/leetcode/leetcode/sum-of-nodes-with-even-valued-grandparent/sum-of-nodes-with-even-valued-grandparent.java
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int childSum(TreeNode root){
+        if(root == null){
+            return 0;
+        }
+        int ans = 0;
+        if(root.left != null){
+            ans+=root.left.val;
+        }
+        if(root.right != null){
+            ans+= root.right.val;
+        }
+        return ans;
+    }
+    public int sumEvenGrandparent(TreeNode root) {
+        if(root==null){
+            return 0;
+        }
+        int ans = 0;
+        if(root.val%2==0){
+            ans += childSum(root.left);
+            ans += childSum(root.right);
+        }
+        return ans + sumEvenGrandparent(root.left) + sumEvenGrandparent(root.right);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/sum-of-unique-elements/README.md b/leetcode/leetcode/sum-of-unique-elements/README.md
new file mode 100644
index 0000000..a6cf0b8
--- /dev/null
+++ b/leetcode/leetcode/sum-of-unique-elements/README.md
@@ -0,0 +1,34 @@
+<h2>1748. Sum of Unique Elements</h2><h3>Easy</h3><hr><div><p>You are given an integer array <code>nums</code>. The unique elements of an array are the elements that appear <strong>exactly once</strong> in the array.</p>
+
+<p>Return <em>the <strong>sum</strong> of all the unique elements of </em><code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,2]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The unique elements are [1,3], and the sum is 4.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,1,1,1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There are no unique elements, and the sum is 0.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,5]
+<strong>Output:</strong> 15
+<strong>Explanation:</strong> The unique elements are [1,2,3,4,5], and the sum is 15.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/sum-of-unique-elements/sum-of-unique-elements.java b/leetcode/leetcode/sum-of-unique-elements/sum-of-unique-elements.java
new file mode 100644
index 0000000..c39388f
--- /dev/null
+++ b/leetcode/leetcode/sum-of-unique-elements/sum-of-unique-elements.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int sumOfUnique(int[] nums) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: nums) {
+            if(map.containsKey(num)){
+                map.put(num,map.get(num)+1);
+            }else{
+                map.put(num,1);
+            }
+        }
+        int sum = 0;
+        for(int num: map.keySet()){
+            if(map.get(num)==1) sum+=num;
+        }
+        return sum;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/swap-nodes-in-pairs/README.md b/leetcode/leetcode/swap-nodes-in-pairs/README.md
new file mode 100644
index 0000000..84386d3
--- /dev/null
+++ b/leetcode/leetcode/swap-nodes-in-pairs/README.md
@@ -0,0 +1,29 @@
+<h2>24. Swap Nodes in Pairs</h2><h3>Medium</h3><hr><div><p>Given a&nbsp;linked list, swap every two adjacent nodes and return its head. You must solve the problem without&nbsp;modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg" style="width: 422px; height: 222px;">
+<pre><strong>Input:</strong> head = [1,2,3,4]
+<strong>Output:</strong> [2,1,4,3]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the&nbsp;list&nbsp;is in the range <code>[0, 100]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/swap-nodes-in-pairs/swap-nodes-in-pairs.java b/leetcode/leetcode/swap-nodes-in-pairs/swap-nodes-in-pairs.java
new file mode 100644
index 0000000..54816f0
--- /dev/null
+++ b/leetcode/leetcode/swap-nodes-in-pairs/swap-nodes-in-pairs.java
@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    
+    public ListNode swapPairs(ListNode head) {
+        if(head==null || head.next == null) return head;
+        ListNode l1 = head;
+        ListNode l2 = head.next;
+        ListNode prev = null;
+        head = l2;
+        while(l1!=null && l2!=null){
+            l1.next = l2.next;
+            l2.next = l1;
+            prev = l1;
+            l1 = l1.next;
+            if(l1 == null || l1.next == null) break;
+            l2 = l1.next;
+            prev.next = l2;
+        }
+        return head;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/swapping-nodes-in-a-linked-list/README.md b/leetcode/leetcode/swapping-nodes-in-a-linked-list/README.md
new file mode 100644
index 0000000..8ee1b4f
--- /dev/null
+++ b/leetcode/leetcode/swapping-nodes-in-a-linked-list/README.md
@@ -0,0 +1,44 @@
+<h2>1721. Swapping Nodes in a Linked List</h2><h3>Medium</h3><hr><div><p>You are given the <code>head</code> of a linked list, and an integer <code>k</code>.</p>
+
+<p>Return <em>the head of the linked list after <strong>swapping</strong> the values of the </em><code>k<sup>th</sup></code> <em>node from the beginning and the </em><code>k<sup>th</sup></code> <em>node from the end (the list is <strong>1-indexed</strong>).</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/21/linked1.jpg" style="width: 722px; height: 202px;">
+<pre><strong>Input:</strong> head = [1,2,3,4,5], k = 2
+<strong>Output:</strong> [1,4,3,2,5]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [7,9,6,6,7,8,3,0,9,5], k = 5
+<strong>Output:</strong> [7,9,6,6,8,7,3,0,9,5]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1], k = 1
+<strong>Output:</strong> [1]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,2], k = 1
+<strong>Output:</strong> [2,1]
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,2,3], k = 2
+<strong>Output:</strong> [1,2,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list is <code>n</code>.</li>
+	<li><code>1 &lt;= k &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/swapping-nodes-in-a-linked-list/swapping-nodes-in-a-linked-list.java b/leetcode/leetcode/swapping-nodes-in-a-linked-list/swapping-nodes-in-a-linked-list.java
new file mode 100644
index 0000000..3bb4d21
--- /dev/null
+++ b/leetcode/leetcode/swapping-nodes-in-a-linked-list/swapping-nodes-in-a-linked-list.java
@@ -0,0 +1,41 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode swapNodes(ListNode head, int k) {
+        ListNode temp = head;
+        int len = 0;
+        int main1 = 0;
+        while(temp!=null){
+            if(len==k-1){
+                main1 = temp.val;
+            }
+            temp = temp.next;
+            len++;
+        }
+        int counter = 0;
+        temp = head;
+        while(counter!=len-k){
+            temp = temp.next;
+            counter++;
+        }
+        int val2 = temp.val;
+        temp.val = main1;
+        counter=0;
+        temp = head;
+        while(counter<k-1){
+            temp = temp.next;
+            counter++;
+        }
+        temp.val = val2;
+        return head;
+        
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/the-kth-factor-of-n/README.md b/leetcode/leetcode/the-kth-factor-of-n/README.md
new file mode 100644
index 0000000..5a04d48
--- /dev/null
+++ b/leetcode/leetcode/the-kth-factor-of-n/README.md
@@ -0,0 +1,48 @@
+<h2>1492. The kth Factor of n</h2><h3>Medium</h3><hr><div><p>Given two positive integers <code>n</code> and <code>k</code>.</p>
+
+<p>A factor of an integer <code>n</code> is defined as an integer <code>i</code> where <code>n % i == 0</code>.</p>
+
+<p>Consider a list of all factors of <code>n</code>&nbsp;sorted in <strong>ascending order</strong>, return <em>the </em><code>kth</code><em> factor</em> in this list or return <strong>-1</strong> if <code>n</code> has less than&nbsp;<code>k</code> factors.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 12, k = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Factors list is [1, 2, 3, 4, 6, 12], the 3rd factor is 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 7, k = 2
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Factors list is [1, 7], the 2nd factor is 7.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 4, k = 4
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> Factors list is [1, 2, 4], there is only 3 factors. We should return -1.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> n = 1, k = 1
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> Factors list is [1], the 1st factor is 1.
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> n = 1000, k = 3
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Factors list is [1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 125, 200, 250, 500, 1000].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= n &lt;= 1000</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/the-kth-factor-of-n/the-kth-factor-of-n.java b/leetcode/leetcode/the-kth-factor-of-n/the-kth-factor-of-n.java
new file mode 100644
index 0000000..276f79b
--- /dev/null
+++ b/leetcode/leetcode/the-kth-factor-of-n/the-kth-factor-of-n.java
@@ -0,0 +1,10 @@
+class Solution {
+    public int kthFactor(int n, int k) {
+        for(int i = 1;i<=n;i++){
+            if(n%i==0 && --k==0){
+               return i;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/leetcode/leetcode/time-needed-to-buy-tickets/README.md b/leetcode/leetcode/time-needed-to-buy-tickets/README.md
new file mode 100644
index 0000000..52afe12
--- /dev/null
+++ b/leetcode/leetcode/time-needed-to-buy-tickets/README.md
@@ -0,0 +1,39 @@
+<h2>2073. Time Needed to Buy Tickets</h2><h3>Easy</h3><hr><div><p>There are <code>n</code> people in a line queuing to buy tickets, where the <code>0<sup>th</sup></code> person is at the <strong>front</strong> of the line and the <code>(n - 1)<sup>th</sup></code> person is at the <strong>back</strong> of the line.</p>
+
+<p>You are given a <strong>0-indexed</strong> integer array <code>tickets</code> of length <code>n</code> where the number of tickets that the <code>i<sup>th</sup></code> person would like to buy is <code>tickets[i]</code>.</p>
+
+<p>Each person takes <strong>exactly 1 second</strong> to buy a ticket. A person can only buy <strong>1 ticket at a time</strong> and has to go back to <strong>the end</strong> of the line (which happens <strong>instantaneously</strong>) in order to buy more tickets. If a person does not have any tickets left to buy, the person will <strong>leave </strong>the line.</p>
+
+<p>Return <em>the <strong>time taken</strong> for the person at position </em><code>k</code><em>&nbsp;</em><strong><em>(0-indexed)</em>&nbsp;</strong><em>to finish buying tickets</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> tickets = [2,3,2], k = 2
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> 
+- In the first pass, everyone in the line buys a ticket and the line becomes [1, 2, 1].
+- In the second pass, everyone in the line buys a ticket and the line becomes [0, 1, 0].
+The person at&nbsp;position 2 has successfully bought 2 tickets and it took 3 + 3 = 6 seconds.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> tickets = [5,1,1,1], k = 0
+<strong>Output:</strong> 8
+<strong>Explanation:</strong>
+- In the first pass, everyone in the line buys a ticket and the line becomes [4, 0, 0, 0].
+- In the next 4 passes, only the person in position 0 is buying tickets.
+The person at&nbsp;position 0 has successfully bought 5 tickets and it took 4 + 1 + 1 + 1 + 1 = 8 seconds.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == tickets.length</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>1 &lt;= tickets[i] &lt;= 100</code></li>
+	<li><code>0 &lt;= k &lt; n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/time-needed-to-buy-tickets/time-needed-to-buy-tickets.java b/leetcode/leetcode/time-needed-to-buy-tickets/time-needed-to-buy-tickets.java
new file mode 100644
index 0000000..bd8645c
--- /dev/null
+++ b/leetcode/leetcode/time-needed-to-buy-tickets/time-needed-to-buy-tickets.java
@@ -0,0 +1,16 @@
+class Solution {
+    public int timeRequiredToBuy(int[] tickets, int k) {
+        int counter = 0;
+        int maincounter =0;
+        int size = tickets.length;
+        while(tickets[k]!=0){
+            if(tickets[maincounter]!=0){
+                tickets[maincounter]--;
+                counter++;
+            }
+            maincounter++;
+            maincounter= maincounter%size;
+        }
+        return counter;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/truncate-sentence/README.md b/leetcode/leetcode/truncate-sentence/README.md
new file mode 100644
index 0000000..9890e71
--- /dev/null
+++ b/leetcode/leetcode/truncate-sentence/README.md
@@ -0,0 +1,45 @@
+<h2>1816. Truncate Sentence</h2><h3>Easy</h3><hr><div><p>A <strong>sentence</strong> is a list of words that are separated by a single space with no leading or trailing spaces. Each of the words consists of <strong>only</strong> uppercase and lowercase English letters (no punctuation).</p>
+
+<ul>
+	<li>For example, <code>"Hello World"</code>, <code>"HELLO"</code>, and <code>"hello world hello world"</code> are all sentences.</li>
+</ul>
+
+<p>You are given a sentence <code>s</code>​​​​​​ and an integer <code>k</code>​​​​​​. You want to <strong>truncate</strong> <code>s</code>​​​​​​ such that it contains only the <strong>first</strong> <code>k</code>​​​​​​ words. Return <code>s</code>​​​​<em>​​ after <strong>truncating</strong> it.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "Hello how are you Contestant", k = 4
+<strong>Output:</strong> "Hello how are you"
+<strong>Explanation:</strong>
+The words in s are ["Hello", "how" "are", "you", "Contestant"].
+The first 4 words are ["Hello", "how", "are", "you"].
+Hence, you should return "Hello how are you".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "What is the solution to this problem", k = 4
+<strong>Output:</strong> "What is the solution"
+<strong>Explanation:</strong>
+The words in s are ["What", "is" "the", "solution", "to", "this", "problem"].
+The first 4 words are ["What", "is", "the", "solution"].
+Hence, you should return "What is the solution".</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "chopper is not a tanuki", k = 5
+<strong>Output:</strong> "chopper is not a tanuki"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 500</code></li>
+	<li><code>k</code> is in the range <code>[1, the number of words in s]</code>.</li>
+	<li><code>s</code> consist of only lowercase and uppercase English letters and spaces.</li>
+	<li>The words in <code>s</code> are separated by a single space.</li>
+	<li>There are no leading or trailing spaces.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/truncate-sentence/truncate-sentence.java b/leetcode/leetcode/truncate-sentence/truncate-sentence.java
new file mode 100644
index 0000000..9ea254c
--- /dev/null
+++ b/leetcode/leetcode/truncate-sentence/truncate-sentence.java
@@ -0,0 +1,9 @@
+class Solution {
+    public String truncateSentence(String s, int k) {
+        int i =0;
+        for(i=0;i<s.length() && k!=0;i++){
+            if(s.charAt(i)==' ') --k;
+        }
+        return k==0 ? s.substring(0,i-1) : s.substring(0,i);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/two-sum-ii-input-array-is-sorted/README.md b/leetcode/leetcode/two-sum-ii-input-array-is-sorted/README.md
new file mode 100644
index 0000000..149ad37
--- /dev/null
+++ b/leetcode/leetcode/two-sum-ii-input-array-is-sorted/README.md
@@ -0,0 +1,39 @@
+<h2>167. Two Sum II - Input Array Is Sorted</h2><h3>Easy</h3><hr><div><p>Given a <strong>1-indexed</strong> array of integers <code>numbers</code> that is already <strong><em>sorted in non-decreasing order</em></strong>, find two numbers such that they add up to a specific <code>target</code> number. Let these two numbers be <code>numbers[index<sub>1</sub>]</code> and <code>numbers[index<sub>2</sub>]</code> where <code>1 &lt;= index<sub>1</sub> &lt; index<sub>2</sub> &lt;= numbers.length</code>.</p>
+
+<p>Return<em> the indices of the two numbers, </em><code>index<sub>1</sub></code><em> and </em><code>index<sub>2</sub></code><em>, <strong>added by one</strong> as an integer array </em><code>[index<sub>1</sub>, index<sub>2</sub>]</code><em> of length 2.</em></p>
+
+<p>The tests are generated such that there is <strong>exactly one solution</strong>. You <strong>may not</strong> use the same element twice.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> numbers = [<u>2</u>,<u>7</u>,11,15], target = 9
+<strong>Output:</strong> [1,2]
+<strong>Explanation:</strong> The sum of 2 and 7 is 9. Therefore, index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> numbers = [<u>2</u>,3,<u>4</u>], target = 6
+<strong>Output:</strong> [1,3]
+<strong>Explanation:</strong> The sum of 2 and 4 is 6. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 3. We return [1, 3].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> numbers = [<u>-1</u>,<u>0</u>], target = -1
+<strong>Output:</strong> [1,2]
+<strong>Explanation:</strong> The sum of -1 and 0 is -1. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= numbers.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-1000 &lt;= numbers[i] &lt;= 1000</code></li>
+	<li><code>numbers</code> is sorted in <strong>non-decreasing order</strong>.</li>
+	<li><code>-1000 &lt;= target &lt;= 1000</code></li>
+	<li>The tests are generated such that there is <strong>exactly one solution</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted.java b/leetcode/leetcode/two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted.java
new file mode 100644
index 0000000..282f0de
--- /dev/null
+++ b/leetcode/leetcode/two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted.java
@@ -0,0 +1,26 @@
+class Solution {
+    public int BinarySearch(int[] numbers, int target, int low){
+        int high = numbers.length-1;
+        int mid = (low+high)/2;
+        while(low<=high){
+            mid = (low+high)/2;
+            if(numbers[mid] == target) return mid;
+            if(numbers[mid]>target) high = mid -1;
+            else low = mid+1;
+        
+        }
+        return -1;
+    }
+    public int[] twoSum(int[] numbers, int value) {
+        int[] target = new int[2];
+        for(int i =0;i<numbers.length;i++){
+            int val = BinarySearch(numbers,value-numbers[i], i+1);
+            if(val!=-1){
+                target[0] = i+1;
+                target[1] = val+1;
+                break;
+            }
+        }
+        return target;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/two-sum/README.md b/leetcode/leetcode/two-sum/README.md
new file mode 100644
index 0000000..5dd9f3f
--- /dev/null
+++ b/leetcode/leetcode/two-sum/README.md
@@ -0,0 +1,38 @@
+<h2>1. Two Sum</h2><h3>Easy</h3><hr><div><p>Given an array of integers <code>nums</code>&nbsp;and an integer <code>target</code>, return <em>indices of the two numbers such that they add up to <code>target</code></em>.</p>
+
+<p>You may assume that each input would have <strong><em>exactly</em> one solution</strong>, and you may not use the <em>same</em> element twice.</p>
+
+<p>You can return the answer in any order.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,7,11,15], target = 9
+<strong>Output:</strong> [0,1]
+<strong>Output:</strong> Because nums[0] + nums[1] == 9, we return [0, 1].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,2,4], target = 6
+<strong>Output:</strong> [1,2]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,3], target = 6
+<strong>Output:</strong> [0,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= target &lt;= 10<sup>9</sup></code></li>
+	<li><strong>Only one valid answer exists.</strong></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow-up:&nbsp;</strong>Can you come up with an algorithm that is less than&nbsp;<code>O(n<sup>2</sup>)&nbsp;</code>time complexity?</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/two-sum/two-sum.java b/leetcode/leetcode/two-sum/two-sum.java
new file mode 100644
index 0000000..6359f8b
--- /dev/null
+++ b/leetcode/leetcode/two-sum/two-sum.java
@@ -0,0 +1,15 @@
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        int[] arr = new int[2];
+        for(int i = 0; i<nums.length;i++){
+            if(map.containsKey(target-nums[i])   && !(map.get(target-nums[i]) == i)){
+                arr[0] =i;
+                arr[1] = (int) map.get(target-nums[i]);
+                return arr;
+            }
+            map.put(nums[i],i);
+        }
+        return arr;
+    }
+}
diff --git a/leetcode/leetcode/unique-number-of-occurrences/README.md b/leetcode/leetcode/unique-number-of-occurrences/README.md
new file mode 100644
index 0000000..4a86c72
--- /dev/null
+++ b/leetcode/leetcode/unique-number-of-occurrences/README.md
@@ -0,0 +1,29 @@
+<h2>1207. Unique Number of Occurrences</h2><h3>Easy</h3><hr><div><p>Given an array of integers <code>arr</code>, return <code>true</code> if the number of occurrences of each value in the array is <strong>unique</strong>, or <code>false</code> otherwise.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,2,1,1,3]
+<strong>Output:</strong> true
+<strong>Explanation:</strong>&nbsp;The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [-3,0,1,-3,1,1,1,-3,10,0]
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length&nbsp;&lt;= 1000</code></li>
+	<li><code>-1000 &lt;= arr[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/unique-number-of-occurrences/unique-number-of-occurrences.java b/leetcode/leetcode/unique-number-of-occurrences/unique-number-of-occurrences.java
new file mode 100644
index 0000000..f97bb7c
--- /dev/null
+++ b/leetcode/leetcode/unique-number-of-occurrences/unique-number-of-occurrences.java
@@ -0,0 +1,13 @@
+class Solution {
+    public boolean uniqueOccurrences(int[] arr) {
+        HashMap<Integer,Integer> map = new HashMap<>();
+        for(int num: arr){
+            map.put(num, map.getOrDefault(num,0)+1);
+        }
+        HashSet<Integer> set = new HashSet<>();
+        for (Map.Entry<Integer, Integer> entrySet :map.entrySet()) {
+            set.add(entrySet.getValue());
+        }
+        return map.size() == set.size();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/valid-parentheses/README.md b/leetcode/leetcode/valid-parentheses/README.md
new file mode 100644
index 0000000..53485dc
--- /dev/null
+++ b/leetcode/leetcode/valid-parentheses/README.md
@@ -0,0 +1,48 @@
+<h2>20. Valid Parentheses</h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code> containing just the characters <code>'('</code>, <code>')'</code>, <code>'{'</code>, <code>'}'</code>, <code>'['</code> and <code>']'</code>, determine if the input string is valid.</p>
+
+<p>An input string is valid if:</p>
+
+<ol>
+	<li>Open brackets must be closed by the same type of brackets.</li>
+	<li>Open brackets must be closed in the correct order.</li>
+</ol>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "()"
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "()[]{}"
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "(]"
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> s = "([)]"
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> s = "{[]}"
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>s</code> consists of parentheses only <code>'()[]{}'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/valid-parentheses/valid-parentheses.java b/leetcode/leetcode/valid-parentheses/valid-parentheses.java
new file mode 100644
index 0000000..ef411b1
--- /dev/null
+++ b/leetcode/leetcode/valid-parentheses/valid-parentheses.java
@@ -0,0 +1,21 @@
+class Solution {
+    public boolean isValid(String s) {
+        Stack<Character> s1 = new Stack<>();
+        for(int i = 0;i<s.length();i++){
+            char c = s.charAt(i);
+            if(c == '('){
+                s1.push(')');
+            }else if(c == '{'){
+                s1.push('}');
+            }else if( c=='['){
+                s1.push(']');
+            }
+            else if(!(s1.isEmpty()) && s1.peek()==c){
+                s1.pop();
+            }else{
+                return false;
+            }
+        }
+        return s1.isEmpty();
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/valid-perfect-square/README.md b/leetcode/leetcode/valid-perfect-square/README.md
new file mode 100644
index 0000000..5ff8bb0
--- /dev/null
+++ b/leetcode/leetcode/valid-perfect-square/README.md
@@ -0,0 +1,19 @@
+<h2>367. Valid Perfect Square</h2><h3>Easy</h3><hr><div><p>Given a <strong>positive</strong> integer <i>num</i>, write a function which returns True if <i>num</i> is a perfect square else False.</p>
+
+<p><b>Follow up:</b> <b>Do not</b> use any built-in library function such as <code>sqrt</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> num = 16
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> num = 14
+<strong>Output:</strong> false
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= num &lt;= 2^31 - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/valid-perfect-square/valid-perfect-square.cpp b/leetcode/leetcode/valid-perfect-square/valid-perfect-square.cpp
new file mode 100644
index 0000000..9edb75e
--- /dev/null
+++ b/leetcode/leetcode/valid-perfect-square/valid-perfect-square.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    bool isPerfectSquare(int num) {
+        int left = 1;
+        int right = 100000;
+        while(left<=right){
+            long mid = left + (right-left)/2;
+            if((int)mid*mid==num){
+                return true;
+            }else if((int)mid*mid>num){
+                right = mid -1;
+            }else{
+                left = mid +1;
+            }
+        }
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/leetcode/leetcode/valid-triangle-number/README.md b/leetcode/leetcode/valid-triangle-number/README.md
new file mode 100644
index 0000000..d662112
--- /dev/null
+++ b/leetcode/leetcode/valid-triangle-number/README.md
@@ -0,0 +1,27 @@
+<h2>611. Valid Triangle Number</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, return <em>the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,2,3,4]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Valid combinations are: 
+2,3,4 (using the first 2)
+2,3,4 (using the second 2)
+2,2,3
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [4,2,3,4]
+<strong>Output:</strong> 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/valid-triangle-number/valid-triangle-number.java b/leetcode/leetcode/valid-triangle-number/valid-triangle-number.java
new file mode 100644
index 0000000..cdd7897
--- /dev/null
+++ b/leetcode/leetcode/valid-triangle-number/valid-triangle-number.java
@@ -0,0 +1,21 @@
+class Solution {
+    public int triangleNumber(int[] nums) {
+        if(nums.length<3) return 0;
+        int ans = 0;
+        Arrays.sort(nums);
+        for(int i = 2;i<nums.length;i++){
+            int left = 0;
+            int right = i-1;
+            while(left<right){
+                if(nums[left]+ nums[right]>nums[i]){
+                    ans+=right-left;
+                    right--;
+                }else{
+                left++;
+                }
+                
+            }
+        }
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/validate-binary-search-tree/README.md b/leetcode/leetcode/validate-binary-search-tree/README.md
new file mode 100644
index 0000000..3e6f61c
--- /dev/null
+++ b/leetcode/leetcode/validate-binary-search-tree/README.md
@@ -0,0 +1,32 @@
+<h2>98. Validate Binary Search Tree</h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree, <em>determine if it is a valid binary search tree (BST)</em>.</p>
+
+<p>A <strong>valid BST</strong> is defined as follows:</p>
+
+<ul>
+	<li>The left subtree of a node contains only nodes with keys <strong>less than</strong> the node's key.</li>
+	<li>The right subtree of a node contains only nodes with keys <strong>greater than</strong> the node's key.</li>
+	<li>Both the left and right subtrees must also be binary search trees.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/01/tree1.jpg" style="width: 302px; height: 182px;">
+<pre><strong>Input:</strong> root = [2,1,3]
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/01/tree2.jpg" style="width: 422px; height: 292px;">
+<pre><strong>Input:</strong> root = [5,1,4,null,null,3,6]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The root node's value is 5 but its right child's value is 4.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-2<sup>31</sup> &lt;= Node.val &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/validate-binary-search-tree/validate-binary-search-tree.java b/leetcode/leetcode/validate-binary-search-tree/validate-binary-search-tree.java
new file mode 100644
index 0000000..bd8d1dc
--- /dev/null
+++ b/leetcode/leetcode/validate-binary-search-tree/validate-binary-search-tree.java
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    
+    public boolean isBST(TreeNode root, Integer min, Integer max){
+        if(root==null) return true;
+        if ((min != null && root.val <= min) || (max != null && root.val >= max)) {
+            return false;
+        }
+        return (isBST(root.left, min, root.val) && isBST(root.right, root.val, max));
+    }
+    
+    public boolean isValidBST(TreeNode root) {
+        return isBST(root, null, null);
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/water-bottles/README.md b/leetcode/leetcode/water-bottles/README.md
new file mode 100644
index 0000000..8c775d5
--- /dev/null
+++ b/leetcode/leetcode/water-bottles/README.md
@@ -0,0 +1,46 @@
+<h2>1518. Water Bottles</h2><h3>Easy</h3><hr><div><p>Given <code>numBottles</code>&nbsp;full water bottles, you can exchange <code>numExchange</code> empty water bottles for one full water bottle.</p>
+
+<p>The operation of drinking a full water bottle turns it into an empty bottle.</p>
+
+<p>Return the <strong>maximum</strong> number of water bottles you can&nbsp;drink.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2020/07/01/sample_1_1875.png" style="width: 480px; height: 240px;"></strong></p>
+
+<pre><strong>Input:</strong> numBottles = 9, numExchange = 3
+<strong>Output:</strong> 13
+<strong>Explanation:</strong> You can exchange 3 empty bottles to get 1 full water bottle.
+Number of water bottles you can&nbsp;drink: 9 + 3 + 1 = 13.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2020/07/01/sample_2_1875.png" style="width: 790px; height: 290px;"></p>
+
+<pre><strong>Input:</strong> numBottles = 15, numExchange = 4
+<strong>Output:</strong> 19
+<strong>Explanation:</strong> You can exchange 4 empty bottles to get 1 full water bottle. 
+Number of water bottles you can&nbsp;drink: 15 + 3 + 1 = 19.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> numBottles = 5, numExchange = 5
+<strong>Output:</strong> 6
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> numBottles = 2, numExchange = 3
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;=&nbsp;numBottles &lt;= 100</code></li>
+	<li><code>2 &lt;=&nbsp;numExchange &lt;= 100</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/leetcode/leetcode/water-bottles/water-bottles.java b/leetcode/leetcode/water-bottles/water-bottles.java
new file mode 100644
index 0000000..59e6822
--- /dev/null
+++ b/leetcode/leetcode/water-bottles/water-bottles.java
@@ -0,0 +1,12 @@
+class Solution {
+    public int numWaterBottles(int numBottles, int numExchange) {
+        int res = numBottles;
+        while (numBottles >= numExchange) {
+            int rem = numBottles % numExchange;
+            numBottles /= numExchange;
+            res += numBottles;
+            numBottles += rem;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/leetcode/leetcode/watering-plants/README.md b/leetcode/leetcode/watering-plants/README.md
new file mode 100644
index 0000000..4c4c7ab
--- /dev/null
+++ b/leetcode/leetcode/watering-plants/README.md
@@ -0,0 +1,59 @@
+<h2>2079. Watering Plants</h2><h3>Medium</h3><hr><div><p>You want to water <code>n</code> plants in your garden with a watering can. The plants are arranged in a row and are labeled from <code>0</code> to <code>n - 1</code> from left to right where the <code>i<sup>th</sup></code> plant is located at <code>x = i</code>. There is a river at <code>x = -1</code> that you can refill your watering can at.</p>
+
+<p>Each plant needs a specific amount of water. You will water the plants in the following way:</p>
+
+<ul>
+	<li>Water the plants in order from left to right.</li>
+	<li>After watering the current plant, if you do not have enough water to <strong>completely</strong> water the next plant, return to the river to fully refill the watering can.</li>
+	<li>You <strong>cannot</strong> refill the watering can early.</li>
+</ul>
+
+<p>You are initially at the river (i.e., <code>x = -1</code>). It takes <strong>one step</strong> to move <strong>one unit</strong> on the x-axis.</p>
+
+<p>Given a <strong>0-indexed</strong> integer array <code>plants</code> of <code>n</code> integers, where <code>plants[i]</code> is the amount of water the <code>i<sup>th</sup></code> plant needs, and an integer <code>capacity</code> representing the watering can capacity, return <em>the <strong>number of steps</strong> needed to water all the plants</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> plants = [2,2,3,3], capacity = 5
+<strong>Output:</strong> 14
+<strong>Explanation:</strong> Start at the river with a full watering can:
+- Walk to plant 0 (1 step) and water it. Watering can has 3 units of water.
+- Walk to plant 1 (1 step) and water it. Watering can has 1 unit of water.
+- Since you cannot completely water plant 2, walk back to the river to refill (2 steps).
+- Walk to plant 2 (3 steps) and water it. Watering can has 2 units of water.
+- Since you cannot completely water plant 3, walk back to the river to refill (3 steps).
+- Walk to plant 3 (4 steps) and water it.
+Steps needed = 1 + 1 + 2 + 3 + 3 + 4 = 14.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> plants = [1,1,1,4,2,3], capacity = 4
+<strong>Output:</strong> 30
+<strong>Explanation:</strong> Start at the river with a full watering can:
+- Water plants 0, 1, and 2 (3 steps). Return to river (3 steps).
+- Water plant 3 (4 steps). Return to river (4 steps).
+- Water plant 4 (5 steps). Return to river (5 steps).
+- Water plant 5 (6 steps).
+Steps needed = 3 + 3 + 4 + 4 + 5 + 5 + 6 = 30.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> plants = [7,7,7,7,7,7,7], capacity = 8
+<strong>Output:</strong> 49
+<strong>Explanation:</strong> You have to refill before watering each plant.
+Steps needed = 1 + 1 + 2 + 2 + 3 + 3 + 4 + 4 + 5 + 5 + 6 + 6 + 7 = 49.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == plants.length</code></li>
+	<li><code>1 &lt;= n &lt;= 1000</code></li>
+	<li><code>1 &lt;= plants[i] &lt;= 10<sup>6</sup></code></li>
+	<li><code>max(plants[i]) &lt;= capacity &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/leetcode/leetcode/watering-plants/watering-plants.java b/leetcode/leetcode/watering-plants/watering-plants.java
new file mode 100644
index 0000000..a3caa1c
--- /dev/null
+++ b/leetcode/leetcode/watering-plants/watering-plants.java
@@ -0,0 +1,19 @@
+class Solution {
+    public int wateringPlants(int[] plants, int capacity) {
+        int steps = 0;
+        int max = capacity; 
+        for(int i =0;i<plants.length;i++){
+            if(capacity>=plants[i]){
+                capacity-=plants[i];
+                plants[i] = 0;
+                steps++;
+                
+            }else{
+                steps+=(2*i);
+                capacity = max;
+                --i;
+            }
+        }
+        return steps;
+    }
+}
\ No newline at end of file

From db52c50ba61a4a99ac70f64c48d9a2b81fe889df Mon Sep 17 00:00:00 2001
From: Dev Nirwal <devnirwal@Newtons-MacBook-Pro-2.local>
Date: Mon, 27 Oct 2025 11:29:08 +0530
Subject: [PATCH 2/2] Added 500+ leetcode solutions

---
 leetcode/leetcode/stats.json | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 leetcode/leetcode/stats.json

diff --git a/leetcode/leetcode/stats.json b/leetcode/leetcode/stats.json
new file mode 100644
index 0000000..cfa5cea
--- /dev/null
+++ b/leetcode/leetcode/stats.json
@@ -0,0 +1 @@
+{"leetcode":{"easy":59,"hard":17,"medium":132,"shas":{"0153-find-minimum-in-rotated-sorted-array":{"0153-find-minimum-in-rotated-sorted-array.py":"1ef4ae6fc6f57c5b662ca1747d9a371c45d5fe6b","README.md":"600ad5a169903c578c661c0f571748dc2de102e8","difficulty":"medium","0153-find-minimum-in-rotated-sorted-array.java":"0566f124deb94210f5e99ed7ddcbe55ffa20bcb0"},"README.md":{"":"32c03197ed19f0c6b8e4ea349903348518858143"},"0073-set-matrix-zeroes":{"0073-set-matrix-zeroes.java":"e8102c5657e8759b968ec00e9a356f2a96a882e8","README.md":"090588bf90298b1411926a692aced8baab5f5ff3","difficulty":"medium"},"stats.json":{"":"9589dc4907fbba92b10d3a1b8caf4ebb1b3b2e2e"},"0118-pascals-triangle":{"0118-pascals-triangle.java":"c8862bdceefee5bfecde55f81ec0029ba509fce9","README.md":"549ce276ec0d25402deff66cf41209e7589d123d","difficulty":"easy"},"0053-maximum-subarray":{"0053-maximum-subarray.java":"6339ed2d4963f50fb868e320280a57fc279885f8","README.md":"d5a3ebbc32f90c704f218540f37b5cba9883d539","difficulty":"medium"},"0075-sort-colors":{"0075-sort-colors.java":"153dbc2b2c5a30fabc2de9f591e877deacb66b6e","README.md":"4288266adf023c7d18a4eb5453cbc9287eae800a","difficulty":"medium"},"0543-diameter-of-binary-tree":{"0543-diameter-of-binary-tree.java":"1ef75e7456afd96b7eec6ad6aa98184370205cfe","README.md":"5ef438e39aa6f6497073598c4bd2c8274ababac7","difficulty":"easy"},"0048-rotate-image":{"0048-rotate-image.java":"f3c698cd02df0c0b7b7d5ce6d8ddbc5664ee64c1","README.md":"d88ff8b52f32909a218264b3487fc6d24d6821bf","difficulty":"medium"},"0088-merge-sorted-array":{"0088-merge-sorted-array.java":"678d90124cddd73971fff1c2e1703ecc9394c932","README.md":"50730b6007ef4a20d99d504582778d3b2a0d4774","difficulty":"easy"},"0287-find-the-duplicate-number":{"0287-find-the-duplicate-number.java":"8decd490df74bff894f8f5b44e0acd3340699003","README.md":"ba4e8560f5387b44482fb9f9ab2e51194d9ccffc","difficulty":"medium"},"0050-powx-n":{"0050-powx-n.java":"c9880d0c316f47478d019f4bf357bc732c45eaf5","README.md":"0e37c798735e04506df424847346f2955d3126fc","difficulty":"medium"},"0169-majority-element":{"README.md":"641edd368211891c146ad332f04dbe89234d2a11"},"0229-majority-element-ii":{"0229-majority-element-ii.java":"d513056741da9a69783ada2e906f5ecbbe9cb338","README.md":"91109a276e79a04ef0263e9ccb06c6f9275ffed7","difficulty":"medium"},"0062-unique-paths":{"0062-unique-paths.java":"ea02adde09ac8c52b47aaaa741c4829e071a8ffc","README.md":"b676820715691b3472b9749889dbf60309e0f260","difficulty":"medium"},"0001-two-sum":{"0001-two-sum.java":"c7bc327f9655a86d6648ac811504ee162ddd1435","README.md":"295832280eacc9b202138f15adc074a9cb24c66f","difficulty":"easy","0001-two-sum.cpp":"43cb7b73567c2c1cb546f61428d4db16a5282b1f"},"0167-two-sum-ii-input-array-is-sorted":{"0167-two-sum-ii-input-array-is-sorted.java":"fa7180950ccac38db76d2b4241a9f0c8d616c345","README.md":"9cace0eb3d59e65c56c0e1a9c379e190b2a25941","difficulty":"medium"},"0937-online-stock-span":{"0937-online-stock-span.java":"4147826aae4c015300754692f63a6c0d2545247d","README.md":"3fcfbc7558179852614eb7d64e2345fb1c0505c8","difficulty":"medium"},"0152-maximum-product-subarray":{"0152-maximum-product-subarray.java":"5d0d38d925c371fa99be75d128ec821d9c02a270","README.md":"40a85749395739828873eb1717439c1894fd6db9","difficulty":"medium"},"0337-house-robber-iii":{"0337-house-robber-iii.java":"4258c1568aa337e24f9f2f86f2aebe7798d89403","README.md":"e63c52a313917818f8d9ffe177841177d5878c84","difficulty":"medium"},"0201-bitwise-and-of-numbers-range":{"0201-bitwise-and-of-numbers-range.java":"dd79d09ed561d881b7461fb75ad90961ead7c748","README.md":"e55e5e503658eac75ba088a17c9bbcc7652e6138","difficulty":"medium"},"0200-number-of-islands":{"README.md":"42a12c0fca41e0bf0eaafabd16b28121853b36ce","difficulty":"medium"},"0820-find-eventual-safe-states":{"0820-find-eventual-safe-states.java":"0f2aa803e173e127a0f8a9c2e88860e3a0fe01e4","README.md":"59c3927e21eee9572ac3d67a2fbf75be891e9107","difficulty":"medium"},"1983-maximum-population-year":{"1983-maximum-population-year.java":"d0096d3163e3762c9bab1db608b33b25f5b6884a","README.md":"9d8dfcf36915a096fde87cf40f937ed30c185785","difficulty":"easy"},"3398-make-a-square-with-the-same-color":{"3398-make-a-square-with-the-same-color.java":"4c9a198ac2ad0ac6e65ab8a6bc5a83bafbd77b8f","README.md":"bf5e00fc4b8bab6cf2b50c283abd555fbf97bdd9","difficulty":"easy"},"0143-reorder-list":{"0143-reorder-list.java":"f366c3be842484ebc80a041adbe3a5784aebeff4","README.md":"de26a460feba4d30abca8e824de627cb9f32e2a1","difficulty":"medium"},"0268-missing-number":{"0268-missing-number.java":"8551ad2e23cbd53cf29582a295db836a1365e240","README.md":"9910f8217471fa2e735e371c3915f20715734ac2","difficulty":"easy"},"0039-combination-sum":{"0039-combination-sum.java":"3bc42442bbbba425e48312bbf61eabbfebb7c07b","README.md":"241b5cec663c0994bf628428fcf6a8d5eddcc4f2","difficulty":"medium","0039-combination-sum.py":"7d6bf25009cbe803c7aa400943062df3832dada1"},"0021-merge-two-sorted-lists":{"0021-merge-two-sorted-lists.java":"d46406274a9d418679d342be7e5fc63b861f5ff9","README.md":"859aec2842f4b0ee5bcbc96fb86ed1988c287b12","difficulty":"easy"},"0049-group-anagrams":{"0049-group-anagrams.java":"42b57e07b9387a6891fa8e81597ed758c5441f11","README.md":"9d4e57a1660ecf3ab6088a2b5784c68ccf5ddbcf","difficulty":"medium"},"0374-guess-number-higher-or-lower":{"0374-guess-number-higher-or-lower.java":"b673d23038aa93acb7c90dd6188fe71afb15a182","README.md":"3dd24cd2b0da68d3653c0d369eb622e41175926b","difficulty":"easy"},"0102-binary-tree-level-order-traversal":{"0102-binary-tree-level-order-traversal.java":"5ffcc1881b551d99f662ab24c68de1d5415ab506","README.md":"01b65fdfcb1f1937ab9e22e5e3338d581c1423eb"},"3372-longest-strictly-increasing-or-strictly-decreasing-subarray":{"3372-longest-strictly-increasing-or-strictly-decreasing-subarray.java":"17b46b511a69a4b416ec23d0e57f8a00d363e219","README.md":"4f3835279e633060c530aa5cb2bca56ec8035dc3","difficulty":"easy"},"2448-count-number-of-bad-pairs":{"2448-count-number-of-bad-pairs.java":"c95cb40d5d43b9f92d50f1cc9b07ba45e187f1a5","README.md":"83d0ed4c7dfcf97d08917577333c7e30f2b0d6ce","difficulty":"medium"},"3447-clear-digits":{"3447-clear-digits.java":"a74c30618ffa8289982029f70b30ad10f130071c","README.md":"8642a98cf9e2794a3d2983324a86db1a8c01393d","difficulty":"easy"},"2021-remove-all-occurrences-of-a-substring":{"2021-remove-all-occurrences-of-a-substring.java":"7b5dfc5b9f81c9bbe98271ea6aef439849ca8c8a","README.md":"05d9e853a43416e8acbdd9fe1ffddcd4842162d0","difficulty":"medium"},"3332-minimum-operations-to-exceed-threshold-value-ii":{"3332-minimum-operations-to-exceed-threshold-value-ii.java":"c8b32f26b0215fddd329de8ede12a196db8d5346","README.md":"7c223db3548c23f8596939f028244ccdf6c1a83a","difficulty":"medium"},"2107-find-unique-binary-string":{"2107-find-unique-binary-string.java":"287e71627acd0fcf7deec470a9394c111a38237b","README.md":"b0b6e304f8d6bd3ff908e232d68c40f89ee7c9cd","difficulty":"medium"},"1387-find-elements-in-a-contaminated-binary-tree":{"1387-find-elements-in-a-contaminated-binary-tree.java":"5ddc5e06a03cf72c71bfd4ec6868990c4fbf4ad7","README.md":"7980583be6ecef53867f4c3e06018b1486896daa","difficulty":"medium"},"3541-report-spam-message":{"3541-report-spam-message.java":"4959f123831b029ac8496bcf9981101419bbfec9","README.md":"a7b30cbf15657a5fb42e885619efaa00638fac49","difficulty":"medium"},"1050-construct-binary-search-tree-from-preorder-traversal":{"1050-construct-binary-search-tree-from-preorder-traversal.java":"6e1421603b42744b9e6c1675e2fefe759e3b427b","README.md":"d3d0510158f3b554d706e2b6674e4319ccf054f0","difficulty":"medium"},"1093-recover-a-tree-from-preorder-traversal":{"1093-recover-a-tree-from-preorder-traversal.java":"e2472fa659b840f2b8443b95ffe3ddeb6b4959b2","README.md":"b70ae544747eef7effda85e53eeef3f8a9d5e9b1","difficulty":"hard"},"0925-construct-binary-tree-from-preorder-and-postorder-traversal":{"0925-construct-binary-tree-from-preorder-and-postorder-traversal.java":"ba05daaf00406aff4f61ebcb2eeb58f78521e292","README.md":"be31bf390a70467103dd25c4054df5dcb6e1bfb3","difficulty":"medium"},"0503-next-greater-element-ii":{"0503-next-greater-element-ii.java":"045903daf0ef78cf90684022a1abd613796d47c3","README.md":"9d0f8b6842483c06482bc71f887f06f4e524ea02","difficulty":"medium"},"0954-maximum-sum-circular-subarray":{"0954-maximum-sum-circular-subarray.java":"44e7bd7d6546fe99d1f63303e1e13f291d490c0d","README.md":"03a38e407f8647ff2d71f040c0cc3ebd45b55611","difficulty":"medium"},"2564-most-profitable-path-in-a-tree":{"2564-most-profitable-path-in-a-tree.java":"ab6a6868214974fc130b46753c45bc99663318e1","README.md":"e56db6241b94a4f297e763b1b86a745d31513479","difficulty":"medium"},"1631-number-of-sub-arrays-with-odd-sum":{"1631-number-of-sub-arrays-with-odd-sum.java":"b4d29e27d4609957ab51a661848591b6a8f7654c","README.md":"2e2bb66730b657eb16248394f3e2794c8b40a50c","difficulty":"medium"},"1849-maximum-absolute-sum-of-any-subarray":{"1849-maximum-absolute-sum-of-any-subarray.java":"90215b3b296a939cdbb3341c37fa781152a436c8","README.md":"17a252ecbf551e9e57e4abb7dfc552dd8f74a817","difficulty":"medium"},"0045-jump-game-ii":{"0045-jump-game-ii.java":"03f1908ff533f61a63034a929855ba88703665c4","README.md":"553a8bb4e694bc2995dafe43715c60dae94f1614","difficulty":"medium"},"2427-first-letter-to-appear-twice":{"2427-first-letter-to-appear-twice.java":"36b8cdfecc57227658e545b1ff0b5fcba391b235","README.md":"e16f9b14de5e6464593cc1df30c3ec1d54fefa4c","difficulty":"easy"},"0003-longest-substring-without-repeating-characters":{"0003-longest-substring-without-repeating-characters.java":"0d0174b922f2c2fa6a1f2d56e18cf02975ffcf2a","README.md":"76430b4ca3f89e9447aba0f80390214b0903c119","difficulty":"medium"},"1170-shortest-common-supersequence":{"1170-shortest-common-supersequence.java":"fbc4fb0b6f974c1a215fc73cc53639a108094db0","README.md":"7a916ced23fb0af40ec7fbdf9158b011b1da5920","difficulty":"hard"},"0038-count-and-say":{"0038-count-and-say.java":"fc96327bb3143090cc9f99f3f1901d3729c342e1","README.md":"8ad8a0c57bd9542392588b66768a3cb3695ad51c","difficulty":"medium"},"2551-apply-operations-to-an-array":{"2551-apply-operations-to-an-array.java":"701d2f6e1ad7681d6c933235c401583e2b76f4cd","README.md":"db6fe73b402f26b678e52baa5c5d8517ec000c82","difficulty":"easy"},"0347-top-k-frequent-elements":{"0347-top-k-frequent-elements.java":"b379f745eb8eb6319bc19163d206c552ecdfab90","README.md":"71a7402a28b9374c9d59408ca33b519faf6b4b5d","difficulty":"medium"},"0138-copy-list-with-random-pointer":{"0138-copy-list-with-random-pointer.java":"6b26a56b10120f1153d03ddb2756bae16453cae8","README.md":"e428e5a3788bd2f607e32ab5a9eb946bbc45f8ce","difficulty":"medium"},"2707-merge-two-2d-arrays-by-summing-values":{"2707-merge-two-2d-arrays-by-summing-values.java":"1dce1f353414374b7053aa917ec488525133b738","README.md":"126f179270e6ce8476193401d33ca567d254ae5b","difficulty":"easy"},"0239-sliding-window-maximum":{"0239-sliding-window-maximum.java":"6a93027c183817f86f6bc63ed34ddd2af4efdbe7","README.md":"e74bbc2d7db3a76d550412775d2638076c85fdea","difficulty":"hard"},"1908-recyclable-and-low-fat-products":{"1908-recyclable-and-low-fat-products.sql":"97611203b65f7e49740741884940228b2ed5d57e","README.md":"f47c9f2e6a58af1ffee4c36c6aa7e87e20ffcfcf","difficulty":"easy"},"0584-find-customer-referee":{"0584-find-customer-referee.sql":"df97c0b9b67f5b25c6667bf361dda9c2e04a0125","README.md":"86aa614d4de964a6479545c1c8d31136e413a63d","difficulty":"easy"},"1258-article-views-i":{"1258-article-views-i.sql":"d94a74de6bf988bdf28fd06daa0ac59f5a1d84de","README.md":"efe35a7c266bd447c846cfe7405fd29d3023c4ae","difficulty":"easy"},"0326-power-of-three":{"0326-power-of-three.java":"de32f8aeddf8bd4413f42d0913094cfc9cbab4cc","README.md":"bb5baa8d797ad2b56432a84c6895005c87296ffe","difficulty":"easy"},"1827-invalid-tweets":{"1827-invalid-tweets.sql":"c30fede03a3e4a23e901208197061208c2a7b396","README.md":"900c40eca353248e020cabfa9993adc86b02e75e","difficulty":"easy"},"2265-partition-array-according-to-given-pivot":{"2265-partition-array-according-to-given-pivot.java":"38d898c1dbb5043572ceb5328fe65fc12f012018","README.md":"5ed7d3387bd3b69500fe679841c7463ffb6cf942"},"1889-check-if-number-is-a-sum-of-powers-of-three":{"1889-check-if-number-is-a-sum-of-powers-of-three.java":"a510bffa04ad41f0ae53d9e7d8bd311980969751","README.md":"565fa7a1a460edcb5bbfac1992cce481f586bce6","difficulty":"medium"},"0342-power-of-four":{"0342-power-of-four.java":"7d2c53f80c3e1f613c6584450131e8f31535482f","README.md":"151e06f6546534c9a03810988bcda994511353d5","difficulty":"easy"},"2649-count-total-number-of-colored-cells":{"2649-count-total-number-of-colored-cells.java":"4ea975d9d009e5f5c1edf3b309832969e34236b2","README.md":"269e2535e29df07b26c6dfbc4b57370f3a06f4b2","difficulty":"medium"},"3227-find-missing-and-repeated-values":{"3227-find-missing-and-repeated-values.java":"68c28623a5c719d60da7d17fd728cf75695f5147","README.md":"c25efda0562d8d985ee1f10a560efcb04acf9041","difficulty":"easy"},"0069-sqrtx":{"0069-sqrtx.java":"12aaf1428d7a3ffdae0241eac7bf36bdcff95449","README.md":"7e5ae55a48395ad7ba6e25814d16265ea3cbc3e5","difficulty":"easy"},"0034-find-first-and-last-position-of-element-in-sorted-array":{"0034-find-first-and-last-position-of-element-in-sorted-array.java":"dfff5f13b525e04c3403c98f6fe51ed138ac0d1e","README.md":"567e3eedc797db77ac13d34c49731ab95533307b","difficulty":"medium"},"2610-closest-prime-numbers-in-range":{"2610-closest-prime-numbers-in-range.java":"00dda8c80c7c0a9b33284c07a4f5794c83ca107c","README.md":"bbd585a08200af4de9470426ecb0db7eb66cf648","difficulty":"medium"},"2463-minimum-recolors-to-get-k-consecutive-black-blocks":{"2463-minimum-recolors-to-get-k-consecutive-black-blocks.java":"60b57cb82ed79277700398765261e7728f9344ba","README.md":"cb542868f09389af2d2b18728b6c12b0647aad94","difficulty":"easy"},"3483-alternating-groups-ii":{"3483-alternating-groups-ii.java":"579707733a35a635f346429f9df665b6474e7abc","README.md":"cbc52601191d27764faea143c97c7e73cc8de8fd","difficulty":"medium"},"0033-search-in-rotated-sorted-array":{"0033-search-in-rotated-sorted-array.java":"d7acb240286d761ed9c1ada5b7b1a2e43114eee9","README.md":"abac798678095507f22966997c719cde31f2a5b4","difficulty":"medium"},"3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii":{"3569-count-of-substrings-containing-every-vowel-and-k-consonants-ii.java":"9fef354e508947c7afe6af55ac61d489a8b438ac","README.md":"02c591a538d2909dd2d99e4ec4fd1f8bee60a54f","difficulty":"medium"},"0162-find-peak-element":{"0162-find-peak-element.java":"04d5c59538390e01efc1c1e29f701cae63b8822d","README.md":"511544c464bc7b44d0e1c5d6931b7e4e6c3d9ce9","difficulty":"medium"},"1460-number-of-substrings-containing-all-three-characters":{"1460-number-of-substrings-containing-all-three-characters.java":"e5140371969cb767f343884f4987ff1d06078183","README.md":"fc7ac2697b98c74aaf62410402169767db117684","difficulty":"medium"},"0076-minimum-window-substring":{"0076-minimum-window-substring.java":"5b325e25289e155bd635f38c32e932f057758c4b","README.md":"4e4e993681b5879cc2236606247c0c41ae2bb783","difficulty":"hard"},"0907-koko-eating-bananas":{"0907-koko-eating-bananas.java":"2f1fe29b80793cfbccd2534a313c08b0d4ecc3f3","README.md":"4fc2146d72b5c83fe9ec4f29cd87039fd510316e","difficulty":"medium"},"2614-maximum-count-of-positive-integer-and-negative-integer":{"2614-maximum-count-of-positive-integer-and-negative-integer.java":"8810444b25b77e1bc5197c5c0d25b7890d1a83c0","README.md":"58eaeae56e775d5323829c217ff0e84c57a05c00","difficulty":"easy"},"3643-zero-array-transformation-ii":{"3643-zero-array-transformation-ii.java":"302f7e3043e05d237aab37f89ed3d1d4d7df0765","README.md":"fd36c49d3ccd8a0c464f6c30d4683a50ba804fb3","difficulty":"medium"},"1335-maximum-candies-allocated-to-k-children":{"1335-maximum-candies-allocated-to-k-children.java":"f074018401c9d270656406f1a28671b3238c2330","README.md":"c37cdabe65ad7ba4e873c71464f4f93154ad39f3","difficulty":"medium"},"2690-house-robber-iv":{"2690-house-robber-iv.java":"0ee5d03e3d0a93afc22dee05be4e22d72593aff1","README.md":"b0f5ad1bf2fff08a3a3460c98be8a054116abb0a","difficulty":"medium"},"0451-sort-characters-by-frequency":{"0451-sort-characters-by-frequency.java":"1bb9419e4e85adcda377bcb6c658532a4fd52cbd","README.md":"1d68915815209b3121f3a0c8ea1168e009173d43","difficulty":"medium"},"2665-minimum-time-to-repair-cars":{"2665-minimum-time-to-repair-cars.java":"04d8ce0698c04133b7d52cc3f23f0cc8284e9f11","README.md":"35ff34a2055cba652497ba054132d7b5b1bbe95f","difficulty":"medium"},"2308-divide-array-into-equal-pairs":{"2308-divide-array-into-equal-pairs.java":"2c3f139377e03f68a6d144674561133581875d71","README.md":"32caea17d3d82751d3bd281c103f0436f8f16d77","difficulty":"easy"},"2478-longest-nice-subarray":{"2478-longest-nice-subarray.java":"4d942ebd890fe3b4121c481fa35d2aa0bf7c3b66","README.md":"0635d5598d25bbeb1a731079ace5dde898168d40","difficulty":"medium"},"0209-minimum-size-subarray-sum":{"0209-minimum-size-subarray-sum.java":"b50f8f479c2d18f494c3b0024489b2e49e0a548f","README.md":"6175d13534a18976ac44650d27ae421dbeee2c30","difficulty":"medium"},"0029-divide-two-integers":{"0029-divide-two-integers.java":"29423446bb2614eee23a6837b927acbccb59f4f3","README.md":"f8c4af779d05517a3176de8e2d75f706c3323c1d","difficulty":"medium"},"3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i":{"3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i.java":"adc7c8bea1c94b4985a72dfef3e90ecf05320b1c","README.md":"739142b289a1f4b92f65f63ba50de4282f7de5b1","difficulty":"medium"},"0908-middle-of-the-linked-list":{"0908-middle-of-the-linked-list.java":"6eb7f3c35c2926753c0922ea17242469f32c9d59","README.md":"8901a7b1b751c35fa003969dc6a62dda8e8c2451","difficulty":"easy"},"0141-linked-list-cycle":{"0141-linked-list-cycle.java":"44833e56117a70dd13487c3a933d8e3fb24ac453","README.md":"c5ab8258e428a83827bb65b22ace9f4fd6aa339a","difficulty":"easy"},"0206-reverse-linked-list":{"0206-reverse-linked-list.java":"b4daf0bbebd5000d7762ba15c4d1221c33f8da54","README.md":"d0e5a229257a811c50c7bcd689b492fe0a4082d2","difficulty":"easy","0206-reverse-linked-list.py":"03d4c661530cf4567d995da5c286c6fd5403b31c"},"0142-linked-list-cycle-ii":{"README.md":"5542812ecebeb59b63a8be0ed2f2ed36de15f75a","difficulty":"medium"},"2216-delete-the-middle-node-of-a-linked-list":{"2216-delete-the-middle-node-of-a-linked-list.java":"0485074a71ef9113180f1b3d91894d4820f6e031","README.md":"c16c8af108b049c03e0c79815f4a5a3b53ea5e48","difficulty":"medium"},"3348-minimum-cost-walk-in-weighted-graph":{"3348-minimum-cost-walk-in-weighted-graph.java":"6cb8765ed8067e2de7bb2a8647382eb82a48206f","README.md":"21a647d06f45ab22c2fc74744716c1cf84b48ee0","difficulty":"hard"},"0061-rotate-list":{"README.md":"65b7b860012ab804609a9507478a5816b73c3748"},"0838-design-linked-list":{"0838-design-linked-list.java":"8cd11244b7ed6a5206bd7dc49e86e16cf5c49d6a","README.md":"59ef517de9a96df09654fc68509a8335e90ccbba","difficulty":"medium"},"2220-find-all-possible-recipes-from-given-supplies":{"2220-find-all-possible-recipes-from-given-supplies.java":"1989c97393ed1be25b95134870bc6d0ac6a05e8e","README.md":"2a6be38db122481efe904ac8eff5d23597b936d5","difficulty":"medium"},"2793-count-the-number-of-complete-components":{"2793-count-the-number-of-complete-components.java":"cb71bf42cc0158ecedf5afb849dfb023005e8534","README.md":"c90c5ad42723b42c8a4e3d7746f91b309379b4c5","difficulty":"medium"},"0725-split-linked-list-in-parts":{"0725-split-linked-list-in-parts.java":"b6bf4b5fa9a94b31aba8ad376d2b9529be3fe651","README.md":"10e13a9db1092b1cc890e4ff74dd0c7b6dcac32b","difficulty":"medium"},"0234-palindrome-linked-list":{"0234-palindrome-linked-list.java":"dbf25528e15d7e05f5b42d59bfe8bd6cbd04aa0c","README.md":"7576eb79ebdcea463cbb12a37b2b7d59b7d2bcaa","difficulty":"easy"},"0092-reverse-linked-list-ii":{"0092-reverse-linked-list-ii.java":"015cf694dccd45b31faa350d4d1ef42ea560337f","README.md":"ef7393e9cec8b5d4098980721b062d60e653322a","difficulty":"medium"},"0083-remove-duplicates-from-sorted-list":{"0083-remove-duplicates-from-sorted-list.java":"400d086f0a1079a245968cd4ed02db61c9deff73","README.md":"9e0949f9f309216274ffb754d658f9e827034229","difficulty":"easy"},"0082-remove-duplicates-from-sorted-list-ii":{"0082-remove-duplicates-from-sorted-list-ii.cpp":"c5253aa9f692cc7f201520325554957c8f00c46e","README.md":"6a04b7ae4aaeb832fed9b01f7af10fbfa37e4b4e","difficulty":"medium"},"0025-reverse-nodes-in-k-group":{"0025-reverse-nodes-in-k-group.java":"53b5f5f497e91c1ab87557b4e42636a89d3ad138","README.md":"546ce7c305d12a712c76d032e209715ad644c24b","difficulty":"hard"},"0328-odd-even-linked-list":{"0328-odd-even-linked-list.cpp":"874d13c4e152947f0346c8cb602c4aa5ac62c658","README.md":"6e8419bdb07dd5aff28612281f8e77d099e4e75c","difficulty":"medium"},"2090-number-of-ways-to-arrive-at-destination":{"2090-number-of-ways-to-arrive-at-destination.java":"3e7b30c4a3dd7339095660f303e65cc2deb03046","README.md":"73a0faa914a0009a7c548e0a9bcb5068d609ebc4","difficulty":"medium"},"3501-delete-nodes-from-linked-list-present-in-array":{"3501-delete-nodes-from-linked-list-present-in-array.java":"7d234011dd456cfef024ad77f371935c3f4b6b4f","README.md":"666c4fdca81de7fccf908d13e05f955ac275b758","difficulty":"medium"},"0020-valid-parentheses":{"0020-valid-parentheses.java":"63bc6738376859fd745e5b9162cda9ff1174072a","README.md":"cd6320f8cb09fba0fb72aa44268e4aa33fff7cf9","difficulty":"easy"},"3657-check-if-grid-can-be-cut-into-sections":{"3657-check-if-grid-can-be-cut-into-sections.java":"36229e4d43f9bb39cd8265f1b4db497e79429516","README.md":"c14d99f9c7eabfa65ce1109605b683175e41fad0","difficulty":"medium"},"0402-remove-k-digits":{"0402-remove-k-digits.java":"10150846499ed7b5d1596004d75f62777a89ae82","README.md":"eaaadeabfaffeeae4a28fe6d6f8c131d82846129","difficulty":"medium"},"0540-single-element-in-a-sorted-array":{"0540-single-element-in-a-sorted-array.java":"bb784740e4b7864517a1cc265a1c7759c968710e","README.md":"0fe63f4b1657f7367d6d59ebbc4ea2a723d03dcc","difficulty":"medium"},"2160-minimum-operations-to-make-a-uni-value-grid":{"2160-minimum-operations-to-make-a-uni-value-grid.java":"51e9df66b893af15f1f0d6511b0a99b5e49b7dfa","README.md":"c38f21ecbb665c68a9abcb179a3b301c8b17968e","difficulty":"medium"},"0739-daily-temperatures":{"0739-daily-temperatures.java":"29110446c46d4568dc6398890c4df60735eb0dad","README.md":"5c61532b63ee9964cd9c2b43443829cfdc52dda7","difficulty":"medium"},"0735-asteroid-collision":{"0735-asteroid-collision.java":"97f3553566b788e4b5970ddc2045ef4935778863","README.md":"3ab52c85c938839835a44dafc03e436670cb4215","difficulty":"medium"},"2888-minimum-index-of-a-valid-split":{"2888-minimum-index-of-a-valid-split.java":"4c64ea5693b3985f6879cef5c7c501bb3b79c4ea","README.md":"3499d62a7a4903ffeeb8a4817f149ae4a84b476f","difficulty":"medium"},"0160-intersection-of-two-linked-lists":{"0160-intersection-of-two-linked-lists.java":"fa89ad9c72bb7da0ac1f579e3b836068577bf97c","README.md":"2ea40f7a63475325ce5f02fdc4a3eeaf37a25a96","difficulty":"easy"},"0225-implement-stack-using-queues":{"0225-implement-stack-using-queues.java":"59e904fff9c27c5b37ce69d516bb306d7e14190e","README.md":"b654d8365893c74fe70f24041bb5a9545bcd8d9e","difficulty":"easy"},"0232-implement-queue-using-stacks":{"0232-implement-queue-using-stacks.java":"bfdeb226b4e8b23ed1ed2814ed45309ab8ec58e7","README.md":"d0de1ae41764baaa8af874723bd5b1dc85277d89","difficulty":"easy"},"0155-min-stack":{"0155-min-stack.java":"ebf3a864dd9feaedbecfbc60f5e5d07c9780dfe7","README.md":"3902f5dff724cfd4e66625fd89bd17f7b3028c1a","difficulty":"medium"},"0187-repeated-dna-sequences":{"0187-repeated-dna-sequences.java":"245aba10ce230d27a3a2c9c6dd7707f901e5c4ac","README.md":"90f80694d7b1b3f224f3c3c54e08a8ab8423d9a0","difficulty":"medium"},"2588-maximum-number-of-points-from-grid-queries":{"2588-maximum-number-of-points-from-grid-queries.java":"da64d57912c2bd87b9ad65a52c1d5b4e58cfd9ff","README.md":"9630fb6dfb6bec9a90a001acdbfa1fe35d50e7f3","difficulty":"hard"},"0768-partition-labels":{"0768-partition-labels.java":"e2467a6d2d074f47210d789f55a065ebf5d7dd04","README.md":"6c15e4b6600f33c722555ea0fd19d2d49a21696d","difficulty":"medium"},"2174-next-greater-numerically-balanced-number":{"2174-next-greater-numerically-balanced-number.java":"5ecd4ffe07095c3fafd82e924b5c618c872baef4","README.md":"c00541d068216e8968544333ec48d55a33ca3383","difficulty":"medium"},"3430-count-days-without-meetings":{"3430-count-days-without-meetings.java":"67a2ebf0b88cf188144cd3d4bd9f1a87a2013498","README.md":"b977410ce1e2cd44d3294b76e2cda1e19884571e","difficulty":"medium"},"2681-put-marbles-in-bags":{"2681-put-marbles-in-bags.java":"8485e8ad90870f8e46894471f23176cba0207de1","README.md":"078e38baec3762c66fe47980a4176e8fc05b8895","difficulty":"hard"},"1029-vertical-order-traversal-of-a-binary-tree":{"1029-vertical-order-traversal-of-a-binary-tree.java":"172db7c9cb8e7dbd7ec9be6c5ee7b3f637b62957","README.md":"cc712dafc645b72db251cf84985e1f2456c15d53","difficulty":"hard"},"0013-roman-to-integer":{"0013-roman-to-integer.java":"b8b92066f8b537a43e2c697ce852874b5b3302e3","README.md":"0cff3a12e3a57725016019dffbd00e1453cced47","difficulty":"easy"},"0094-binary-tree-inorder-traversal":{"0094-binary-tree-inorder-traversal.java":"75d8815777a7b4817eccc59ff8bb0f2ab4c35cfa","README.md":"bd34dc7858ef18ca0298bb98d645a48123cf98b8","difficulty":"easy","0094-binary-tree-inorder-traversal.py":"281bbf69f86846cbb0addea0758774fbbe6596b5"},"3001-apply-operations-to-maximize-score":{"3001-apply-operations-to-maximize-score.java":"4a5b28189d1658d2e22396d14404829675caf39f","README.md":"435c8b3c8bf4d5097b7a93eb8ca2407421b04e1d","difficulty":"hard"},"0144-binary-tree-preorder-traversal":{"0144-binary-tree-preorder-traversal.java":"eba91d1d89027f67895a1c9ec8429859c02d565b","README.md":"2a9e1c4d5b165cf7667739cb5cd3e9fde9b49315","difficulty":"easy","0144-binary-tree-preorder-traversal.py":"2a28860ae750df07ab989d4f999af0cc4025a3b8"},"0078-subsets":{"0078-subsets.java":"0153bf65a191bf3a5ae77adef5f7241237a96056","README.md":"fb4b5a7f5abfc5e90375a3cbd0ec5781838463eb","difficulty":"medium","0078-subsets.py":"353d25360f806aeb4ab3ec4cfe92915251a197f7"},"0145-binary-tree-postorder-traversal":{"README.md":"ac6ce4de8f4a2a59c2b312532094616b3d3c85b7"},"0128-longest-consecutive-sequence":{"0128-longest-consecutive-sequence.java":"ad92ff20c7a1f4c8d24cceabff9e1892a49f4cd8","README.md":"bc9f29c64becd6a215a5f4d2dfc5724230985721","difficulty":"medium"},"0104-maximum-depth-of-binary-tree":{"0104-maximum-depth-of-binary-tree.java":"cbfd5c64dbfff1bcaa537083b8360eb258970bc4","README.md":"3e88d40eac7067a0b69cceb90c76020b6f152ae0","difficulty":"easy"},"0110-balanced-binary-tree":{"0110-balanced-binary-tree.java":"9b77fb824272cde09721d74b3f7aace96a46eec0","README.md":"1496517dcf0faedc819cbdf10d07de1900d95d9c","difficulty":"easy"},"0404-sum-of-left-leaves":{"0404-sum-of-left-leaves.java":"eff7875a12be7ea2ee408829e01017777a037674","README.md":"ac38605e80f3542e7c10c61df12ed09c0364fdfe","difficulty":"easy"},"0070-climbing-stairs":{"0070-climbing-stairs.java":"50e9857e94a10ff002a7544f40124e18947a6b60","README.md":"0c597685f700179382f33b96e37d1288b8252318","difficulty":"easy"},"0121-best-time-to-buy-and-sell-stock":{"0121-best-time-to-buy-and-sell-stock.java":"895d0a17a03e793d013a8a81d217761345603b4d","README.md":"c985d4a7bb22bad48ddd48f971d6376a9b0b8e9b"},"0217-contains-duplicate":{"0217-contains-duplicate.java":"b0e3233d5d1b9a051ff5a0f216c64801357079d6","README.md":"32f125875e81cf1815f6c769990b2abcd816244c","difficulty":"easy"},"0238-product-of-array-except-self":{"README.md":"912d25d7bd08724df0ad14590238921cf2be4a85"},"0322-coin-change":{"0322-coin-change.java":"0d728ee47fcb876f6700a8e1676f12c8ffa0cf35","README.md":"f31f965b5eeabbbf18769728b85c63ea3fae1f53","difficulty":"medium"},"0300-longest-increasing-subsequence":{"0300-longest-increasing-subsequence.java":"31dc936ea09eb271a24bc3b214ef0472eed9c21e","README.md":"598ddc0fad5b6ebf0b6821028c42c5f9a78fc010","difficulty":"medium"},"0191-number-of-1-bits":{"0191-number-of-1-bits.java":"4ae471e0270e168916820020ee72cca0921162c2","README.md":"d53044185b7acd8d879cf509f6dd60520c328629","difficulty":"easy"},"0100-same-tree":{"README.md":"e68046f2dc906bcd38453dd92eec5c257d4694a9"},"0226-invert-binary-tree":{"0226-invert-binary-tree.java":"5697955f189e809197a3ae62f2ee86384fd7cbc5","README.md":"50f4a6354112c1afacef29ffc7209e5f9f7095d8","difficulty":"easy"},"0637-average-of-levels-in-binary-tree":{"0637-average-of-levels-in-binary-tree.java":"df0740b47aad95e47950cc6e28b6fa3cc131f96b","README.md":"aaa6ac767f5432694c7fb7c1db70135c1c177dc8","difficulty":"easy"},"0199-binary-tree-right-side-view":{"0199-binary-tree-right-side-view.java":"920aad6c28bd372ff556356a201f2e9508b8c3ed","README.md":"e5e81cc2d06e4177eb353566d3a36bebd1431bab","difficulty":"medium"},"0103-binary-tree-zigzag-level-order-traversal":{"0103-binary-tree-zigzag-level-order-traversal.java":"194d96c15a17ee4f3672ee5d4fcc258c5ebf79a4","README.md":"fcd20aa2bad60f78f450527d135d90bfbc83d83a","difficulty":"medium"},"0112-path-sum":{"0112-path-sum.java":"ed212a4e5dbc40ca8424362c9a98cc57fb796d7d","README.md":"98772e551dafb6d42f9d932cfe0bd4fdf77d93d6","difficulty":"easy"},"0116-populating-next-right-pointers-in-each-node":{"0116-populating-next-right-pointers-in-each-node.java":"3a063e9cdf4c7f4b96d64cfc9855fde37a839fd8","README.md":"04fdf61ef1b0d696b39681fc9e6dbade83bfe222","difficulty":"medium"},"0015-3sum":{"0015-3sum.java":"34d0daed26c910d1146a2fcea90bbfad1ce19465","README.md":"84e5854cd32cb65d06da712e6329d17566651913","difficulty":"medium"},"0098-validate-binary-search-tree":{"0098-validate-binary-search-tree.java":"5e9fcfd9f438be8475d281098ba04743da6f1c04","README.md":"957fcdbca58c72b7e3fa5e71a94279d6325e4e06","difficulty":"medium","0098-validate-binary-search-tree.py":"1929b358f61e2d3c13b96a4fad62a3c9f326eb3b"},"0784-insert-into-a-binary-search-tree":{"0784-insert-into-a-binary-search-tree.java":"b1134cb772ae0eaa50d54cb445b36dca837ac8bd","README.md":"f0477736fdf23ae1d38f735c19e178f3f1e507ac","difficulty":"medium","0784-insert-into-a-binary-search-tree.py":"f1675753684a8a27ab7a4b9432623aa323148784"},"0056-merge-intervals":{"0056-merge-intervals.java":"69aeb5e03d0f7236908cc30c26f1dfd6f82d3c8f","README.md":"88e7690183764e9cad4696a6b74ab34e99745618","difficulty":"medium"},"0016-3sum-closest":{"0016-3sum-closest.java":"1350ef29c15b7790264adb3a31de9adb5561c368","README.md":"a6789ba53a05d173a00e814c4b2dda541a615b47","difficulty":"medium"},"0303-range-sum-query-immutable":{"0303-range-sum-query-immutable.java":"23f3216e8e61da59dc15516d3379ac1930b4eac7","README.md":"5a7f2f73ae2ee4698604e8c58800f931af311de4","difficulty":"easy"},"0713-subarray-product-less-than-k":{"0713-subarray-product-less-than-k.java":"ee4fa7ca3bd9d7e09b9073c14dfe130736b65fb5","README.md":"b147fb6a02d5267336c7e5735505342af49a2f4b","difficulty":"medium"},"2255-minimum-swaps-to-group-all-1s-together-ii":{"2255-minimum-swaps-to-group-all-1s-together-ii.java":"c37f07c871250455c13c032763e66a2afb885a6c","README.md":"5a1f6a120382f83f592b58e3eb3ac6b8e99e88d3","difficulty":"medium"},"0108-convert-sorted-array-to-binary-search-tree":{"0108-convert-sorted-array-to-binary-search-tree.java":"0d60392b42c96782d68db2a5fed785a810b445d5","README.md":"243a2859e66a71742146af16ea68ff0ab438a502","difficulty":"easy"},"0235-lowest-common-ancestor-of-a-binary-search-tree":{"0235-lowest-common-ancestor-of-a-binary-search-tree.java":"c88b12b0f62417f68a1ae5f20e657258a1258f52","README.md":"ccc587c35bb4f030d4cc146967eb49e7a922b6ce","difficulty":"medium"},"0338-counting-bits":{"0338-counting-bits.java":"c26306bcda7e642de790c386ef23ef4c4bfeece2","README.md":"49b28d806be1219ac702d54734cc9dcf52f4a286","difficulty":"easy"},"0124-binary-tree-maximum-path-sum":{"0124-binary-tree-maximum-path-sum.java":"7def5cec6d65f0d37ed71d9609c1fa4d8434eaa3","README.md":"ffa0bc8c9c787efac4955cef573cc6ed99caf29a","difficulty":"hard"},"0236-lowest-common-ancestor-of-a-binary-tree":{"0236-lowest-common-ancestor-of-a-binary-tree.java":"5da51b7a46b1a866292211d1b3fc798cc4f75173","README.md":"2e410057370d1340e00c05396cfa7ccd934457ff","difficulty":"medium"},"0230-kth-smallest-element-in-a-bst":{"0230-kth-smallest-element-in-a-bst.java":"d331bc43a8ea85bc12067dba88f4c52ab631e569","README.md":"b85079c6416a140ae38c1742bfed6b19335fb1cd","difficulty":"medium"},"0114-flatten-binary-tree-to-linked-list":{"0114-flatten-binary-tree-to-linked-list.java":"23ee3bb75baef036421dfb30abf84fe726316a11","README.md":"581431bf3d62fd3a541ca6eb01543cb6f06b71a8","difficulty":"medium"},"3242-count-elements-with-maximum-frequency":{"3242-count-elements-with-maximum-frequency.java":"5616c08b61d7df7aa5c8528d7d7b2338f64eabae","README.md":"830c97a0d6c382e4061313e1a26e404f7125da10","difficulty":"easy"},"0133-clone-graph":{"0133-clone-graph.java":"b82ba8a6bcc1becd1534d4e9e489ee8c41f1db92","README.md":"38fdb5ad5ec20bac2131a1b2104d89710ba5a693","difficulty":"medium"},"0106-construct-binary-tree-from-inorder-and-postorder-traversal":{"0106-construct-binary-tree-from-inorder-and-postorder-traversal.cpp":"23a4edffe240ded4bb203085e411d34a425257ba","README.md":"8169bc76429370954eb33bb078940c0a05066e29","difficulty":"medium"},"0149-max-points-on-a-line":{"0149-max-points-on-a-line.java":"96b1d89cf169d444a31972791d89f99d49f10ab5","README.md":"336c348141e342674d8c581a6e72e17fc26a4f0f","difficulty":"hard"},"0215-kth-largest-element-in-an-array":{"0215-kth-largest-element-in-an-array.java":"389260a58dc3e4a4cb9fa3fc942491d98223958a","README.md":"298cc5a76e0dc90dc8740987ad53ab6784bb1497","difficulty":"medium"},"0023-merge-k-sorted-lists":{"0023-merge-k-sorted-lists.java":"8a6c73393e938df806caebf58aebc3716a165b06","README.md":"39f48ee106381bce575d0e15310ccc646636ee43","difficulty":"hard"},"0011-container-with-most-water":{"0011-container-with-most-water.java":"4f20893211c4f70cede56e6938fc087d08aabd03","README.md":"d639cbc775d69587c4d50e25339787fc8d8bf70a","difficulty":"medium"},"0198-house-robber":{"0198-house-robber.java":"ba5317db8929d38461fbaa3495aa30b6f17e9622","README.md":"c491b967a900cb99d15082fbea11f278283749f7","difficulty":"medium","0198-house-robber.py":"d266efbe85d78e0f94f3d8c922795dd5715ff4ce"},"2461-amount-of-time-for-binary-tree-to-be-infected":{"2461-amount-of-time-for-binary-tree-to-be-infected.java":"c0aedacd93e3b8fac88cbb5990292ed431c50a7c","README.md":"e3054e38f31f80f79126a9f2651a7902efda08d1","difficulty":"medium"},"1509-replace-employee-id-with-the-unique-identifier":{"1509-replace-employee-id-with-the-unique-identifier.sql":"645ce2af700ec4798093bab35f2392e0cf089281","README.md":"cdf2476162cbbde935ced1e799ed8042c75d0407","difficulty":"easy"},"1153-product-sales-analysis-i":{"README.md":"a0798287a8dd6e4ac0b9fb21988981bac8828da1"},"1724-customer-who-visited-but-did-not-make-any-transactions":{"1724-customer-who-visited-but-did-not-make-any-transactions.sql":"8fad138c652ef3570451a84b338c2dd14e4d6bbc","README.md":"40d68268c444390fbb9bde90605f3f12373efb58","difficulty":"easy"},"0213-house-robber-ii":{"0213-house-robber-ii.java":"7fa4cb79ecc2ea8329ab575b86a4499655692773","README.md":"e45c4fa04051a71565b17a37248a3c8cb2440288","difficulty":"medium"},"0063-unique-paths-ii":{"0063-unique-paths-ii.java":"f0323e9bd2e7a00a3f47714d6152008f4c0c0d67","README.md":"2b02424a57e698cea22bc562b9c128698181b280","difficulty":"medium"},"1250-longest-common-subsequence":{"1250-longest-common-subsequence.java":"2354b448652001463e62f804d0dcbad15ad8a879","README.md":"fac5f449f398e070adf3297046180c02b994cedf","difficulty":"medium"},"0516-longest-palindromic-subsequence":{"0516-longest-palindromic-subsequence.java":"795d3bb6cc570a81beddc0ad75548e3b143300a4","README.md":"f772e50126d694335103837835619758d7239303","difficulty":"medium"},"0120-triangle":{"0120-triangle.java":"d2fca90d69dd8742925a48985970b7f5b0aeef22","README.md":"041b5f2775b1bcdb24d9b7c06cdd771e5d1cf484","difficulty":"medium"},"0064-minimum-path-sum":{"0064-minimum-path-sum.java":"6971d8c435376408e814b83d7325dd2dac4b51c1","README.md":"83eb5e532a72ad80d5c0489525c128a44770f39f","difficulty":"medium"},"0967-minimum-falling-path-sum":{"0967-minimum-falling-path-sum.java":"89387c8071feb46fb8ec231add7f877dd405295c","README.md":"e08a2b33fd62e43cd693504092ad466855f24dbb","difficulty":"medium"},"1224-minimum-falling-path-sum-ii":{"1224-minimum-falling-path-sum-ii.java":"4e3cc825b60a323e3ad05edfda2fef76e43afd10","README.md":"52a76257131aa311dccf98b30235cb8190c591cd","difficulty":"hard"},"0416-partition-equal-subset-sum":{"0416-partition-equal-subset-sum.java":"f477246cb35f866c01e71cf12991afd28f676c38","README.md":"6928b40440620e801ec73179b91d2c09a25e3f70","difficulty":"medium"},"0485-max-consecutive-ones":{"0485-max-consecutive-ones.java":"31a5093897318be7092b716fd20decbd43542598","README.md":"0a88ee73233dd3a1dada777b4b3139b22ebe4d81","difficulty":"easy"},"0435-non-overlapping-intervals":{"0435-non-overlapping-intervals.java":"68811c3982ce93ea5aa3dbe57e12c0eab32072f4","README.md":"7512c649c35f6eb44ff2829f202e301c24b835aa","difficulty":"medium"},"0055-jump-game":{"0055-jump-game.java":"eeedd5fc37051e5dfe1b29571273932756a9f1f8","README.md":"900dfed38ade0996d0fcda4f5b8993a34580e74e","difficulty":"medium"},"0424-longest-repeating-character-replacement":{"README.md":"64e2ba5714ef780b760523fafa5c05a6fddab22c","0424-longest-repeating-character-replacement.java":"50825c3504b8bf5db061bac56e677e9e0ce930fe","difficulty":"medium"},"1014-k-closest-points-to-origin":{"1014-k-closest-points-to-origin.java":"6bc0f559f36536338903592bc18cd8974907f6ea","README.md":"2380f2d9b5266d81bdcf363d1c06aab986e19c8d","difficulty":"medium"},"0513-find-bottom-left-tree-value":{"0513-find-bottom-left-tree-value.java":"150077e597787f5ecf95b2227996c9f27babe95b","README.md":"579cbb8fa73b66162143543b7b0a8d04b1809b43","difficulty":"medium"},"3685-count-subarrays-of-length-three-with-a-condition":{"README.md":"e421bbd3dbaf923671e9001501d93111e1b16b8d"},"1030-smallest-string-starting-from-leaf":{"1030-smallest-string-starting-from-leaf.java":"d592fbbc747368faf3724789e1515bb19ae97473","README.md":"57325b9b052673b5af7d87a952b8ccb361fa5a1e","difficulty":"medium"},"0988-flip-equivalent-binary-trees":{"0988-flip-equivalent-binary-trees.java":"15fc642f1d692fe883df757e7ef3f4601a39ec17","README.md":"e48d4b2aa292bc58a79b0dd061763a065800af59","difficulty":"medium"},"2493-reverse-odd-levels-of-binary-tree":{"2493-reverse-odd-levels-of-binary-tree.java":"516f1ef8edce2f44b73d54feef994f5faf5272d2","README.md":"b5dd3a112647e1f67446439450d976d26fc3c5a0","difficulty":"medium"},"0525-contiguous-array":{"0525-contiguous-array.java":"d87b426133706f8cd8cec40f83d3cc7d17728704","README.md":"8393a67aa9fceefdbd7999e07fc514b506083479","difficulty":"medium"},"0560-subarray-sum-equals-k":{"0560-subarray-sum-equals-k.java":"8b4d91ab7b81fdd3e17363f0ee8f93b5efc2010d","README.md":"dc9c776f71887d8b50daaacbd3c275d80a1d7a18","difficulty":"medium"},"1056-capacity-to-ship-packages-within-d-days":{"1056-capacity-to-ship-packages-within-d-days.java":"3dd9b46f03f7a149f2f2bac0fb505404756cdae2","README.md":"e2211f0f1c2218faaae189be54a10b2d1a0e9f01","difficulty":"medium"},"0966-binary-subarrays-with-sum":{"0966-binary-subarrays-with-sum.java":"4a03011a6cf456bbb6a37d2ddac9251ea641e603","README.md":"f23933023910f16541855b6fa0021c3ee820946f","difficulty":"medium"},"2394-count-subarrays-with-score-less-than-k":{"2394-count-subarrays-with-score-less-than-k.java":"8e5ef4180496439a53b4ed8affe5f27d48ed37a6","README.md":"5fe8df9bfd796ca7527579333d0ba68fc5c388ec","difficulty":"hard"},"3213-count-subarrays-where-max-element-appears-at-least-k-times":{"3213-count-subarrays-where-max-element-appears-at-least-k-times.java":"556b158d1441b994767e464aafeaf3b36da01efc","README.md":"a2edb3343523ab5b250174fd46f361ab9cd02094","difficulty":"medium"},"1034-subarrays-with-k-different-integers":{"README.md":"d2ebd7428506a2c60be65acdb993a591fc2f38a7"},"1421-find-numbers-with-even-number-of-digits":{"1421-find-numbers-with-even-number-of-digits.java":"10e02bf2f21768603a3f320b9ebcf2a9bcfaecc0","README.md":"4497207c1e016dd329a4401ac3b755dabf4b7fa8","difficulty":"easy"},"3172-divisible-and-non-divisible-sums-difference":{"3172-divisible-and-non-divisible-sums-difference.java":"3bbd6d01e137c5462f58cdab45d90422b5171666","README.md":"6ad2ed61f3cb6fd32f50f78375014337f5290fb9","difficulty":"easy"},"0480-sliding-window-median":{"0480-sliding-window-median.java":"4adf9b3981a4239e5ccd96961a1b7961b8460524","README.md":"7d669f5dbdc8dd37a2bb7bba384b8437fa279fa6","difficulty":"hard"},"3201-distribute-candies-among-children-ii":{"3201-distribute-candies-among-children-ii.java":"f36fe463245674a62e0d57dbbf177cdf17866bb5","README.md":"adfce050ec51573e8031520d7e5018ce16b31a43","difficulty":"medium"},"2260-divide-a-string-into-groups-of-size-k":{"2260-divide-a-string-into-groups-of-size-k.java":"8313743c47949c5b8501d2156de206cfcdd0cf19","README.md":"5cb523e15704bbaef15006900cb6b1b83ca77085","difficulty":"easy"},"0783-search-in-a-binary-search-tree":{"0783-search-in-a-binary-search-tree.py":"579b6d28c4537a402859c5a3169fd28539fd8ca3","README.md":"0ebb87b67c966c7015765bd0dd9990eb6353574f","difficulty":"easy"},"0046-permutations":{"0046-permutations.java":"9b640fdbac98789d9d79e7ef034beb7ef27dd868","README.md":"2b8ea299bb1b115617c0f0c3f959614962286398","difficulty":"medium"},"0040-combination-sum-ii":{"0040-combination-sum-ii.py":"66ba90e9cbe97b4a6ab5cc9455850af700957d4a","README.md":"326d74f429b6d1be09c063a41a7f9f073b2e64aa","difficulty":"medium"},"0131-palindrome-partitioning":{"0131-palindrome-partitioning.py":"caf4a2978213560f6770696c011c40607d13f8b1","README.md":"8d1193b850186046367e6f61e71d735ecfe81acf","difficulty":"medium"},"0257-binary-tree-paths":{"0257-binary-tree-paths.py":"fce9e5d0abe2fda88b5443da7d45f943cb1d4435","README.md":"d0a5987303eae22716aa5ff4aac834c26f236bf8","difficulty":"easy"},"2887-sort-vowels-in-a-string":{"2887-sort-vowels-in-a-string.py":"fc902e3a19f89a9ede303151a4f6cbe25a4d866d","README.md":"74a440d7bd9c603c708f36462c87ea7d8231e426","difficulty":"medium"},"2307-replace-non-coprime-numbers-in-array":{"2307-replace-non-coprime-numbers-in-array.py":"310ea7346f259c15452d5093f7b5df04ac53a0ba","README.md":"3258f4992470829da9804def63210d23b8d1dff5","difficulty":"hard"},"2324-find-triangular-sum-of-an-array":{"2324-find-triangular-sum-of-an-array.java":"a5534691ec11ce7be6905755b99fc2f57e486fd1","README.md":"1ab984bad8b6df9cd063b6819b6fea259bfdf63b","difficulty":"medium"},"2429-design-a-food-rating-system":{"2429-design-a-food-rating-system.java":"667fd8ee833b099cb9d721c572cbeaa0f0fe950b","README.md":"ae2882acee563e072dbc5988bb198cc090f8cd3c","difficulty":"medium"},"1642-water-bottles":{"1642-water-bottles.java":"d8190a05de6ac60f9bb6b56f9b169a530117eec3","README.md":"68f50f8e7634560543b62c9ff7215a0e5c80a544","difficulty":"easy"},"1652-minimum-suffix-flips":{"1652-minimum-suffix-flips.py":"efe1cc5795e7d40b4b73ad704ef4ef1bb18958ae","README.md":"ff4871e45ee683454393dbe7a0d69dba1f71f3d6","difficulty":"medium"}},"solved":208}}
\ No newline at end of file