From 0f09cea26dfb062c2dda61dcb5f9f725d4c8b968 Mon Sep 17 00:00:00 2001
From: Vaibhav Nirmal <vaibhavnirmal2001@gmail.com>
Date: Mon, 10 Oct 2022 15:23:49 +0530
Subject: [PATCH] added new problems

Added c++ Solutions of leetcode

Co-Authored-By: Vaibhav Nirmal <70758433+vaibhavnirmal2001@users.noreply.github.com>
---
 01-matrix/README.md                           |  29 +++
 1's Complement - GFG/1s-complement.cpp        |  42 ++++
 1's Complement - GFG/README.md                |  43 ++++
 1-two-sum/1-two-sum.cpp                       |  22 ++
 1-two-sum/NOTES.md                            |   1 +
 1-two-sum/README.md                           |  38 +++
 100-same-tree/NOTES.md                        |   1 +
 100-same-tree/README.md                       |  31 +++
 .../1009-complement-of-base-10-integer.cpp    |   7 +
 1009-complement-of-base-10-integer/NOTES.md   |   1 +
 1009-complement-of-base-10-integer/README.md  |  40 ++++
 ...s-with-total-durations-divisible-by-60.cpp |  12 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +++
 ...apacity-to-ship-packages-within-d-days.cpp |  51 ++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  49 ++++
 .../102-binary-tree-level-order-traversal.cpp |  40 ++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +++
 ...022-sum-of-root-to-leaf-binary-numbers.cpp |  36 +++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  32 +++
 .../1029-two-city-scheduling.cpp              |  35 +++
 1029-two-city-scheduling/NOTES.md             |   1 +
 1029-two-city-scheduling/README.md            |  40 ++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +++
 .../104-maximum-depth-of-binary-tree.cpp      |  23 ++
 104-maximum-depth-of-binary-tree/NOTES.md     |   1 +
 104-maximum-depth-of-binary-tree/README.md    |  25 ++
 .../1041-robot-bounded-in-circle.cpp          |  23 ++
 1041-robot-bounded-in-circle/NOTES.md         |   1 +
 1041-robot-bounded-in-circle/README.md        |  40 ++++
 .../1049-last-stone-weight-ii.cpp             |  36 +++
 1049-last-stone-weight-ii/NOTES.md            |   1 +
 1049-last-stone-weight-ii/README.md           |  39 ++++
 ...ee-from-preorder-and-inorder-traversal.cpp |  57 +++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  28 +++
 ...ert-sorted-array-to-binary-search-tree.cpp |  38 +++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  29 +++
 1094-car-pooling/1094-car-pooling.cpp         |  10 +
 1094-car-pooling/NOTES.md                     |   1 +
 1094-car-pooling/README.md                    |  30 +++
 .../11-container-with-most-water.cpp          |  17 ++
 11-container-with-most-water/NOTES.md         |   1 +
 11-container-with-most-water/README.md        |  31 +++
 .../110-balanced-binary-tree.cpp              |  35 +++
 110-balanced-binary-tree/NOTES.md             |   1 +
 110-balanced-binary-tree/README.md            |  35 +++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  46 ++++
 ...114-flatten-binary-tree-to-linked-list.cpp |  37 +++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  36 +++
 .../115-distinct-subsequences.cpp             |  27 +++
 115-distinct-subsequences/NOTES.md            |   1 +
 115-distinct-subsequences/README.md           |  38 +++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  44 ++++
 118-pascals-triangle/NOTES.md                 |   1 +
 118-pascals-triangle/README.md                |  19 ++
 120-triangle/120-triangle.cpp                 |  32 +++
 120-triangle/NOTES.md                         |   1 +
 120-triangle/README.md                        |  35 +++
 .../121-best-time-to-buy-and-sell-stock.cpp   |  21 ++
 121-best-time-to-buy-and-sell-stock/NOTES.md  |   1 +
 121-best-time-to-buy-and-sell-stock/README.md |  30 +++
 ...122-best-time-to-buy-and-sell-stock-ii.cpp |  14 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  39 ++++
 .../1220-count-vowels-permutation.cpp         |  37 +++
 1220-count-vowels-permutation/NOTES.md        |   1 +
 1220-count-vowels-permutation/README.md       |  40 ++++
 ...23-best-time-to-buy-and-sell-stock-iii.cpp |  22 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  37 +++
 ...nimum-remove-to-make-valid-parentheses.cpp |  19 ++
 .../README.md                                 |  41 ++++
 126-word-ladder-ii/126-word-ladder-ii.cpp     |  68 ++++++
 126-word-ladder-ii/NOTES.md                   |   1 +
 126-word-ladder-ii/README.md                  |  40 ++++
 127-word-ladder/127-word-ladder.cpp           |  32 +++
 127-word-ladder/NOTES.md                      |   1 +
 127-word-ladder/README.md                     |  38 +++
 ...the-smallest-divisor-given-a-threshold.cpp |  39 ++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  30 +++
 .../1288-remove-covered-intervals.cpp         |  33 +++
 1288-remove-covered-intervals/NOTES.md        |   1 +
 1288-remove-covered-intervals/README.md       |  30 +++
 .../1291-sequential-digits.cpp                |  24 ++
 1291-sequential-digits/NOTES.md               |   1 +
 1291-sequential-digits/README.md              |  19 ++
 13-Roman-to-Integer/13-roman-to-integer.cpp   |  28 +++
 13-Roman-to-Integer/NOTES.md                  |   1 +
 ...ll-elements-in-two-binary-search-trees.cpp |  60 +++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  23 ++
 .../131-palindrome-partitioning.cpp           |  44 ++++
 131-palindrome-partitioning/NOTES.md          |   1 +
 131-palindrome-partitioning/README.md         |  20 ++
 133-clone-graph/NOTES.md                      |   1 +
 133-clone-graph/README.md                     |  59 +++++
 .../1337-the-k-weakest-rows-in-a-matrix.cpp   |  38 +++
 1337-the-k-weakest-rows-in-a-matrix/NOTES.md  |   1 +
 1337-the-k-weakest-rows-in-a-matrix/README.md |  61 +++++
 134-gas-station/NOTES.md                      |   1 +
 134-gas-station/README.md                     |  44 ++++
 ...-all-valid-pickup-and-delivery-options.cpp |  14 ++
 .../README.md                                 |  36 +++
 136-single-number/136-single-number.cpp       |   9 +
 136-single-number/README.md                   |  24 ++
 .../138-copy-list-with-random-pointer.cpp     |  61 +++++
 138-copy-list-with-random-pointer/NOTES.md    |   1 +
 138-copy-list-with-random-pointer/README.md   |  47 ++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  46 ++++
 139-word-break/README.md                      |  37 +++
 .../141-linked-list-cycle.cpp                 |  28 +++
 141-linked-list-cycle/NOTES.md                |   1 +
 141-linked-list-cycle/README.md               |  40 ++++
 .../142-linked-list-cycle-ii.cpp              |  38 +++
 142-linked-list-cycle-ii/NOTES.md             |   1 +
 142-linked-list-cycle-ii/README.md            |  40 ++++
 ...ximum-points-you-can-obtain-from-cards.cpp |  46 ++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  39 ++++
 144-binary-tree-preorder-traversal/NOTES.md   |   1 +
 144-binary-tree-preorder-traversal/README.md  |  32 +++
 146-lru-cache/146-lru-cache.cpp               |  70 ++++++
 146-lru-cache/NOTES.md                        |   1 +
 146-lru-cache/README.md                       |  44 ++++
 ...ake-after-horizontal-and-vertical-cuts.cpp |  21 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  43 ++++
 .../1472-design-browser-history.cpp           |  27 +++
 1472-design-browser-history/NOTES.md          |   1 +
 1472-design-browser-history/README.md         |  45 ++++
 148-sort-list/148-sort-list.cpp               |  50 ++++
 148-sort-list/NOTES.md                        |   1 +
 148-sort-list/README.md                       |  32 +++
 1510-stone-game-iv/1510-stone-game-iv.cpp     |  15 ++
 1510-stone-game-iv/NOTES.md                   |   1 +
 1510-stone-game-iv/README.md                  |  36 +++
 ...3-find-minimum-in-rotated-sorted-array.cpp |  22 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  46 ++++
 ...ind-minimum-in-rotated-sorted-array-ii.cpp |  26 +++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  36 +++
 155-min-stack/155-min-stack.cpp               |  82 +++++++
 155-min-stack/NOTES.md                        |   1 +
 155-min-stack/README.md                       |  44 ++++
 .../1552-magnetic-force-between-two-balls.cpp |  52 +++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  32 +++
 16-3sum-closest/16-3sum-closest.cpp           |  34 +++
 16-3sum-closest/NOTES.md                      |   1 +
 .../160-intersection-of-two-linked-lists.cpp  |  24 ++
 .../README.md                                 |  63 +++++
 .../162-find-peak-element.cpp                 |  20 ++
 162-find-peak-element/NOTES.md                |   1 +
 162-find-peak-element/README.md               |  30 +++
 165-compare-version-numbers/README.md         |  49 ++++
 .../1672-richest-customer-wealth.cpp          |  15 ++
 1672-richest-customer-wealth/NOTES.md         |   1 +
 1672-richest-customer-wealth/README.md        |  41 ++++
 1675-minimize-deviation-in-array/NOTES.md     |   1 +
 1675-minimize-deviation-in-array/README.md    |  52 +++++
 169-majority-element/169-majority-element.cpp |  21 ++
 169-majority-element/NOTES.md                 |   1 +
 169-majority-element/README.md                |  23 ++
 .../171-excel-sheet-column-number.cpp         |  15 ++
 171-excel-sheet-column-number/NOTES.md        |   1 +
 171-excel-sheet-column-number/README.md       |  42 ++++
 .../1760-minimum-limit-of-balls-in-a-bag.cpp  |  38 +++
 1760-minimum-limit-of-balls-in-a-bag/NOTES.md |   1 +
 .../README.md                                 |  54 +++++
 179-largest-number/179-largest-number.cpp     |  49 ++++
 179-largest-number/NOTES.md                   |   1 +
 179-largest-number/README.md                  |  25 ++
 18-4sum/18-4sum.cpp                           |  44 ++++
 18-4sum/NOTES.md                              |   1 +
 18-4sum/README.md                             |  32 +++
 ...3-find-the-winner-of-the-circular-game.cpp |   9 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  43 ++++
 189-rotate-array/NOTES.md                     |   1 +
 189-rotate-array/README.md                    |  39 ++++
 2-add-two-numbers/2-add-two-numbers.cpp       |  58 +++++
 2-add-two-numbers/NOTES.md                    |   1 +
 2-add-two-numbers/README.md                   |  33 +++
 20-valid-parentheses/20-valid-parentheses.cpp |  53 +++++
 20-valid-parentheses/NOTES.md                 |   1 +
 20-valid-parentheses/README.md                |  36 +++
 .../203-remove-linked-list-elements.cpp       |  35 +++
 203-remove-linked-list-elements/NOTES.md      |   1 +
 203-remove-linked-list-elements/README.md     |  30 +++
 .../206-reverse-linked-list.cpp               |  23 ++
 206-reverse-linked-list/NOTES.md              |   1 +
 206-reverse-linked-list/README.md             |  32 +++
 .../209-minimum-size-subarray-sum.cpp         |  64 ++++++
 209-minimum-size-subarray-sum/NOTES.md        |   1 +
 209-minimum-size-subarray-sum/README.md       |  33 +++
 .../21-merge-two-sorted-lists.cpp             |  46 ++++
 21-merge-two-sorted-lists/NOTES.md            |   1 +
 21-merge-two-sorted-lists/README.md           |  34 +++
 .../2145-count-the-hidden-sequences.cpp       |  12 +
 2145-count-the-hidden-sequences/NOTES.md      |   1 +
 2145-count-the-hidden-sequences/README.md     |  57 +++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  44 ++++
 ...ize-number-of-subsequences-in-a-string.cpp |  45 ++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  37 +++
 221-maximal-square/NOTES.md                   |   1 +
 221-maximal-square/README.md                  |  31 +++
 .../225-implement-stack-using-queues.cpp      |  40 ++++
 225-implement-stack-using-queues/NOTES.md     |   1 +
 225-implement-stack-using-queues/README.md    |  48 ++++
 .../229-majority-element-ii.cpp               |  47 ++++
 229-majority-element-ii/NOTES.md              |   1 +
 229-majority-element-ii/README.md             |  32 +++
 .../23-merge-k-sorted-lists.cpp               |  59 +++++
 23-merge-k-sorted-lists/NOTES.md              |   1 +
 23-merge-k-sorted-lists/README.md             |  43 ++++
 231-power-of-two/231-power-of-two.cpp         |  14 ++
 231-power-of-two/NOTES.md                     |   1 +
 231-power-of-two/README.md                    |  34 +++
 .../232-implement-queue-using-stacks.cpp      |  44 ++++
 232-implement-queue-using-stacks/NOTES.md     |   1 +
 232-implement-queue-using-stacks/README.md    |  48 ++++
 .../234-palindrome-linked-list.cpp            |  55 +++++
 234-palindrome-linked-list/NOTES.md           |   1 +
 ...owest-common-ancestor-of-a-binary-tree.cpp |  27 +++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  36 +++
 .../237-delete-node-in-a-linked-list.cpp      |  17 ++
 237-delete-node-in-a-linked-list/NOTES.md     |   1 +
 237-delete-node-in-a-linked-list/README.md    |  29 +++
 .../238-product-of-array-except-self.cpp      |  17 ++
 238-product-of-array-except-self/NOTES.md     |   1 +
 238-product-of-array-except-self/README.md    |  26 +++
 239-sliding-window-maximum/NOTES.md           |   1 +
 239-sliding-window-maximum/README.md          |  35 +++
 .../24-swap-nodes-in-pairs.cpp                |  29 +++
 24-swap-nodes-in-pairs/NOTES.md               |   1 +
 24-swap-nodes-in-pairs/README.md              |  29 +++
 242-valid-anagram/242-valid-anagram.cpp       |   8 +
 242-valid-anagram/NOTES.md                    |   1 +
 242-valid-anagram/README.md                   |  23 ++
 25-reverse-nodes-in-k-group/NOTES.md          |   1 +
 25-reverse-nodes-in-k-group/README.md         |  31 +++
 258-add-digits/258-add-digits.cpp             |  16 ++
 258-add-digits/NOTES.md                       |   1 +
 258-add-digits/README.md                      |  29 +++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  51 ++++
 283-move-zeroes/283-move-zeroes.cpp           |  22 ++
 283-move-zeroes/NOTES.md                      |   1 +
 283-move-zeroes/README.md                     |  22 ++
 .../287-find-the-duplicate-number.cpp         |  21 ++
 287-find-the-duplicate-number/NOTES.md        |   1 +
 287-find-the-duplicate-number/README.md       |  37 +++
 ...string-with-concatenation-of-all-words.cpp |  39 ++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  35 +++
 300-longest-increasing-subsequence/NOTES.md   |   1 +
 307-range-sum-query-mutable/NOTES.md          |   1 +
 307-range-sum-query-mutable/README.md         |  43 ++++
 31-next-permutation/31-next-permutation.cpp   |  37 +++
 31-next-permutation/NOTES.md                  |   1 +
 .../316-remove-duplicate-letters.cpp          |  21 ++
 316-remove-duplicate-letters/NOTES.md         |   1 +
 316-remove-duplicate-letters/README.md        |  26 +++
 326-power-of-three/326-power-of-three.cpp     |  11 +
 326-power-of-three/NOTES.md                   |   1 +
 326-power-of-three/README.md                  |  32 +++
 .../33-search-in-rotated-sorted-array.cpp     |  30 +++
 33-search-in-rotated-sorted-array/NOTES.md    |   1 +
 33-search-in-rotated-sorted-array/README.md   |  30 +++
 ...st-position-of-element-in-sorted-array.cpp |  60 +++++
 .../README.md                                 |  27 +++
 342-power-of-four/342-power-of-four.cpp       |  11 +
 342-power-of-four/NOTES.md                    |   1 +
 342-power-of-four/README.md                   |  24 ++
 344-reverse-string/NOTES.md                   |   1 +
 344-reverse-string/README.md                  |  20 ++
 .../345-reverse-vowels-of-a-string.cpp        |  25 ++
 345-reverse-vowels-of-a-string/NOTES.md       |   1 +
 345-reverse-vowels-of-a-string/README.md      |  20 ++
 .../347-top-k-frequent-elements.cpp           |  25 ++
 347-top-k-frequent-elements/NOTES.md          |   1 +
 347-top-k-frequent-elements/README.md         |  22 ++
 .../35-search-insert-position.cpp             |  24 ++
 35-search-insert-position/NOTES.md            |   1 +
 35-search-insert-position/README.md           |  33 +++
 37-sudoku-solver/NOTES.md                     |   1 +
 37-sudoku-solver/README.md                    |  32 +++
 38-count-and-say/38-count-and-say.cpp         |  20 ++
 38-count-and-say/NOTES.md                     |   1 +
 38-count-and-say/README.md                    |  39 ++++
 .../382-linked-list-random-node.cpp           |  20 ++
 382-linked-list-random-node/NOTES.md          |   1 +
 382-linked-list-random-node/README.md         |  45 ++++
 .../389-find-the-difference.cpp               |   9 +
 389-find-the-difference/NOTES.md              |   1 +
 39-combination-sum/39-combination-sum.cpp     |  29 +++
 39-combination-sum/NOTES.md                   |   1 +
 39-combination-sum/README.md                  |  39 ++++
 394-decode-string/NOTES.md                    |   1 +
 394-decode-string/README.md                   |  37 +++
 .../397-integer-replacement.cpp               |  28 +++
 397-integer-replacement/NOTES.md              |   1 +
 397-integer-replacement/README.md             |  38 +++
 3sum-closest/3sum-closest.cpp                 |  31 +++
 3sum-closest/README.md                        |  19 ++
 3sum/3sum.cpp                                 |  50 ++++
 3sum/README.md                                |  23 ++
 .../4-median-of-two-sorted-arrays.cpp         |  47 ++++
 4-median-of-two-sorted-arrays/NOTES.md        |   1 +
 4-median-of-two-sorted-arrays/README.md       |  31 +++
 .../40-combination-sum-ii.cpp                 |  30 +++
 40-combination-sum-ii/NOTES.md                |   1 +
 40-combination-sum-ii/README.md               |  38 +++
 402-remove-k-digits/402-remove-k-digits.cpp   |  19 ++
 402-remove-k-digits/NOTES.md                  |   1 +
 402-remove-k-digits/README.md                 |  33 +++
 .../410-split-array-largest-sum.cpp           |  53 +++++
 410-split-array-largest-sum/NOTES.md          |   1 +
 410-split-array-largest-sum/README.md         |  36 +++
 415-add-strings/NOTES.md                      |   1 +
 415-add-strings/README.md                     |  32 +++
 .../416-partition-equal-subset-sum.cpp        |  38 +++
 416-partition-equal-subset-sum/NOTES.md       |   1 +
 416-partition-equal-subset-sum/README.md      |  25 ++
 .../42-trapping-rain-water.cpp                |  24 ++
 42-trapping-rain-water/NOTES.md               |   1 +
 ...maximum-xor-of-two-numbers-in-an-array.cpp |  22 ++
 .../NOTES.md                                  |   1 +
 .../438-find-all-anagrams-in-a-string.cpp     |  29 +++
 438-find-all-anagrams-in-a-string/NOTES.md    |   1 +
 438-find-all-anagrams-in-a-string/README.md   |  32 +++
 .../442-find-all-duplicates-in-an-array.cpp   |  16 ++
 442-find-all-duplicates-in-an-array/NOTES.md  |   1 +
 442-find-all-duplicates-in-an-array/README.md |  25 ++
 45-jump-game-ii/45-jump-game-ii.cpp           |  25 ++
 45-jump-game-ii/NOTES.md                      |   1 +
 45-jump-game-ii/README.md                     |  30 +++
 454-4sum-ii/454-4sum-ii.cpp                   |  23 ++
 454-4sum-ii/NOTES.md                          |   1 +
 454-4sum-ii/README.md                         |  36 +++
 458-poor-pigs/NOTES.md                        |   1 +
 458-poor-pigs/README.md                       |  33 +++
 46-permutations/46-permutations.cpp           |  27 +++
 46-permutations/NOTES.md                      |   1 +
 46-permutations/README.md                     |  22 ++
 .../472-concatenated-words.cpp                |  32 +++
 472-concatenated-words/NOTES.md               |   1 +
 472-concatenated-words/README.md              |  30 +++
 48-rotate-image/48-rotate-image.cpp           |  19 ++
 48-rotate-image/NOTES.md                      |   1 +
 48-rotate-image/README.md                     |  26 +++
 .../485-max-consecutive-ones.cpp              |  21 ++
 485-max-consecutive-ones/README.md            |  24 ++
 49-group-anagrams/49-group-anagrams.cpp       |  20 ++
 49-group-anagrams/NOTES.md                    |   1 +
 49-group-anagrams/README.md                   |  24 ++
 494-target-sum/494-target-sum.cpp             |  79 +++++++
 494-target-sum/NOTES.md                       |   1 +
 494-target-sum/README.md                      |  39 ++++
 .../496-next-greater-element-i.cpp            |  39 ++++
 496-next-greater-element-i/NOTES.md           |   1 +
 496-next-greater-element-i/README.md          |  40 ++++
 4sum-ii/4sum-ii.cpp                           |  23 ++
 4sum-ii/README.md                             |  36 +++
 4sum/4sum.cpp                                 |  54 +++++
 4sum/README.md                                |  32 +++
 50-powx-n/50-powx-n.cpp                       |  28 +++
 50-powx-n/NOTES.md                            |   1 +
 50-powx-n/README.md                           |  31 +++
 .../503-next-greater-element-ii.cpp           |  27 +++
 503-next-greater-element-ii/NOTES.md          |   1 +
 503-next-greater-element-ii/README.md         |  28 +++
 509-fibonacci-number/509-fibonacci-number.cpp |   8 +
 509-fibonacci-number/NOTES.md                 |   1 +
 509-fibonacci-number/README.md                |  37 +++
 51-n-queens/51-n-queens.cpp                   |  70 ++++++
 51-n-queens/NOTES.md                          |   1 +
 51-n-queens/README.md                         |  27 +++
 52-n-queens-ii/52-n-queens-ii.cpp             |  46 ++++
 52-n-queens-ii/NOTES.md                       |   1 +
 52-n-queens-ii/README.md                      |  25 ++
 520-detect-capital/520-detect-capital.cpp     |  10 +
 520-detect-capital/NOTES.md                   |   1 +
 520-detect-capital/README.md                  |  26 +++
 525-contiguous-array/525-contiguous-array.cpp |  14 ++
 525-contiguous-array/NOTES.md                 |   1 +
 525-contiguous-array/README.md                |  25 ++
 53-maximum-subarray/53-maximum-subarray.cpp   |  16 ++
 53-maximum-subarray/NOTES.md                  |   1 +
 53-maximum-subarray/README.md                 |  35 +++
 .../532-k-diff-pairs-in-an-array.cpp          |  23 ++
 532-k-diff-pairs-in-an-array/NOTES.md         |   1 +
 532-k-diff-pairs-in-an-array/README.md        |  43 ++++
 54-spiral-matrix/54-spiral-matrix.cpp         |  37 +++
 54-spiral-matrix/NOTES.md                     |   1 +
 54-spiral-matrix/README.md                    |  25 ++
 .../540-single-element-in-a-sorted-array.cpp  |  16 ++
 540-single-element-in-a-sorted-array/NOTES.md |   1 +
 .../README.md                                 |  22 ++
 543-diameter-of-binary-tree/NOTES.md          |   1 +
 543-diameter-of-binary-tree/README.md         |  28 +++
 55-jump-game/55-jump-game.cpp                 |  42 ++++
 55-jump-game/NOTES.md                         |   1 +
 55-jump-game/README.md                        |  27 +++
 .../556-next-greater-element-iii.cpp          |   9 +
 556-next-greater-element-iii/NOTES.md         |   1 +
 556-next-greater-element-iii/README.md        |  19 ++
 .../560-subarray-sum-equals-k.cpp             |  15 ++
 567-permutation-in-string/NOTES.md            |   1 +
 567-permutation-in-string/README.md           |  26 +++
 .../576-out-of-boundary-paths.cpp             |  29 +++
 576-out-of-boundary-paths/README.md           |  27 +++
 .../60-permutation-sequence.cpp               |  17 ++
 60-permutation-sequence/NOTES.md              |   1 +
 60-permutation-sequence/README.md             |  34 +++
 .../605-can-place-flowers.cpp                 |  14 ++
 605-can-place-flowers/NOTES.md                |   1 +
 605-can-place-flowers/README.md               |  22 ++
 61-rotate-list/NOTES.md                       |   1 +
 61-rotate-list/README.md                      |  24 ++
 62-unique-paths/NOTES.md                      |   1 +
 62-unique-paths/README.md                     |  30 +++
 63-unique-paths-ii/NOTES.md                   |   1 +
 63-unique-paths-ii/README.md                  |  35 +++
 64-minimum-path-sum/64-minimum-path-sum.cpp   |  24 ++
 64-minimum-path-sum/NOTES.md                  |   1 +
 64-minimum-path-sum/README.md                 |  28 +++
 650-2-keys-keyboard/650-2-keys-keyboard.cpp   |  24 ++
 650-2-keys-keyboard/NOTES.md                  |   1 +
 650-2-keys-keyboard/README.md                 |  33 +++
 66-plus-one/NOTES.md                          |   1 +
 .../662-maximum-width-of-binary-tree.cpp      |  40 ++++
 662-maximum-width-of-binary-tree/NOTES.md     |   1 +
 662-maximum-width-of-binary-tree/README.md    |  38 +++
 67-add-binary/NOTES.md                        |   1 +
 67-add-binary/README.md                       |  19 ++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  28 +++
 7 Segment Display - GFG/7-segment-display.cpp |  71 ++++++
 7 Segment Display - GFG/README.md             |  51 ++++
 70-climbing-stairs/NOTES.md                   |   1 +
 .../700-search-in-a-binary-search-tree.cpp    |  17 ++
 700-search-in-a-binary-search-tree/NOTES.md   |   1 +
 700-search-in-a-binary-search-tree/README.md  |  27 +++
 .../701-insert-into-a-binary-search-tree.cpp  |  33 +++
 701-insert-into-a-binary-search-tree/NOTES.md |   1 +
 .../README.md                                 |  36 +++
 704-binary-search/704-binary-search.cpp       |  28 +++
 704-binary-search/NOTES.md                    |   1 +
 704-binary-search/README.md                   |  29 +++
 71-simplify-path/71-simplify-path.cpp         |  40 ++++
 71-simplify-path/NOTES.md                     |   1 +
 71-simplify-path/README.md                    |  46 ++++
 724-find-pivot-index/724-find-pivot-index.cpp |  18 ++
 724-find-pivot-index/NOTES.md                 |   1 +
 724-find-pivot-index/README.md                |  47 ++++
 .../74-search-a-2d-matrix.cpp                 |  24 ++
 74-search-a-2d-matrix/NOTES.md                |   1 +
 74-search-a-2d-matrix/README.md               |  30 +++
 740-delete-and-earn/740-delete-and-earn.cpp   |  18 ++
 740-delete-and-earn/NOTES.md                  |   1 +
 740-delete-and-earn/README.md                 |  37 +++
 .../746-min-cost-climbing-stairs.cpp          |  17 ++
 75-sort-colors/75-sort-colors.cpp             |  24 ++
 75-sort-colors/NOTES.md                       |   1 +
 75-sort-colors/README.md                      |  31 +++
 763-partition-labels/763-partition-labels.cpp |  23 ++
 763-partition-labels/NOTES.md                 |   1 +
 763-partition-labels/README.md                |  31 +++
 78-subsets/78-subsets.cpp                     |  19 ++
 78-subsets/NOTES.md                           |   1 +
 78-subsets/README.md                          |  26 +++
 79-word-search/79-word-search.cpp             |  38 +++
 79-word-search/NOTES.md                       |   1 +
 79-word-search/README.md                      |  37 +++
 .../8-string-to-integer-atoi.cpp              |  34 +++
 8-string-to-integer-atoi/NOTES.md             |   1 +
 8-string-to-integer-atoi/README.md            |  74 ++++++
 ...remove-duplicates-from-sorted-array-ii.cpp |  10 +
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  51 ++++
 804-unique-morse-code-words/NOTES.md          |   1 +
 804-unique-morse-code-words/README.md         |  48 ++++
 ...-remove-duplicates-from-sorted-list-ii.cpp |  42 ++++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  24 ++
 823-binary-trees-with-factors/NOTES.md        |   1 +
 823-binary-trees-with-factors/README.md       |  28 +++
 .../84-largest-rectangle-in-histogram.cpp     |  72 ++++++
 84-largest-rectangle-in-histogram/NOTES.md    |   1 +
 84-largest-rectangle-in-histogram/README.md   |  25 ++
 847-shortest-path-visiting-all-nodes/NOTES.md |   1 +
 .../README.md                                 |  31 +++
 .../856-score-of-parentheses.cpp              |  21 ++
 856-score-of-parentheses/NOTES.md             |   1 +
 856-score-of-parentheses/README.md            |  38 +++
 858-mirror-reflection/NOTES.md                |   1 +
 858-mirror-reflection/README.md               |  29 +++
 .../875-koko-eating-bananas.cpp               |  22 ++
 .../876-middle-of-the-linked-list.cpp         |  26 +++
 .../881-boats-to-save-people.cpp              |  27 +++
 881-boats-to-save-people/NOTES.md             |   1 +
 881-boats-to-save-people/README.md            |  34 +++
 .../890-find-and-replace-pattern.cpp          |  18 ++
 890-find-and-replace-pattern/NOTES.md         |   1 +
 890-find-and-replace-pattern/README.md        |  31 +++
 .../895-maximum-frequency-stack.cpp           |  23 ++
 895-maximum-frequency-stack/NOTES.md          |   1 +
 895-maximum-frequency-stack/README.md         |  46 ++++
 90-subsets-ii/90-subsets-ii.cpp               |  28 +++
 90-subsets-ii/NOTES.md                        |   1 +
 90-subsets-ii/README.md                       |  20 ++
 916-word-subsets/NOTES.md                     |   1 +
 916-word-subsets/README.md                    |  35 +++
 .../NOTES.md                                  |   1 +
 .../README.md                                 |  37 +++
 .../946-validate-stack-sequences.cpp          |  15 ++
 946-validate-stack-sequences/NOTES.md         |   1 +
 946-validate-stack-sequences/README.md        |  32 +++
 .../977-squares-of-a-sorted-array.cpp         |  23 ++
 977-squares-of-a-sorted-array/NOTES.md        |   1 +
 977-squares-of-a-sorted-array/README.md       |  28 +++
 .../98-validate-binary-search-tree.cpp        |  31 +++
 98-validate-binary-search-tree/NOTES.md       |   1 +
 98-validate-binary-search-tree/README.md      |  32 +++
 .../981-time-based-key-value-store.cpp        |  37 +++
 983-minimum-cost-for-tickets/NOTES.md         |   1 +
 983-minimum-cost-for-tickets/README.md        |  51 ++++
 .../991-broken-calculator.cpp                 |  21 ++
 991-broken-calculator/NOTES.md                |   1 +
 991-broken-calculator/README.md               |  38 +++
 994-rotting-oranges/994-rotting-oranges.cpp   |  48 ++++
 994-rotting-oranges/NOTES.md                  |   1 +
 994-rotting-oranges/README.md                 |  43 ++++
 .../README.md                                 |  29 +++
 ...to-a-number-represented-as-linked-list.cpp | 119 ++++++++++
 .../README.md                                 |  55 +++++
 .../allocate-minimum-number-of-pages.cpp      |  89 +++++++
 Anagram of String - GFG/README.md             |  34 +++
 Anagram of String - GFG/anagram-of-string.cpp |  37 +++
 Array to BST - GFG/README.md                  |  50 ++++
 Array to BST - GFG/array-to-bst.cpp           |  46 ++++
 Biconnected Graph - GFG/README.md             |  53 +++++
 Biconnected Graph - GFG/biconnected-graph.cpp |  47 ++++
 Binary Array Sorting - GFG/README.md          |  47 ++++
 .../binary-array-sorting.cpp                  |  79 +++++++
 .../README.md                                 |  32 +++
 .../binary-number-to-decimal-number.cpp       |  31 +++
 Bitwise AND of the Array - GFG/README.md      |  40 ++++
 .../bitwise-and-of-the-array.cpp              |  64 ++++++
 Can Make Triangle - GFG/README.md             |  50 ++++
 Can Make Triangle - GFG/can-make-triangle.cpp |  52 +++++
 Check Mirror in N-ary tree - GFG/README.md    |  50 ++++
 .../check-mirror-in-nary-tree.cpp             |  52 +++++
 Check if subtree - GFG/README.md              |  49 ++++
 Check if subtree - GFG/check-if-subtree.cpp   | 160 +++++++++++++
 .../README.md                                 |  30 +++
 ...lone-a-stack-without-using-extra-space.cpp |  87 +++++++
 .../README.md                                 |  30 +++
 ...one-a-stack-without-usinig-extra-space.cpp |  62 +++++
 Coins of Geekland - GFG/README.md             |  40 ++++
 Coins of Geekland - GFG/coins-of-geekland.cpp |  70 ++++++
 Compute Before Matrix - GFG/README.md         |  54 +++++
 .../compute-before-matrix.cpp                 |  52 +++++
 Concatenate two numbers - GFG/README.md       |  46 ++++
 .../concatenate-two-numbers.cpp               |  62 +++++
 Corona Vaccine - GFG/README.md                |  52 +++++
 Corona Vaccine - GFG/corona-vaccine.cpp       | 155 +++++++++++++
 Counts Zeros Xor Pairs - GFG/README.md        |  43 ++++
 .../counts-zeros-xor-pairs.cpp                |  48 ++++
 Cousins of a given node - GFG/README.md       |  51 ++++
 .../cousins-of-a-given-node.cpp               | 217 ++++++++++++++++++
 .../README.md                                 |  41 ++++
 .../cyclically-rotate-an-array-by-one.cpp     |  39 ++++
 Escape the Forbidden Forest - GFG/README.md   |  42 ++++
 .../escape-the-forbidden-forest.cpp           |  53 +++++
 Even and Odd - GFG/README.md                  |  44 ++++
 Even and Odd - GFG/even-and-odd.cpp           |  75 ++++++
 Excel Sheet _ Part - 1 - GFG/README.md        |  25 ++
 .../excel-sheet-part-1.cpp                    |  50 ++++
 Find Missing And Repeating - GFG/README.md    |  36 +++
 .../find-missing-and-repeating.cpp            |  56 +++++
 Find Nth root of M - GFG/README.md            |  36 +++
 .../find-nth-root-of-m.cpp                    |  40 ++++
 Find Prime numbers in a range - GFG/README.md |  38 +++
 .../find-prime-numbers-in-a-range.cpp         |  49 ++++
 Find position of set bit - GFG/README.md      |  39 ++++
 .../find-position-of-set-bit.cpp              |  38 +++
 .../README.md                                 |  39 ++++
 .../find-rectangle-with-corners-as-1.cpp      |  69 ++++++
 .../README.md                                 |  50 ++++
 .../find-the-closest-element-in-bst.cpp       | 135 +++++++++++
 Find the Maximum Flow - GFG/README.md         |  51 ++++
 .../find-the-maximum-flow.cpp                 | 126 ++++++++++
 Find the number of islands - GFG/README.md    |  50 ++++
 .../find-the-number-of-islands.cpp            |  57 +++++
 Form a palindrome - GFG/README.md             |  40 ++++
 Form a palindrome - GFG/form-a-palindrome.cpp |  50 ++++
 Fraction Trouble - GFG/README.md              |  32 +++
 Fraction Trouble - GFG/fraction-trouble.cpp   |  38 +++
 Gadgets of Doraland - GFG/README.md           |  41 ++++
 .../gadgets-of-doraland.py                    |  38 +++
 Handshakes - GFG/README.md                    |  51 ++++
 Handshakes - GFG/handshakes.cpp               |  31 +++
 Height Using Parent Array - GFG/README.md     |  33 +++
 .../height-using-parent-array.cpp             |  50 ++++
 Help Classmates - GFG/README.md               |  44 ++++
 Help Classmates - GFG/help-classmates.cpp     |  60 +++++
 Hit most Balloons - GFG/README.md             |  42 ++++
 Hit most Balloons - GFG/hit-most-balloons.cpp |  85 +++++++
 Implement stack using array - GFG/README.md   |  43 ++++
 .../implement-stack-using-array.cpp           |  68 ++++++
 .../README.md                                 |  58 +++++
 .../implementing-dijkstra-algorithm.cpp       |  76 ++++++
 .../README.md                                 |  41 ++++
 .../insertion-sort-for-singly-linked-list.cpp | 105 +++++++++
 .../README.md                                 |  48 ++++
 .../kth-element-of-two-sorted-arrays.cpp      |  69 ++++++
 Kadane's Algorithm - GFG/README.md            |  44 ++++
 .../kadanes-algorithm.cpp                     |  56 +++++
 Kth smallest element - GFG/README.md          |  46 ++++
 .../kth-smallest-element.cpp                  |  45 ++++
 Largest subarray with 0 sum - GFG/README.md   |  25 ++
 .../largest-subarray-with-0-sum.cpp           |  56 +++++
 Largest value in each level - GFG/README.md   |  51 ++++
 .../largest-value-in-each-level.cpp           | 142 ++++++++++++
 Leaves to DLL - GFG/README.md                 |  61 +++++
 Leaves to DLL - GFG/leaves-to-dll.cpp         | 169 ++++++++++++++
 Left View of Binary Tree - GFG/README.md      |  42 ++++
 .../left-view-of-binary-tree.cpp              | 148 ++++++++++++
 .../README.md                                 |  41 ++++
 .../longest-common-prefix-in-an-array.cpp     |  56 +++++
 .../README.md                                 |  44 ++++
 ...longest-substring-to-form-a-palindrome.cpp |  43 ++++
 M-Coloring Problem - GFG/README.md            |  39 ++++
 .../mcoloring-problem.cpp                     |  66 ++++++
 Matrix Operations - GFG/README.md             |  49 ++++
 Matrix Operations - GFG/matrix-operations.cpp |  83 +++++++
 Maximum Winning score - GFG/README.md         |  53 +++++
 .../maximum-winning-score.cpp                 | 137 +++++++++++
 Maximum average subarray - GFG/README.md      |  39 ++++
 .../maximum-average-subarray.cpp              |  53 +++++
 ...-number-of-events-that-can-be-attended.cpp |  55 +++++
 Maximum selections - GFG/README.md            |  68 ++++++
 .../maximum-selections.cpp                    |  53 +++++
 .../README.md                                 |  34 +++
 ...ncreasing-order-elements-from-n-arrays.cpp |  62 +++++
 .../README.md                                 |  45 ++++
 .../median-in-a-rowwise-sorted-matrix.cpp     |  69 ++++++
 Merge K sorted linked lists - GFG/README.md   |  51 ++++
 .../merge-k-sorted-linked-lists.cpp           | 134 +++++++++++
 Min Coin - GFG/README.md                      |  39 ++++
 Min Coin - GFG/min-coin.cpp                   |  61 +++++
 Minimum Swaps to Sort - GFG/README.md         |  38 +++
 .../minimum-swaps-to-sort.cpp                 |  47 ++++
 .../README.md                                 |  30 +++
 ...-zeros-to-the-front-of-the-linked-list.cpp |  87 +++++++
 .../README.md                                 |  37 +++
 ...umbers-with-digits-in-increasing-order.cpp |  56 +++++
 Negative weight cycle - GFG/README.md         |  40 ++++
 .../negative-weight-cycle.cpp                 |  44 ++++
 Next Permutation - GFG/README.md              |  32 +++
 Next Permutation - GFG/next-permutation.cpp   |  67 ++++++
 Nodes at even distance - GFG/README.md        |  44 ++++
 .../nodes-at-even-distance.cpp                |  64 ++++++
 .../README.md                                 |  49 ++++
 ...words-with-k-maximum-contiguous-vowels.cpp |  86 +++++++
 Optimal binary search tree - GFG/README.md    |  56 +++++
 .../optimal-binary-search-tree.cpp            |  58 +++++
 Partition Equal Subset Sum - GFG/README.md    |  36 +++
 .../partition-equal-subset-sum.cpp            |  57 +++++
 Positive Negative Pair - GFG/README.md        |  40 ++++
 .../positive-negative-pair.cpp                |  69 ++++++
 Predecessor and Successor - GFG/README.md     |  33 +++
 .../predecessor-and-successor.cpp             | 134 +++++++++++
 Queries on Strings - GFG/README.md            |  35 +++
 .../queries-on-strings.cpp                    |  48 ++++
 Queue using two Stacks - GFG/README.md        |  57 +++++
 .../queue-using-two-stacks.cpp                |  82 +++++++
 Rank The Permutations - GFG/README.md         |  44 ++++
 .../rank-the-permutations.cpp                 |  49 ++++
 Rat in a Maze Problem - I - GFG/README.md     |  47 ++++
 .../rat-in-a-maze-problem-i.cpp               |  97 ++++++++
 .../README.md                                 |  46 ++++
 .../rearrange-geek-and-his-classmates.cpp     |  49 ++++
 .../README.md                                 |  38 +++
 ...emove-leading-zeros-from-an-ip-address.cpp |  58 +++++
 Return two prime numbers - GFG/README.md      |  33 +++
 .../return-two-prime-numbers.cpp              |  46 ++++
 .../README.md                                 |  57 +++++
 .../reverse-first-k-elements-of-queue.cpp     |  55 +++++
 .../README.md                                 |  41 ++++
 .../reverse-words-in-a-given-string.cpp       |  48 ++++
 Rotate by 90 degree - GFG/README.md           |  31 +++
 .../rotate-by-90-degree.cpp                   |  67 ++++++
 Search Pattern (Z-algorithm) - GFG/README.md  |  39 ++++
 .../search-pattern-zalgorithm.cpp             |  56 +++++
 Search a node in BST - GFG/README.md          |  49 ++++
 .../search-a-node-in-bst.cpp                  |  68 ++++++
 Shortest Path between Cities - GFG/README.md  |  51 ++++
 .../shortest-path-between-cities.cpp          |  35 +++
 .../README.md                                 |  47 ++++
 .../shortest-unique-prefix-for-every-word.cpp | 106 +++++++++
 Smallest Absolute Difference - GFG/README.md  |  47 ++++
 .../smallest-absolute-difference.cpp          |  52 +++++
 .../README.md                                 |  43 ++++
 ...allest-greater-elements-in-whole-array.cpp |  52 +++++
 .../README.md                                 |  39 ++++
 .../smallest-window-containing-0-1-and-2.cpp  |  52 +++++
 Sort a stack - GFG/README.md                  |  30 +++
 Sort a stack - GFG/sort-a-stack.cpp           |  74 ++++++
 .../README.md                                 |  42 ++++
 .../sort-an-array-of-0s-1s-and-2s.cpp         |  48 ++++
 Sort by Set Bit Count - GFG/README.md         |  63 +++++
 .../sort-by-set-bit-count.cpp                 |  54 +++++
 Special Matrix - GFG/README.md                |  40 ++++
 Special Matrix - GFG/special-matrix.cpp       |  53 +++++
 Spidey Sense - GFG/README.md                  |  52 +++++
 Spidey Sense - GFG/spidey-sense.cpp           |  78 +++++++
 Stack using two queues - GFG/README.md        |  44 ++++
 .../stack-using-two-queues.cpp                |  79 +++++++
 Subset Sums - GFG/README.md                   |  43 ++++
 Subset Sums - GFG/subset-sums.cpp             |  52 +++++
 Subsets - GFG/README.md                       |  54 +++++
 Subsets - GFG/subsets.cpp                     |  76 ++++++
 Swap Kth nodes from ends - GFG/README.md      |  50 ++++
 .../swap-kth-nodes-from-ends.cpp              | 138 +++++++++++
 .../README.md                                 |  49 ++++
 .../the-painters-partition-problem-ii.cpp     |  83 +++++++
 Transfiguration - GFG/README.md               |  46 ++++
 Triangle and Square - GFG/README.md           |  45 ++++
 .../triangle-and-square.cpp                   |  29 +++
 Union of two arrays - GFG/README.md           |  45 ++++
 .../union-of-two-arrays.cpp                   |  50 ++++
 Word Break - Part 2 - GFG/README.md           |  36 +++
 .../word-break-part-2.cpp                     |  83 +++++++
 XOR Game - GFG/README.md                      |  33 +++
 XOR Game - GFG/xor-game.cpp                   |  36 +++
 accounts-merge/README.md                      |  35 +++
 accounts-merge/accounts-merge.cpp             |  29 +++
 add-digits/README.md                          |  29 +++
 add-digits/add-digits.cpp                     |  16 ++
 add-strings/README.md                         |  32 +++
 add-strings/add-strings.cpp                   |  20 ++
 add-two-numbers/README.md                     |  33 +++
 add-two-numbers/add-two-numbers.cpp           |  58 +++++
 .../README.md                                 |  43 ++++
 ...ll-elements-in-two-binary-search-trees.cpp |  60 +++++
 all-paths-from-source-to-target/README.md     |  48 ++++
 .../all-paths-from-source-to-target.cpp       |  19 ++
 all-possible-full-binary-trees/README.md      |  26 +++
 .../all-possible-full-binary-trees.cpp        |  36 +++
 arranging-coins/README.md                     |  26 +++
 arranging-coins/arranging-coins.cpp           |  20 ++
 array-of-doubled-pairs/README.md              |  37 +++
 balance-a-binary-search-tree/README.md        |  26 +++
 balanced-binary-tree/README.md                |  35 +++
 balanced-binary-tree/balanced-binary-tree.cpp |  37 +++
 best-sightseeing-pair/README.md               |  28 +++
 .../best-sightseeing-pair.cpp                 |  12 +
 best-time-to-buy-and-sell-stock-ii/README.md  |  38 +++
 .../best-time-to-buy-and-sell-stock-ii.cpp    |   9 +
 best-time-to-buy-and-sell-stock-iii/README.md |  37 +++
 best-time-to-buy-and-sell-stock-iv/README.md  |  30 +++
 .../best-time-to-buy-and-sell-stock-iv.cpp    |  42 ++++
 .../README.md                                 |  32 +++
 ...me-to-buy-and-sell-stock-with-cooldown.cpp |  18 ++
 best-time-to-buy-and-sell-stock/README.md     |  30 +++
 .../best-time-to-buy-and-sell-stock.cpp       |  12 +
 .../README.md                                 |  46 ++++
 ...binary-search-tree-to-greater-sum-tree.cpp |  16 ++
 binary-search/README.md                       |  29 +++
 binary-search/binary-search.cpp               |  19 ++
 binary-tree-inorder-traversal/README.md       |  43 ++++
 .../binary-tree-inorder-traversal.cpp         |  27 +++
 binary-tree-level-order-traversal/README.md   |  29 +++
 .../binary-tree-level-order-traversal.cpp     |  81 +++++++
 binary-tree-maximum-path-sum/README.md        |  29 +++
 .../binary-tree-maximum-path-sum.cpp          |  17 ++
 binary-tree-paths/README.md                   |  25 ++
 binary-tree-paths/binary-tree-paths.cpp       |  41 ++++
 binary-tree-postorder-traversal/README.md     |  43 ++++
 binary-tree-preorder-traversal/README.md      |  44 ++++
 .../binary-tree-preorder-traversal.cpp        |  28 +++
 binary-tree-pruning/README.md                 |  34 +++
 binary-tree-right-side-view/README.md         |  29 +++
 .../binary-tree-right-side-view.cpp           |  41 ++++
 .../README.md                                 |  29 +++
 ...nary-tree-zigzag-level-order-traversal.cpp |  53 +++++
 binary-watch/README.md                        |  37 +++
 binary-watch/binary-watch.cpp                 |  25 ++
 build-array-from-permutation/README.md        |  35 +++
 .../build-array-from-permutation.cpp          |  13 ++
 burst-balloons/README.md                      |  30 +++
 burst-balloons/burst-balloons.cpp             |  29 +++
 climbing-stairs/README.md                     |  31 +++
 climbing-stairs/climbing-stairs.cpp           |  13 ++
 clone-graph/README.md                         |  65 ++++++
 coin-change-2/README.md                       |  43 ++++
 coin-change-2/coin-change-2.cpp               |  38 +++
 coin-change/README.md                         |  35 +++
 coin-change/coin-change.cpp                   |  17 ++
 combination-sum-iv/README.md                  |  40 ++++
 combination-sum-iv/combination-sum-iv.cpp     |  12 +
 combination-sum/README.md                     |  51 ++++
 combination-sum/combination-sum.cpp           |  26 +++
 combine-two-tables/README.md                  |  32 +++
 combine-two-tables/combine-two-tables.sql     |   4 +
 consecutive-characters/README.md              |  45 ++++
 .../consecutive-characters.cpp                |  27 +++
 .../README.md                                 |  28 +++
 ...e-from-inorder-and-postorder-traversal.cpp |  51 ++++
 .../README.md                                 |  28 +++
 ...ee-from-preorder-and-inorder-traversal.cpp |  51 ++++
 contains-duplicate-ii/README.md               |  30 +++
 .../contains-duplicate-ii.cpp                 |  14 ++
 contains-duplicate/README.md                  |  21 ++
 contains-duplicate/contains-duplicate.cpp     |  22 ++
 .../README.md                                 |  44 ++++
 ...ary-number-in-a-linked-list-to-integer.cpp |  22 ++
 .../README.md                                 |  29 +++
 ...ert-sorted-array-to-binary-search-tree.cpp |  38 +++
 copy-list-with-random-pointer/README.md       |  54 +++++
 .../copy-list-with-random-pointer.cpp         |  61 +++++
 count-number-of-teams/README.md               |  42 ++++
 count-sorted-vowel-strings/README.md          |  34 +++
 .../README.md                                 |  52 +++++
 ...ubstrings-that-differ-by-one-character.cpp |  54 +++++
 .../README.md                                 |  54 +++++
 course-schedule-ii/README.md                  |  42 ++++
 course-schedule-ii/course-schedule-ii.cpp     |  37 +++
 course-schedule/README.md                     |  36 +++
 custom-sort-string/README.md                  |  26 +++
 custom-sort-string/custom-sort-string.cpp     |  19 ++
 daily-temperatures/README.md                  |  21 ++
 daily-temperatures/daily-temperatures.cpp     |  16 ++
 decode-ways-ii/README.md                      |  59 +++++
 decode-ways/README.md                         |  60 +++++
 decode-ways/decode-ways.cpp                   |  26 +++
 deepest-leaves-sum/README.md                  |  22 ++
 deepest-leaves-sum/deepest-leaves-sum.cpp     |  31 +++
 delete-and-earn/README.md                     |  37 +++
 delete-leaves-with-a-given-value/README.md    |  53 +++++
 delete-node-in-a-bst/README.md                |  47 ++++
 delete-node-in-a-bst/delete-node-in-a-bst.cpp |  65 ++++++
 delete-node-in-a-linked-list/README.md        |  47 ++++
 .../delete-node-in-a-linked-list.cpp          |  17 ++
 destination-city/README.md                    |  41 ++++
 detonate-the-maximum-bombs/README.md          |  49 ++++
 .../detonate-the-maximum-bombs.cpp            |  38 +++
 di-string-match/README.md                     |  28 +++
 di-string-match/di-string-match.cpp           |   9 +
 diameter-of-binary-tree/README.md             |  28 +++
 .../diameter-of-binary-tree.cpp               |  40 ++++
 different-ways-to-add-parentheses/README.md   |  33 +++
 divide-two-integers/README.md                 |  43 ++++
 edit-distance/README.md                       |  41 ++++
 encode-and-decode-tinyurl/README.md           |  34 +++
 .../encode-and-decode-tinyurl.cpp             |  13 ++
 excel-sheet-column-title/README.md            |  45 ++++
 .../excel-sheet-column-title.cpp              |  24 ++
 fibonacci-number/README.md                    |  37 +++
 fibonacci-number/fibonacci-number.cpp         |   7 +
 .../README.md                                 |  52 +++++
 ...-a-binary-tree-in-a-clone-of-that-tree.cpp |  18 ++
 .../README.md                                 |  22 ++
 ...nd-all-numbers-disappeared-in-an-array.cpp |  15 ++
 find-center-of-star-graph/README.md           |  30 +++
 .../find-center-of-star-graph.cpp             |  22 ++
 .../README.md                                 |  27 +++
 ...st-position-of-element-in-sorted-array.cpp |  23 ++
 find-median-from-data-stream/README.md        |  50 ++++
 .../find-median-from-data-stream.cpp          |  26 +++
 .../README.md                                 |  36 +++
 ...ind-minimum-in-rotated-sorted-array-ii.cpp |  29 +++
 .../README.md                                 |  46 ++++
 .../find-minimum-in-rotated-sorted-array.cpp  |  21 ++
 find-peak-element/README.md                   |  30 +++
 find-peak-element/find-peak-element.cpp       |  15 ++
 .../README.md                                 |  60 +++++
 find-the-duplicate-number/README.md           |  38 +++
 .../find-the-duplicate-number.cpp             |  21 ++
 find-the-town-judge/README.md                 |  57 +++++
 find-the-town-judge/find-the-town-judge.cpp   |  37 +++
 .../README.md                                 |  43 ++++
 finding-the-users-active-minutes/README.md    |  42 ++++
 first-bad-version/README.md                   |  31 +++
 first-bad-version/first-bad-version.cpp       |  12 +
 .../README.md                                 |  77 +++++++
 ...latten-a-multilevel-doubly-linked-list.cpp |  25 ++
 flatten-binary-tree-to-linked-list/README.md  |  36 +++
 .../flatten-binary-tree-to-linked-list.cpp    |  37 +++
 .../README.md                                 |  38 +++
 flip-string-to-monotone-increasing/README.md  |  36 +++
 .../flip-string-to-monotone-increasing.cpp    |  14 ++
 flood-fill/README.md                          |  35 +++
 flood-fill/flood-fill.cpp                     |  36 +++
 fruit-into-baskets/README.md                  |  51 ++++
 generate-parentheses/README.md                |  17 ++
 generate-parentheses/generate-parentheses.cpp |  19 ++
 group-anagrams/README.md                      |  24 ++
 group-anagrams/group-anagrams.cpp             |  26 +++
 .../README.md                                 |  35 +++
 ...le-given-the-group-size-they-belong-to.cpp |  14 ++
 hamming-distance/README.md                    |  29 +++
 hamming-distance/hamming-distance.cpp         |  29 +++
 house-robber-ii/README.md                     |  34 +++
 house-robber-iii/README.md                    |  29 +++
 house-robber-iii/house-robber-iii.cpp         |  18 ++
 house-robber/README.md                        |  29 +++
 house-robber/house-robber.cpp                 |  21 ++
 increasing-order-search-tree/README.md        |  22 ++
 insert-into-a-binary-search-tree/README.md    |  36 +++
 .../insert-into-a-binary-search-tree.cpp      |  33 +++
 insertion-sort-list/README.md                 |  33 +++
 insertion-sort-list/insertion-sort-list.cpp   |  20 ++
 integer-break/README.md                       |  26 +++
 integer-break/integer-break.cpp               |  22 ++
 intersection-of-two-arrays/README.md          |  24 ++
 .../intersection-of-two-arrays.cpp            |  39 ++++
 intersection-of-two-linked-lists/README.md    |  63 +++++
 .../intersection-of-two-linked-lists.cpp      |  39 ++++
 interval-list-intersections/README.md         |  45 ++++
 .../interval-list-intersections.cpp           |  15 ++
 .../README.md                                 |  43 ++++
 invert-binary-tree/README.md                  |  29 +++
 invert-binary-tree/invert-binary-tree.cpp     |  27 +++
 is-graph-bipartite/README.md                  |  39 ++++
 is-graph-bipartite/is-graph-bipartite.cpp     |  53 +++++
 is-subsequence/README.md                      |  23 ++
 is-subsequence/is-subsequence.cpp             |  27 +++
 isomorphic-strings/README.md                  |  26 +++
 isomorphic-strings/isomorphic-strings.cpp     |  12 +
 iterator-for-combination/README.md            |  37 +++
 .../iterator-for-combination.cpp              |  24 ++
 jewels-and-stones/README.md                   |  21 ++
 jewels-and-stones/jewels-and-stones.cpp       |  24 ++
 jump-game-ii/README.md                        |  30 +++
 jump-game-ii/jump-game-ii.cpp                 |  17 ++
 jump-game/README.md                           |  27 +++
 k-closest-points-to-origin/README.md          |  33 +++
 .../k-closest-points-to-origin.cpp            |  12 +
 koko-eating-bananas/README.md                 |  36 +++
 kth-largest-element-in-an-array/README.md     |  20 ++
 kth-smallest-element-in-a-bst/README.md       |  27 +++
 .../kth-smallest-element-in-a-bst.cpp         |  60 +++++
 .../README.md                                 |  30 +++
 ...th-smallest-element-in-a-sorted-matrix.cpp |  29 +++
 .../README.md                                 |  37 +++
 ...argest-component-size-by-common-factor.cpp |  45 ++++
 .../README.md                                 |  33 +++
 .../letter-combinations-of-a-phone-number.cpp |  24 ++
 linked-list-cycle-ii/README.md                |  40 ++++
 linked-list-cycle/README.md                   |  40 ++++
 linked-list-cycle/linked-list-cycle.cpp       |  27 +++
 longest-common-subsequence/README.md          |  40 ++++
 .../longest-common-subsequence.cpp            |  11 +
 longest-consecutive-sequence/README.md        |  26 +++
 .../longest-consecutive-sequence.cpp          |  39 ++++
 longest-increasing-subsequence/README.md      |  35 +++
 .../longest-increasing-subsequence.cpp        |  12 +
 longest-palindromic-subsequence/README.md     |  27 +++
 longest-palindromic-substring/README.md       |  24 ++
 .../longest-palindromic-substring.cpp         |  18 ++
 .../README.md                                 |  29 +++
 .../README.md                                 |  39 ++++
 ...substring-without-repeating-characters.cpp |  36 +++
 longest-uncommon-subsequence-ii/README.md     |  27 +++
 .../README.md                                 |  36 +++
 ...ommon-ancestor-of-a-binary-search-tree.cpp |  29 +++
 .../README.md                                 |  36 +++
 ...owest-common-ancestor-of-a-binary-tree.cpp |  30 +++
 majority-element-ii/README.md                 |  32 +++
 majority-element-ii/majority-element-ii.cpp   |  59 +++++
 majority-element/README.md                    |  23 ++
 majority-element/majority-element.cpp         |  19 ++
 make-the-string-great/README.md               |  45 ++++
 .../make-the-string-great.cpp                 |  12 +
 matrix-block-sum/README.md                    |  31 +++
 matrix-block-sum/matrix-block-sum.cpp         |  81 +++++++
 max-area-of-island/README.md                  |  30 +++
 max-area-of-island/max-area-of-island.cpp     |  19 ++
 max-consecutive-ones-iii/README.md            |  27 +++
 .../max-consecutive-ones-iii.cpp              |  28 +++
 max-consecutive-ones/README.md                |  24 ++
 max-consecutive-ones/max-consecutive-ones.cpp |  29 +++
 maximal-rectangle/README.md                   |  44 ++++
 maximal-rectangle/maximal-rectangle.cpp       |  30 +++
 maximal-square/README.md                      |  31 +++
 maximal-square/maximal-square.cpp             |  23 ++
 maximum-69-number/README.md                   |  36 +++
 maximum-average-subarray-i/README.md          |  27 +++
 .../maximum-average-subarray-i.cpp            |  23 ++
 maximum-binary-tree/README.md                 |  42 ++++
 maximum-depth-of-binary-tree/README.md        |  37 +++
 .../maximum-depth-of-binary-tree.cpp          |  22 ++
 .../README.md                                 |  30 +++
 ...m-difference-between-node-and-ancestor.cpp |  19 ++
 .../README.md                                 |  52 +++++
 maximum-length-of-repeated-subarray/README.md |  24 ++
 .../README.md                                 |  48 ++++
 maximum-product-subarray/README.md            |  30 +++
 .../maximum-product-subarray.cpp              |  23 ++
 maximum-profit-in-job-scheduling/README.md    |  44 ++++
 .../maximum-profit-in-job-scheduling.cpp      |  16 ++
 maximum-score-from-removing-stones/README.md  |  49 ++++
 maximum-subarray/README.md                    |  32 +++
 maximum-subarray/maximum-subarray.cpp         |  14 ++
 maximum-sum-circular-subarray/README.md       |  51 ++++
 .../maximum-sum-circular-subarray.cpp         |  22 ++
 maximum-units-on-a-truck/README.md            |  39 ++++
 .../maximum-units-on-a-truck.cpp              |  19 ++
 median-of-two-sorted-arrays/README.md         |  49 ++++
 .../median-of-two-sorted-arrays.cpp           |  29 +++
 merge-intervals/README.md                     |  26 +++
 merge-intervals/merge-intervals.cpp           |  22 ++
 merge-k-sorted-lists/README.md                |  43 ++++
 merge-k-sorted-lists/merge-k-sorted-lists.cpp |  59 +++++
 merge-sorted-array/README.md                  |  46 ++++
 merge-sorted-array/merge-sorted-array.cpp     |  32 +++
 merge-two-binary-trees/README.md              |  29 +++
 .../merge-two-binary-trees.cpp                |  29 +++
 merge-two-sorted-lists/README.md              |  30 +++
 .../merge-two-sorted-lists.cpp                |  54 +++++
 middle-of-the-linked-list/README.md           |  27 +++
 .../middle-of-the-linked-list.cpp             |  26 +++
 min-cost-climbing-stairs/README.md            |  38 +++
 .../min-cost-climbing-stairs.cpp              |  18 ++
 minimum-absolute-difference-in-bst/README.md  |  26 +++
 .../minimum-absolute-difference-in-bst.cpp    |  41 ++++
 .../README.md                                 |  42 ++++
 ...ost-to-move-chips-to-the-same-position.cpp |   9 +
 minimum-depth-of-binary-tree/README.md        |  27 +++
 .../minimum-depth-of-binary-tree.cpp          |  44 ++++
 minimum-distance-between-bst-nodes/README.md  |  26 +++
 .../minimum-distance-between-bst-nodes.cpp    |  38 +++
 minimum-falling-path-sum/README.md            |  28 +++
 .../minimum-falling-path-sum.cpp              |  29 +++
 minimum-height-trees/README.md                |  46 ++++
 .../README.md                                 |  64 ++++++
 .../README.md                                 |  49 ++++
 ...r-of-steps-to-make-two-strings-anagram.cpp |  16 ++
 .../README.md                                 |  28 +++
 .../README.md                                 |  61 +++++
 ...rations-to-make-the-array-k-increasing.cpp |  25 ++
 minimum-path-sum/README.md                    |  28 +++
 minimum-path-sum/minimum-path-sum.cpp         |  29 +++
 minimum-size-subarray-sum/README.md           |  33 +++
 .../minimum-size-subarray-sum.cpp             |  23 ++
 .../README.md                                 |  41 ++++
 ...value-to-get-positive-step-by-step-sum.cpp |  12 +
 minimum-window-substring/README.md            |  41 ++++
 .../minimum-window-substring.cpp              |  52 +++++
 move-zeroes/README.md                         |  22 ++
 move-zeroes/move-zeroes.cpp                   |  18 ++
 multiply-strings/README.md                    |  21 ++
 multiply-strings/multiply-strings.cpp         |  23 ++
 n-ary-tree-level-order-traversal/README.md    |  29 +++
 .../n-ary-tree-level-order-traversal.cpp      |  18 ++
 n-ary-tree-preorder-traversal/README.md       |  33 +++
 .../n-ary-tree-preorder-traversal.cpp         |  41 ++++
 n-th-tribonacci-number/README.md              |  29 +++
 .../n-th-tribonacci-number.cpp                |  14 ++
 nCr mod M _ Part 1 - GFG/README.md            |  34 +++
 .../n-cr-mod-m-part-1.cpp                     |  69 ++++++
 next-greater-element-i/README.md              |  40 ++++
 .../next-greater-element-i.cpp                |  51 ++++
 next-greater-element-ii/README.md             |  28 +++
 .../next-greater-element-ii.cpp               |  29 +++
 next-permutation/README.md                    |  28 +++
 next-permutation/next-permutation.cpp         |  36 +++
 number-of-1-bits/README.md                    |  40 ++++
 number-of-islands/README.md                   |  37 +++
 number-of-islands/number-of-islands.cpp       |  33 +++
 number-of-provinces/README.md                 |  33 +++
 number-of-provinces/number-of-provinces.cpp   |  37 +++
 .../README.md                                 |  43 ++++
 odd-even-linked-list/README.md                |  30 +++
 odd-even-linked-list/odd-even-linked-list.cpp |  41 ++++
 .../README.md                                 |  30 +++
 ...s-with-total-durations-divisible-by-60.cpp |  13 ++
 palindrome-linked-list/README.md              |  25 ++
 .../palindrome-linked-list.cpp                |  60 +++++
 palindrome-partitioning-ii/README.md          |  32 +++
 partition-array-for-maximum-sum/README.md     |  33 +++
 .../partition-array-for-maximum-sum.cpp       |  12 +
 .../README.md                                 |  42 ++++
 ...artition-array-into-disjoint-intervals.cpp |  16 ++
 pascals-triangle-ii/README.md                 |  25 ++
 pascals-triangle/README.md                    |  19 ++
 pascals-triangle/pascals-triangle.cpp         |  38 +++
 patching-array/README.md                      |  39 ++++
 patching-array/patching-array.cpp             |  15 ++
 path-sum-ii/README.md                         |  35 +++
 path-sum-ii/path-sum-ii.cpp                   |  30 +++
 path-sum/README.md                            |  32 +++
 path-sum/path-sum.cpp                         |  23 ++
 perfect-squares/README.md                     |  26 +++
 perfect-squares/perfect-squares.cpp           |  27 +++
 permutations-ii/README.md                     |  26 +++
 permutations-ii/permutations-ii.cpp           |  21 ++
 .../README.md                                 |  44 ++++
 ...ating-next-right-pointers-in-each-node.cpp |  34 +++
 ...ting-next-right-pointers-in-each-node.java |  18 ++
 power-of-four/README.md                       |  24 ++
 power-of-four/power-of-four.cpp               |  12 +
 power-of-three/README.md                      |  27 +++
 power-of-three/power-of-three.cpp             |  19 ++
 power-of-two/README.md                        |  46 ++++
 power-of-two/power-of-two.cpp                 |  18 ++
 powx-n/README.md                              |  31 +++
 powx-n/powx-n.cpp                             |  18 ++
 product-of-array-except-self/README.md        |  26 +++
 .../product-of-array-except-self.cpp          |  26 +++
 product-of-the-last-k-numbers/README.md       |  46 ++++
 push-dominoes/README.md                       |  41 ++++
 push-dominoes/push-dominoes.cpp               |  37 +++
 range-addition-ii/README.md                   |  35 +++
 range-addition-ii/range-addition-ii.cpp       |  10 +
 range-sum-of-bst/README.md                    |  27 +++
 range-sum-of-bst/range-sum-of-bst.cpp         |  32 +++
 range-sum-query-2d-immutable/README.md        |  42 ++++
 .../range-sum-query-2d-immutable.cpp          |  26 +++
 range-sum-query-immutable/README.md           |  39 ++++
 rank-transform-of-a-matrix/README.md          |  58 +++++
 .../rank-transform-of-a-matrix.cpp            | 124 ++++++++++
 remove-boxes/README.md                        |  39 ++++
 remove-duplicates-from-sorted-array/README.md |  51 ++++
 .../remove-duplicates-from-sorted-array.cpp   |  26 +++
 remove-linked-list-elements/README.md         |  30 +++
 .../remove-linked-list-elements.cpp           |  38 +++
 remove-nth-node-from-end-of-list/README.md    |  34 +++
 .../remove-nth-node-from-end-of-list.cpp      |  39 ++++
 reorder-list/README.md                        |  33 +++
 reverse-linked-list/README.md                 |  32 +++
 reverse-linked-list/reverse-linked-list.cpp   |  22 ++
 reverse-nodes-in-k-group/README.md            |  43 ++++
 .../reverse-nodes-in-k-group.cpp              |  25 ++
 reverse-pairs/README.md                       |  20 ++
 reverse-pairs/reverse-pairs.cpp               | 130 +++++++++++
 reverse-words-in-a-string-iii/README.md       |  21 ++
 robot-return-to-origin/README.md              |  41 ++++
 .../robot-return-to-origin.cpp                |  16 ++
 roman-to-integer/README.md                    |  65 ++++++
 roman-to-integer/roman-to-integer.cpp         |  28 +++
 rotate-array/README.md                        |  39 ++++
 rotate-array/rotate-array.cpp                 |  13 ++
 rotate-image/README.md                        |  39 ++++
 rotate-image/rotate-image.cpp                 |  26 +++
 rotate-list/README.md                         |  24 ++
 rotate-list/rotate-list.cpp                   |  53 +++++
 rotated-digits/README.md                      |  20 ++
 rotated-digits/rotated-digits.cpp             |  20 ++
 rotting-oranges/README.md                     |  43 ++++
 rotting-oranges/rotting-oranges.cpp           |  49 ++++
 same-tree/README.md                           |  31 +++
 same-tree/same-tree.cpp                       |  27 +++
 search-a-2d-matrix-ii/README.md               |  33 +++
 .../search-a-2d-matrix-ii.cpp                 |  26 +++
 search-a-2d-matrix/README.md                  |  30 +++
 search-a-2d-matrix/search-a-2d-matrix.cpp     |  36 +++
 search-in-rotated-sorted-array/README.md      |  30 +++
 .../search-in-rotated-sorted-array.cpp        |  33 +++
 search-insert-position/README.md              |  31 +++
 .../search-insert-position.cpp                |   6 +
 second-highest-salary/README.md               |  20 ++
 .../second-highest-salary.sql                 |   3 +
 set-matrix-zeroes/README.md                   |  36 +++
 set-matrix-zeroes/set-matrix-zeroes.cpp       |  35 +++
 shuffle-an-array/README.md                    |  39 ++++
 shuffle-an-array/shuffle-an-array.cpp         |  22 ++
 single-element-in-a-sorted-array/README.md    |  22 ++
 .../single-element-in-a-sorted-array.cpp      |  58 +++++
 single-number-iii/README.md                   |  33 +++
 single-number-iii/single-number-iii.cpp       |  33 +++
 slowest-key/README.md                         |  48 ++++
 slowest-key/slowest-key.cpp                   |  15 ++
 smallest-integer-divisible-by-k/README.md     |  35 +++
 .../smallest-integer-divisible-by-k.cpp       |   9 +
 sort-an-array/README.md                       |  18 ++
 sort-an-array/sort-an-array.cpp               |   8 +
 sort-characters-by-frequency/README.md        |  37 +++
 .../sort-characters-by-frequency.cpp          |  12 +
 sort-colors/README.md                         |  32 +++
 sort-colors/sort-colors.cpp                   |  32 +++
 .../README.md                                 |  49 ++++
 spiral-matrix/README.md                       |  25 ++
 spiral-matrix/spiral-matrix.cpp               |  35 +++
 sqrtx/README.md                               |  26 +++
 sqrtx/sqrtx.cpp                               |   6 +
 squares-of-a-sorted-array/README.md           |  28 +++
 .../squares-of-a-sorted-array.cpp             |  13 ++
 stone-game/README.md                          |  31 +++
 stone-game/stone-game.cpp                     |  10 +
 subsets/README.md                             |  26 +++
 subsets/subsets.cpp                           |  35 +++
 sum-of-left-leaves/README.md                  |  24 ++
 sum-of-left-leaves/sum-of-left-leaves.cpp     |  28 +++
 .../README.md                                 |  21 ++
 ...-of-nodes-with-even-valued-grandparent.cpp |  16 ++
 sum-of-square-numbers/README.md               |  41 ++++
 .../sum-of-square-numbers.cpp                 |  20 ++
 sum-root-to-leaf-numbers/README.md            |  43 ++++
 surrounded-regions/README.md                  |  28 +++
 surrounded-regions/surrounded-regions.cpp     |  42 ++++
 symmetric-tree/README.md                      |  25 ++
 three-equal-parts/README.md                   |  34 +++
 three-equal-parts/three-equal-parts.cpp       |  19 ++
 total-hamming-distance/README.md              |  30 +++
 trapping-rain-water/README.md                 |  25 ++
 trapping-rain-water/trapping-rain-water.cpp   |  32 +++
 triangle/README.md                            |  35 +++
 trim-a-binary-search-tree/README.md           |  46 ++++
 .../trim-a-binary-search-tree.cpp             |  11 +
 two-sum-ii-input-array-is-sorted/README.md    |  39 ++++
 .../two-sum-ii-input-array-is-sorted.cpp      |  18 ++
 two-sum-iv-input-is-a-bst/README.md           |  43 ++++
 .../two-sum-iv-input-is-a-bst.cpp             |  12 +
 two-sum/README.md                             |  38 +++
 two-sum/two-sum.cpp                           |  22 ++
 ugly-number-ii/README.md                      |  26 +++
 ugly-number-ii/ugly-number-ii.cpp             |  15 ++
 unique-binary-search-trees-ii/README.md       |  22 ++
 unique-binary-search-trees/README.md          |  22 ++
 .../unique-binary-search-trees.cpp            |  21 ++
 unique-paths-ii/README.md                     |  35 +++
 unique-paths-iii/README.md                    |  52 +++++
 unique-paths-iii/unique-paths-iii.cpp         |  35 +++
 unique-paths/README.md                        |  44 ++++
 unique-paths/unique-paths.cpp                 |  12 +
 valid-palindrome/README.md                    |  25 ++
 valid-palindrome/valid-palindrome.cpp         |  17 ++
 valid-parentheses/README.md                   |  48 ++++
 valid-parentheses/valid-parentheses.cpp       |  53 +++++
 valid-sudoku/README.md                        |  56 +++++
 valid-sudoku/valid-sudoku.cpp                 |  20 ++
 valid-triangle-number/README.md               |  27 +++
 .../valid-triangle-number.cpp                 |  21 ++
 validate-binary-search-tree/README.md         |  32 +++
 .../validate-binary-search-tree.cpp           |  43 ++++
 .../README.md                                 |  35 +++
 ...reorder-serialization-of-a-binary-tree.cpp |  16 ++
 walking-robot-simulation-ii/README.md         |  55 +++++
 .../walking-robot-simulation-ii.cpp           |  28 +++
 wiggle-subsequence/README.md                  |  44 ++++
 wiggle-subsequence/wiggle-subsequence.cpp     |  15 ++
 wildcard-matching/README.md                   |  40 ++++
 word-break/README.md                          |  37 +++
 word-break/word-break.cpp                     |  16 ++
 word-ladder/README.md                         |  38 +++
 word-search/README.md                         |  37 +++
 xor-queries-of-a-subarray/README.md           |  35 +++
 1267 files changed, 40117 insertions(+)
 create mode 100644 01-matrix/README.md
 create mode 100644 1's Complement - GFG/1s-complement.cpp
 create mode 100644 1's Complement - GFG/README.md
 create mode 100644 1-two-sum/1-two-sum.cpp
 create mode 100644 1-two-sum/NOTES.md
 create mode 100644 1-two-sum/README.md
 create mode 100644 100-same-tree/NOTES.md
 create mode 100644 100-same-tree/README.md
 create mode 100644 1009-complement-of-base-10-integer/1009-complement-of-base-10-integer.cpp
 create mode 100644 1009-complement-of-base-10-integer/NOTES.md
 create mode 100644 1009-complement-of-base-10-integer/README.md
 create mode 100644 1010-pairs-of-songs-with-total-durations-divisible-by-60/1010-pairs-of-songs-with-total-durations-divisible-by-60.cpp
 create mode 100644 1010-pairs-of-songs-with-total-durations-divisible-by-60/NOTES.md
 create mode 100644 1010-pairs-of-songs-with-total-durations-divisible-by-60/README.md
 create mode 100644 1011-capacity-to-ship-packages-within-d-days/1011-capacity-to-ship-packages-within-d-days.cpp
 create mode 100644 1011-capacity-to-ship-packages-within-d-days/NOTES.md
 create mode 100644 1011-capacity-to-ship-packages-within-d-days/README.md
 create mode 100644 102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.cpp
 create mode 100644 102-binary-tree-level-order-traversal/NOTES.md
 create mode 100644 102-binary-tree-level-order-traversal/README.md
 create mode 100644 1022-sum-of-root-to-leaf-binary-numbers/1022-sum-of-root-to-leaf-binary-numbers.cpp
 create mode 100644 1022-sum-of-root-to-leaf-binary-numbers/NOTES.md
 create mode 100644 1022-sum-of-root-to-leaf-binary-numbers/README.md
 create mode 100644 1029-two-city-scheduling/1029-two-city-scheduling.cpp
 create mode 100644 1029-two-city-scheduling/NOTES.md
 create mode 100644 1029-two-city-scheduling/README.md
 create mode 100644 103-binary-tree-zigzag-level-order-traversal/NOTES.md
 create mode 100644 103-binary-tree-zigzag-level-order-traversal/README.md
 create mode 100644 104-maximum-depth-of-binary-tree/104-maximum-depth-of-binary-tree.cpp
 create mode 100644 104-maximum-depth-of-binary-tree/NOTES.md
 create mode 100644 104-maximum-depth-of-binary-tree/README.md
 create mode 100644 1041-robot-bounded-in-circle/1041-robot-bounded-in-circle.cpp
 create mode 100644 1041-robot-bounded-in-circle/NOTES.md
 create mode 100644 1041-robot-bounded-in-circle/README.md
 create mode 100644 1049-last-stone-weight-ii/1049-last-stone-weight-ii.cpp
 create mode 100644 1049-last-stone-weight-ii/NOTES.md
 create mode 100644 1049-last-stone-weight-ii/README.md
 create mode 100644 105-construct-binary-tree-from-preorder-and-inorder-traversal/105-construct-binary-tree-from-preorder-and-inorder-traversal.cpp
 create mode 100644 105-construct-binary-tree-from-preorder-and-inorder-traversal/NOTES.md
 create mode 100644 105-construct-binary-tree-from-preorder-and-inorder-traversal/README.md
 create mode 100644 108-convert-sorted-array-to-binary-search-tree/108-convert-sorted-array-to-binary-search-tree.cpp
 create mode 100644 108-convert-sorted-array-to-binary-search-tree/NOTES.md
 create mode 100644 108-convert-sorted-array-to-binary-search-tree/README.md
 create mode 100644 1094-car-pooling/1094-car-pooling.cpp
 create mode 100644 1094-car-pooling/NOTES.md
 create mode 100644 1094-car-pooling/README.md
 create mode 100644 11-container-with-most-water/11-container-with-most-water.cpp
 create mode 100644 11-container-with-most-water/NOTES.md
 create mode 100644 11-container-with-most-water/README.md
 create mode 100644 110-balanced-binary-tree/110-balanced-binary-tree.cpp
 create mode 100644 110-balanced-binary-tree/NOTES.md
 create mode 100644 110-balanced-binary-tree/README.md
 create mode 100644 1111-maximum-nesting-depth-of-two-valid-parentheses-strings/NOTES.md
 create mode 100644 1111-maximum-nesting-depth-of-two-valid-parentheses-strings/README.md
 create mode 100644 114-flatten-binary-tree-to-linked-list/114-flatten-binary-tree-to-linked-list.cpp
 create mode 100644 114-flatten-binary-tree-to-linked-list/NOTES.md
 create mode 100644 114-flatten-binary-tree-to-linked-list/README.md
 create mode 100644 115-distinct-subsequences/115-distinct-subsequences.cpp
 create mode 100644 115-distinct-subsequences/NOTES.md
 create mode 100644 115-distinct-subsequences/README.md
 create mode 100644 116-populating-next-right-pointers-in-each-node/NOTES.md
 create mode 100644 116-populating-next-right-pointers-in-each-node/README.md
 create mode 100644 118-pascals-triangle/NOTES.md
 create mode 100644 118-pascals-triangle/README.md
 create mode 100644 120-triangle/120-triangle.cpp
 create mode 100644 120-triangle/NOTES.md
 create mode 100644 120-triangle/README.md
 create mode 100644 121-best-time-to-buy-and-sell-stock/121-best-time-to-buy-and-sell-stock.cpp
 create mode 100644 121-best-time-to-buy-and-sell-stock/NOTES.md
 create mode 100644 121-best-time-to-buy-and-sell-stock/README.md
 create mode 100644 122-best-time-to-buy-and-sell-stock-ii/122-best-time-to-buy-and-sell-stock-ii.cpp
 create mode 100644 122-best-time-to-buy-and-sell-stock-ii/NOTES.md
 create mode 100644 122-best-time-to-buy-and-sell-stock-ii/README.md
 create mode 100644 1220-count-vowels-permutation/1220-count-vowels-permutation.cpp
 create mode 100644 1220-count-vowels-permutation/NOTES.md
 create mode 100644 1220-count-vowels-permutation/README.md
 create mode 100644 123-best-time-to-buy-and-sell-stock-iii/123-best-time-to-buy-and-sell-stock-iii.cpp
 create mode 100644 123-best-time-to-buy-and-sell-stock-iii/NOTES.md
 create mode 100644 123-best-time-to-buy-and-sell-stock-iii/README.md
 create mode 100644 1249-minimum-remove-to-make-valid-parentheses/1249-minimum-remove-to-make-valid-parentheses.cpp
 create mode 100644 1249-minimum-remove-to-make-valid-parentheses/README.md
 create mode 100644 126-word-ladder-ii/126-word-ladder-ii.cpp
 create mode 100644 126-word-ladder-ii/NOTES.md
 create mode 100644 126-word-ladder-ii/README.md
 create mode 100644 127-word-ladder/127-word-ladder.cpp
 create mode 100644 127-word-ladder/NOTES.md
 create mode 100644 127-word-ladder/README.md
 create mode 100644 1283-find-the-smallest-divisor-given-a-threshold/1283-find-the-smallest-divisor-given-a-threshold.cpp
 create mode 100644 1283-find-the-smallest-divisor-given-a-threshold/NOTES.md
 create mode 100644 1283-find-the-smallest-divisor-given-a-threshold/README.md
 create mode 100644 1288-remove-covered-intervals/1288-remove-covered-intervals.cpp
 create mode 100644 1288-remove-covered-intervals/NOTES.md
 create mode 100644 1288-remove-covered-intervals/README.md
 create mode 100644 1291-sequential-digits/1291-sequential-digits.cpp
 create mode 100644 1291-sequential-digits/NOTES.md
 create mode 100644 1291-sequential-digits/README.md
 create mode 100644 13-Roman-to-Integer/13-roman-to-integer.cpp
 create mode 100644 13-Roman-to-Integer/NOTES.md
 create mode 100644 1305-all-elements-in-two-binary-search-trees/1305-all-elements-in-two-binary-search-trees.cpp
 create mode 100644 1305-all-elements-in-two-binary-search-trees/NOTES.md
 create mode 100644 1305-all-elements-in-two-binary-search-trees/README.md
 create mode 100644 131-palindrome-partitioning/131-palindrome-partitioning.cpp
 create mode 100644 131-palindrome-partitioning/NOTES.md
 create mode 100644 131-palindrome-partitioning/README.md
 create mode 100644 133-clone-graph/NOTES.md
 create mode 100644 133-clone-graph/README.md
 create mode 100644 1337-the-k-weakest-rows-in-a-matrix/1337-the-k-weakest-rows-in-a-matrix.cpp
 create mode 100644 1337-the-k-weakest-rows-in-a-matrix/NOTES.md
 create mode 100644 1337-the-k-weakest-rows-in-a-matrix/README.md
 create mode 100644 134-gas-station/NOTES.md
 create mode 100644 134-gas-station/README.md
 create mode 100644 1359-count-all-valid-pickup-and-delivery-options/1359-count-all-valid-pickup-and-delivery-options.cpp
 create mode 100644 1359-count-all-valid-pickup-and-delivery-options/README.md
 create mode 100644 136-single-number/136-single-number.cpp
 create mode 100644 136-single-number/README.md
 create mode 100644 138-copy-list-with-random-pointer/138-copy-list-with-random-pointer.cpp
 create mode 100644 138-copy-list-with-random-pointer/NOTES.md
 create mode 100644 138-copy-list-with-random-pointer/README.md
 create mode 100644 1381-design-a-stack-with-increment-operation/NOTES.md
 create mode 100644 1381-design-a-stack-with-increment-operation/README.md
 create mode 100644 139-word-break/README.md
 create mode 100644 141-linked-list-cycle/141-linked-list-cycle.cpp
 create mode 100644 141-linked-list-cycle/NOTES.md
 create mode 100644 141-linked-list-cycle/README.md
 create mode 100644 142-linked-list-cycle-ii/142-linked-list-cycle-ii.cpp
 create mode 100644 142-linked-list-cycle-ii/NOTES.md
 create mode 100644 142-linked-list-cycle-ii/README.md
 create mode 100644 1423-maximum-points-you-can-obtain-from-cards/1423-maximum-points-you-can-obtain-from-cards.cpp
 create mode 100644 1423-maximum-points-you-can-obtain-from-cards/NOTES.md
 create mode 100644 1423-maximum-points-you-can-obtain-from-cards/README.md
 create mode 100644 144-binary-tree-preorder-traversal/NOTES.md
 create mode 100644 144-binary-tree-preorder-traversal/README.md
 create mode 100644 146-lru-cache/146-lru-cache.cpp
 create mode 100644 146-lru-cache/NOTES.md
 create mode 100644 146-lru-cache/README.md
 create mode 100644 1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.cpp
 create mode 100644 1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/NOTES.md
 create mode 100644 1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/README.md
 create mode 100644 1472-design-browser-history/1472-design-browser-history.cpp
 create mode 100644 1472-design-browser-history/NOTES.md
 create mode 100644 1472-design-browser-history/README.md
 create mode 100644 148-sort-list/148-sort-list.cpp
 create mode 100644 148-sort-list/NOTES.md
 create mode 100644 148-sort-list/README.md
 create mode 100644 1510-stone-game-iv/1510-stone-game-iv.cpp
 create mode 100644 1510-stone-game-iv/NOTES.md
 create mode 100644 1510-stone-game-iv/README.md
 create mode 100644 153-find-minimum-in-rotated-sorted-array/153-find-minimum-in-rotated-sorted-array.cpp
 create mode 100644 153-find-minimum-in-rotated-sorted-array/NOTES.md
 create mode 100644 153-find-minimum-in-rotated-sorted-array/README.md
 create mode 100644 154-find-minimum-in-rotated-sorted-array-ii/154-find-minimum-in-rotated-sorted-array-ii.cpp
 create mode 100644 154-find-minimum-in-rotated-sorted-array-ii/NOTES.md
 create mode 100644 154-find-minimum-in-rotated-sorted-array-ii/README.md
 create mode 100644 155-min-stack/155-min-stack.cpp
 create mode 100644 155-min-stack/NOTES.md
 create mode 100644 155-min-stack/README.md
 create mode 100644 1552-magnetic-force-between-two-balls/1552-magnetic-force-between-two-balls.cpp
 create mode 100644 1552-magnetic-force-between-two-balls/NOTES.md
 create mode 100644 1552-magnetic-force-between-two-balls/README.md
 create mode 100644 16-3sum-closest/16-3sum-closest.cpp
 create mode 100644 16-3sum-closest/NOTES.md
 create mode 100644 160-intersection-of-two-linked-lists/160-intersection-of-two-linked-lists.cpp
 create mode 100644 160-intersection-of-two-linked-lists/README.md
 create mode 100644 162-find-peak-element/162-find-peak-element.cpp
 create mode 100644 162-find-peak-element/NOTES.md
 create mode 100644 162-find-peak-element/README.md
 create mode 100644 165-compare-version-numbers/README.md
 create mode 100644 1672-richest-customer-wealth/1672-richest-customer-wealth.cpp
 create mode 100644 1672-richest-customer-wealth/NOTES.md
 create mode 100644 1672-richest-customer-wealth/README.md
 create mode 100644 1675-minimize-deviation-in-array/NOTES.md
 create mode 100644 1675-minimize-deviation-in-array/README.md
 create mode 100644 169-majority-element/169-majority-element.cpp
 create mode 100644 169-majority-element/NOTES.md
 create mode 100644 169-majority-element/README.md
 create mode 100644 171-excel-sheet-column-number/171-excel-sheet-column-number.cpp
 create mode 100644 171-excel-sheet-column-number/NOTES.md
 create mode 100644 171-excel-sheet-column-number/README.md
 create mode 100644 1760-minimum-limit-of-balls-in-a-bag/1760-minimum-limit-of-balls-in-a-bag.cpp
 create mode 100644 1760-minimum-limit-of-balls-in-a-bag/NOTES.md
 create mode 100644 1760-minimum-limit-of-balls-in-a-bag/README.md
 create mode 100644 179-largest-number/179-largest-number.cpp
 create mode 100644 179-largest-number/NOTES.md
 create mode 100644 179-largest-number/README.md
 create mode 100644 18-4sum/18-4sum.cpp
 create mode 100644 18-4sum/NOTES.md
 create mode 100644 18-4sum/README.md
 create mode 100644 1823-find-the-winner-of-the-circular-game/1823-find-the-winner-of-the-circular-game.cpp
 create mode 100644 1823-find-the-winner-of-the-circular-game/NOTES.md
 create mode 100644 1823-find-the-winner-of-the-circular-game/README.md
 create mode 100644 189-rotate-array/NOTES.md
 create mode 100644 189-rotate-array/README.md
 create mode 100644 2-add-two-numbers/2-add-two-numbers.cpp
 create mode 100644 2-add-two-numbers/NOTES.md
 create mode 100644 2-add-two-numbers/README.md
 create mode 100644 20-valid-parentheses/20-valid-parentheses.cpp
 create mode 100644 20-valid-parentheses/NOTES.md
 create mode 100644 20-valid-parentheses/README.md
 create mode 100644 203-remove-linked-list-elements/203-remove-linked-list-elements.cpp
 create mode 100644 203-remove-linked-list-elements/NOTES.md
 create mode 100644 203-remove-linked-list-elements/README.md
 create mode 100644 206-reverse-linked-list/206-reverse-linked-list.cpp
 create mode 100644 206-reverse-linked-list/NOTES.md
 create mode 100644 206-reverse-linked-list/README.md
 create mode 100644 209-minimum-size-subarray-sum/209-minimum-size-subarray-sum.cpp
 create mode 100644 209-minimum-size-subarray-sum/NOTES.md
 create mode 100644 209-minimum-size-subarray-sum/README.md
 create mode 100644 21-merge-two-sorted-lists/21-merge-two-sorted-lists.cpp
 create mode 100644 21-merge-two-sorted-lists/NOTES.md
 create mode 100644 21-merge-two-sorted-lists/README.md
 create mode 100644 2145-count-the-hidden-sequences/2145-count-the-hidden-sequences.cpp
 create mode 100644 2145-count-the-hidden-sequences/NOTES.md
 create mode 100644 2145-count-the-hidden-sequences/README.md
 create mode 100644 2202-maximize-the-topmost-element-after-k-moves/NOTES.md
 create mode 100644 2202-maximize-the-topmost-element-after-k-moves/README.md
 create mode 100644 2207-maximize-number-of-subsequences-in-a-string/2207-maximize-number-of-subsequences-in-a-string.cpp
 create mode 100644 2207-maximize-number-of-subsequences-in-a-string/NOTES.md
 create mode 100644 2207-maximize-number-of-subsequences-in-a-string/README.md
 create mode 100644 221-maximal-square/NOTES.md
 create mode 100644 221-maximal-square/README.md
 create mode 100644 225-implement-stack-using-queues/225-implement-stack-using-queues.cpp
 create mode 100644 225-implement-stack-using-queues/NOTES.md
 create mode 100644 225-implement-stack-using-queues/README.md
 create mode 100644 229-majority-element-ii/229-majority-element-ii.cpp
 create mode 100644 229-majority-element-ii/NOTES.md
 create mode 100644 229-majority-element-ii/README.md
 create mode 100644 23-merge-k-sorted-lists/23-merge-k-sorted-lists.cpp
 create mode 100644 23-merge-k-sorted-lists/NOTES.md
 create mode 100644 23-merge-k-sorted-lists/README.md
 create mode 100644 231-power-of-two/231-power-of-two.cpp
 create mode 100644 231-power-of-two/NOTES.md
 create mode 100644 231-power-of-two/README.md
 create mode 100644 232-implement-queue-using-stacks/232-implement-queue-using-stacks.cpp
 create mode 100644 232-implement-queue-using-stacks/NOTES.md
 create mode 100644 232-implement-queue-using-stacks/README.md
 create mode 100644 234-palindrome-linked-list/234-palindrome-linked-list.cpp
 create mode 100644 234-palindrome-linked-list/NOTES.md
 create mode 100644 236-lowest-common-ancestor-of-a-binary-tree/236-lowest-common-ancestor-of-a-binary-tree.cpp
 create mode 100644 236-lowest-common-ancestor-of-a-binary-tree/NOTES.md
 create mode 100644 236-lowest-common-ancestor-of-a-binary-tree/README.md
 create mode 100644 237-delete-node-in-a-linked-list/237-delete-node-in-a-linked-list.cpp
 create mode 100644 237-delete-node-in-a-linked-list/NOTES.md
 create mode 100644 237-delete-node-in-a-linked-list/README.md
 create mode 100644 238-product-of-array-except-self/238-product-of-array-except-self.cpp
 create mode 100644 238-product-of-array-except-self/NOTES.md
 create mode 100644 238-product-of-array-except-self/README.md
 create mode 100644 239-sliding-window-maximum/NOTES.md
 create mode 100644 239-sliding-window-maximum/README.md
 create mode 100644 24-swap-nodes-in-pairs/24-swap-nodes-in-pairs.cpp
 create mode 100644 24-swap-nodes-in-pairs/NOTES.md
 create mode 100644 24-swap-nodes-in-pairs/README.md
 create mode 100644 242-valid-anagram/242-valid-anagram.cpp
 create mode 100644 242-valid-anagram/NOTES.md
 create mode 100644 242-valid-anagram/README.md
 create mode 100644 25-reverse-nodes-in-k-group/NOTES.md
 create mode 100644 25-reverse-nodes-in-k-group/README.md
 create mode 100644 258-add-digits/258-add-digits.cpp
 create mode 100644 258-add-digits/NOTES.md
 create mode 100644 258-add-digits/README.md
 create mode 100644 26-remove-duplicates-from-sorted-array/NOTES.md
 create mode 100644 26-remove-duplicates-from-sorted-array/README.md
 create mode 100644 283-move-zeroes/283-move-zeroes.cpp
 create mode 100644 283-move-zeroes/NOTES.md
 create mode 100644 283-move-zeroes/README.md
 create mode 100644 287-find-the-duplicate-number/287-find-the-duplicate-number.cpp
 create mode 100644 287-find-the-duplicate-number/NOTES.md
 create mode 100644 287-find-the-duplicate-number/README.md
 create mode 100644 30-substring-with-concatenation-of-all-words/30-substring-with-concatenation-of-all-words.cpp
 create mode 100644 30-substring-with-concatenation-of-all-words/NOTES.md
 create mode 100644 30-substring-with-concatenation-of-all-words/README.md
 create mode 100644 300-longest-increasing-subsequence/NOTES.md
 create mode 100644 307-range-sum-query-mutable/NOTES.md
 create mode 100644 307-range-sum-query-mutable/README.md
 create mode 100644 31-next-permutation/31-next-permutation.cpp
 create mode 100644 31-next-permutation/NOTES.md
 create mode 100644 316-remove-duplicate-letters/316-remove-duplicate-letters.cpp
 create mode 100644 316-remove-duplicate-letters/NOTES.md
 create mode 100644 316-remove-duplicate-letters/README.md
 create mode 100644 326-power-of-three/326-power-of-three.cpp
 create mode 100644 326-power-of-three/NOTES.md
 create mode 100644 326-power-of-three/README.md
 create mode 100644 33-search-in-rotated-sorted-array/33-search-in-rotated-sorted-array.cpp
 create mode 100644 33-search-in-rotated-sorted-array/NOTES.md
 create mode 100644 33-search-in-rotated-sorted-array/README.md
 create mode 100644 34-find-first-and-last-position-of-element-in-sorted-array/34-find-first-and-last-position-of-element-in-sorted-array.cpp
 create mode 100644 34-find-first-and-last-position-of-element-in-sorted-array/README.md
 create mode 100644 342-power-of-four/342-power-of-four.cpp
 create mode 100644 342-power-of-four/NOTES.md
 create mode 100644 342-power-of-four/README.md
 create mode 100644 344-reverse-string/NOTES.md
 create mode 100644 344-reverse-string/README.md
 create mode 100644 345-reverse-vowels-of-a-string/345-reverse-vowels-of-a-string.cpp
 create mode 100644 345-reverse-vowels-of-a-string/NOTES.md
 create mode 100644 345-reverse-vowels-of-a-string/README.md
 create mode 100644 347-top-k-frequent-elements/347-top-k-frequent-elements.cpp
 create mode 100644 347-top-k-frequent-elements/NOTES.md
 create mode 100644 347-top-k-frequent-elements/README.md
 create mode 100644 35-search-insert-position/35-search-insert-position.cpp
 create mode 100644 35-search-insert-position/NOTES.md
 create mode 100644 35-search-insert-position/README.md
 create mode 100644 37-sudoku-solver/NOTES.md
 create mode 100644 37-sudoku-solver/README.md
 create mode 100644 38-count-and-say/38-count-and-say.cpp
 create mode 100644 38-count-and-say/NOTES.md
 create mode 100644 38-count-and-say/README.md
 create mode 100644 382-linked-list-random-node/382-linked-list-random-node.cpp
 create mode 100644 382-linked-list-random-node/NOTES.md
 create mode 100644 382-linked-list-random-node/README.md
 create mode 100644 389-find-the-difference/389-find-the-difference.cpp
 create mode 100644 389-find-the-difference/NOTES.md
 create mode 100644 39-combination-sum/39-combination-sum.cpp
 create mode 100644 39-combination-sum/NOTES.md
 create mode 100644 39-combination-sum/README.md
 create mode 100644 394-decode-string/NOTES.md
 create mode 100644 394-decode-string/README.md
 create mode 100644 397-integer-replacement/397-integer-replacement.cpp
 create mode 100644 397-integer-replacement/NOTES.md
 create mode 100644 397-integer-replacement/README.md
 create mode 100644 3sum-closest/3sum-closest.cpp
 create mode 100644 3sum-closest/README.md
 create mode 100644 3sum/3sum.cpp
 create mode 100644 3sum/README.md
 create mode 100644 4-median-of-two-sorted-arrays/4-median-of-two-sorted-arrays.cpp
 create mode 100644 4-median-of-two-sorted-arrays/NOTES.md
 create mode 100644 4-median-of-two-sorted-arrays/README.md
 create mode 100644 40-combination-sum-ii/40-combination-sum-ii.cpp
 create mode 100644 40-combination-sum-ii/NOTES.md
 create mode 100644 40-combination-sum-ii/README.md
 create mode 100644 402-remove-k-digits/402-remove-k-digits.cpp
 create mode 100644 402-remove-k-digits/NOTES.md
 create mode 100644 402-remove-k-digits/README.md
 create mode 100644 410-split-array-largest-sum/410-split-array-largest-sum.cpp
 create mode 100644 410-split-array-largest-sum/NOTES.md
 create mode 100644 410-split-array-largest-sum/README.md
 create mode 100644 415-add-strings/NOTES.md
 create mode 100644 415-add-strings/README.md
 create mode 100644 416-partition-equal-subset-sum/416-partition-equal-subset-sum.cpp
 create mode 100644 416-partition-equal-subset-sum/NOTES.md
 create mode 100644 416-partition-equal-subset-sum/README.md
 create mode 100644 42-trapping-rain-water/42-trapping-rain-water.cpp
 create mode 100644 42-trapping-rain-water/NOTES.md
 create mode 100644 421-maximum-xor-of-two-numbers-in-an-array/421-maximum-xor-of-two-numbers-in-an-array.cpp
 create mode 100644 421-maximum-xor-of-two-numbers-in-an-array/NOTES.md
 create mode 100644 438-find-all-anagrams-in-a-string/438-find-all-anagrams-in-a-string.cpp
 create mode 100644 438-find-all-anagrams-in-a-string/NOTES.md
 create mode 100644 438-find-all-anagrams-in-a-string/README.md
 create mode 100644 442-find-all-duplicates-in-an-array/442-find-all-duplicates-in-an-array.cpp
 create mode 100644 442-find-all-duplicates-in-an-array/NOTES.md
 create mode 100644 442-find-all-duplicates-in-an-array/README.md
 create mode 100644 45-jump-game-ii/45-jump-game-ii.cpp
 create mode 100644 45-jump-game-ii/NOTES.md
 create mode 100644 45-jump-game-ii/README.md
 create mode 100644 454-4sum-ii/454-4sum-ii.cpp
 create mode 100644 454-4sum-ii/NOTES.md
 create mode 100644 454-4sum-ii/README.md
 create mode 100644 458-poor-pigs/NOTES.md
 create mode 100644 458-poor-pigs/README.md
 create mode 100644 46-permutations/46-permutations.cpp
 create mode 100644 46-permutations/NOTES.md
 create mode 100644 46-permutations/README.md
 create mode 100644 472-concatenated-words/472-concatenated-words.cpp
 create mode 100644 472-concatenated-words/NOTES.md
 create mode 100644 472-concatenated-words/README.md
 create mode 100644 48-rotate-image/48-rotate-image.cpp
 create mode 100644 48-rotate-image/NOTES.md
 create mode 100644 48-rotate-image/README.md
 create mode 100644 485-max-consecutive-ones/485-max-consecutive-ones.cpp
 create mode 100644 485-max-consecutive-ones/README.md
 create mode 100644 49-group-anagrams/49-group-anagrams.cpp
 create mode 100644 49-group-anagrams/NOTES.md
 create mode 100644 49-group-anagrams/README.md
 create mode 100644 494-target-sum/494-target-sum.cpp
 create mode 100644 494-target-sum/NOTES.md
 create mode 100644 494-target-sum/README.md
 create mode 100644 496-next-greater-element-i/496-next-greater-element-i.cpp
 create mode 100644 496-next-greater-element-i/NOTES.md
 create mode 100644 496-next-greater-element-i/README.md
 create mode 100644 4sum-ii/4sum-ii.cpp
 create mode 100644 4sum-ii/README.md
 create mode 100644 4sum/4sum.cpp
 create mode 100644 4sum/README.md
 create mode 100644 50-powx-n/50-powx-n.cpp
 create mode 100644 50-powx-n/NOTES.md
 create mode 100644 50-powx-n/README.md
 create mode 100644 503-next-greater-element-ii/503-next-greater-element-ii.cpp
 create mode 100644 503-next-greater-element-ii/NOTES.md
 create mode 100644 503-next-greater-element-ii/README.md
 create mode 100644 509-fibonacci-number/509-fibonacci-number.cpp
 create mode 100644 509-fibonacci-number/NOTES.md
 create mode 100644 509-fibonacci-number/README.md
 create mode 100644 51-n-queens/51-n-queens.cpp
 create mode 100644 51-n-queens/NOTES.md
 create mode 100644 51-n-queens/README.md
 create mode 100644 52-n-queens-ii/52-n-queens-ii.cpp
 create mode 100644 52-n-queens-ii/NOTES.md
 create mode 100644 52-n-queens-ii/README.md
 create mode 100644 520-detect-capital/520-detect-capital.cpp
 create mode 100644 520-detect-capital/NOTES.md
 create mode 100644 520-detect-capital/README.md
 create mode 100644 525-contiguous-array/525-contiguous-array.cpp
 create mode 100644 525-contiguous-array/NOTES.md
 create mode 100644 525-contiguous-array/README.md
 create mode 100644 53-maximum-subarray/53-maximum-subarray.cpp
 create mode 100644 53-maximum-subarray/NOTES.md
 create mode 100644 53-maximum-subarray/README.md
 create mode 100644 532-k-diff-pairs-in-an-array/532-k-diff-pairs-in-an-array.cpp
 create mode 100644 532-k-diff-pairs-in-an-array/NOTES.md
 create mode 100644 532-k-diff-pairs-in-an-array/README.md
 create mode 100644 54-spiral-matrix/54-spiral-matrix.cpp
 create mode 100644 54-spiral-matrix/NOTES.md
 create mode 100644 54-spiral-matrix/README.md
 create mode 100644 540-single-element-in-a-sorted-array/540-single-element-in-a-sorted-array.cpp
 create mode 100644 540-single-element-in-a-sorted-array/NOTES.md
 create mode 100644 540-single-element-in-a-sorted-array/README.md
 create mode 100644 543-diameter-of-binary-tree/NOTES.md
 create mode 100644 543-diameter-of-binary-tree/README.md
 create mode 100644 55-jump-game/55-jump-game.cpp
 create mode 100644 55-jump-game/NOTES.md
 create mode 100644 55-jump-game/README.md
 create mode 100644 556-next-greater-element-iii/556-next-greater-element-iii.cpp
 create mode 100644 556-next-greater-element-iii/NOTES.md
 create mode 100644 556-next-greater-element-iii/README.md
 create mode 100644 560-subarray-sum-equals-k/560-subarray-sum-equals-k.cpp
 create mode 100644 567-permutation-in-string/NOTES.md
 create mode 100644 567-permutation-in-string/README.md
 create mode 100644 576-out-of-boundary-paths/576-out-of-boundary-paths.cpp
 create mode 100644 576-out-of-boundary-paths/README.md
 create mode 100644 60-permutation-sequence/60-permutation-sequence.cpp
 create mode 100644 60-permutation-sequence/NOTES.md
 create mode 100644 60-permutation-sequence/README.md
 create mode 100644 605-can-place-flowers/605-can-place-flowers.cpp
 create mode 100644 605-can-place-flowers/NOTES.md
 create mode 100644 605-can-place-flowers/README.md
 create mode 100644 61-rotate-list/NOTES.md
 create mode 100644 61-rotate-list/README.md
 create mode 100644 62-unique-paths/NOTES.md
 create mode 100644 62-unique-paths/README.md
 create mode 100644 63-unique-paths-ii/NOTES.md
 create mode 100644 63-unique-paths-ii/README.md
 create mode 100644 64-minimum-path-sum/64-minimum-path-sum.cpp
 create mode 100644 64-minimum-path-sum/NOTES.md
 create mode 100644 64-minimum-path-sum/README.md
 create mode 100644 650-2-keys-keyboard/650-2-keys-keyboard.cpp
 create mode 100644 650-2-keys-keyboard/NOTES.md
 create mode 100644 650-2-keys-keyboard/README.md
 create mode 100644 66-plus-one/NOTES.md
 create mode 100644 662-maximum-width-of-binary-tree/662-maximum-width-of-binary-tree.cpp
 create mode 100644 662-maximum-width-of-binary-tree/NOTES.md
 create mode 100644 662-maximum-width-of-binary-tree/README.md
 create mode 100644 67-add-binary/NOTES.md
 create mode 100644 67-add-binary/README.md
 create mode 100644 673-number-of-longest-increasing-subsequence/NOTES.md
 create mode 100644 673-number-of-longest-increasing-subsequence/README.md
 create mode 100644 7 Segment Display - GFG/7-segment-display.cpp
 create mode 100644 7 Segment Display - GFG/README.md
 create mode 100644 70-climbing-stairs/NOTES.md
 create mode 100644 700-search-in-a-binary-search-tree/700-search-in-a-binary-search-tree.cpp
 create mode 100644 700-search-in-a-binary-search-tree/NOTES.md
 create mode 100644 700-search-in-a-binary-search-tree/README.md
 create mode 100644 701-insert-into-a-binary-search-tree/701-insert-into-a-binary-search-tree.cpp
 create mode 100644 701-insert-into-a-binary-search-tree/NOTES.md
 create mode 100644 701-insert-into-a-binary-search-tree/README.md
 create mode 100644 704-binary-search/704-binary-search.cpp
 create mode 100644 704-binary-search/NOTES.md
 create mode 100644 704-binary-search/README.md
 create mode 100644 71-simplify-path/71-simplify-path.cpp
 create mode 100644 71-simplify-path/NOTES.md
 create mode 100644 71-simplify-path/README.md
 create mode 100644 724-find-pivot-index/724-find-pivot-index.cpp
 create mode 100644 724-find-pivot-index/NOTES.md
 create mode 100644 724-find-pivot-index/README.md
 create mode 100644 74-search-a-2d-matrix/74-search-a-2d-matrix.cpp
 create mode 100644 74-search-a-2d-matrix/NOTES.md
 create mode 100644 74-search-a-2d-matrix/README.md
 create mode 100644 740-delete-and-earn/740-delete-and-earn.cpp
 create mode 100644 740-delete-and-earn/NOTES.md
 create mode 100644 740-delete-and-earn/README.md
 create mode 100644 746-min-cost-climbing-stairs/746-min-cost-climbing-stairs.cpp
 create mode 100644 75-sort-colors/75-sort-colors.cpp
 create mode 100644 75-sort-colors/NOTES.md
 create mode 100644 75-sort-colors/README.md
 create mode 100644 763-partition-labels/763-partition-labels.cpp
 create mode 100644 763-partition-labels/NOTES.md
 create mode 100644 763-partition-labels/README.md
 create mode 100644 78-subsets/78-subsets.cpp
 create mode 100644 78-subsets/NOTES.md
 create mode 100644 78-subsets/README.md
 create mode 100644 79-word-search/79-word-search.cpp
 create mode 100644 79-word-search/NOTES.md
 create mode 100644 79-word-search/README.md
 create mode 100644 8-string-to-integer-atoi/8-string-to-integer-atoi.cpp
 create mode 100644 8-string-to-integer-atoi/NOTES.md
 create mode 100644 8-string-to-integer-atoi/README.md
 create mode 100644 80-remove-duplicates-from-sorted-array-ii/80-remove-duplicates-from-sorted-array-ii.cpp
 create mode 100644 80-remove-duplicates-from-sorted-array-ii/NOTES.md
 create mode 100644 80-remove-duplicates-from-sorted-array-ii/README.md
 create mode 100644 804-unique-morse-code-words/NOTES.md
 create mode 100644 804-unique-morse-code-words/README.md
 create mode 100644 82-remove-duplicates-from-sorted-list-ii/82-remove-duplicates-from-sorted-list-ii.cpp
 create mode 100644 82-remove-duplicates-from-sorted-list-ii/NOTES.md
 create mode 100644 82-remove-duplicates-from-sorted-list-ii/README.md
 create mode 100644 823-binary-trees-with-factors/NOTES.md
 create mode 100644 823-binary-trees-with-factors/README.md
 create mode 100644 84-largest-rectangle-in-histogram/84-largest-rectangle-in-histogram.cpp
 create mode 100644 84-largest-rectangle-in-histogram/NOTES.md
 create mode 100644 84-largest-rectangle-in-histogram/README.md
 create mode 100644 847-shortest-path-visiting-all-nodes/NOTES.md
 create mode 100644 847-shortest-path-visiting-all-nodes/README.md
 create mode 100644 856-score-of-parentheses/856-score-of-parentheses.cpp
 create mode 100644 856-score-of-parentheses/NOTES.md
 create mode 100644 856-score-of-parentheses/README.md
 create mode 100644 858-mirror-reflection/NOTES.md
 create mode 100644 858-mirror-reflection/README.md
 create mode 100644 875-koko-eating-bananas/875-koko-eating-bananas.cpp
 create mode 100644 876-middle-of-the-linked-list/876-middle-of-the-linked-list.cpp
 create mode 100644 881-boats-to-save-people/881-boats-to-save-people.cpp
 create mode 100644 881-boats-to-save-people/NOTES.md
 create mode 100644 881-boats-to-save-people/README.md
 create mode 100644 890-find-and-replace-pattern/890-find-and-replace-pattern.cpp
 create mode 100644 890-find-and-replace-pattern/NOTES.md
 create mode 100644 890-find-and-replace-pattern/README.md
 create mode 100644 895-maximum-frequency-stack/895-maximum-frequency-stack.cpp
 create mode 100644 895-maximum-frequency-stack/NOTES.md
 create mode 100644 895-maximum-frequency-stack/README.md
 create mode 100644 90-subsets-ii/90-subsets-ii.cpp
 create mode 100644 90-subsets-ii/NOTES.md
 create mode 100644 90-subsets-ii/README.md
 create mode 100644 916-word-subsets/NOTES.md
 create mode 100644 916-word-subsets/README.md
 create mode 100644 921-minimum-add-to-make-parentheses-valid/NOTES.md
 create mode 100644 921-minimum-add-to-make-parentheses-valid/README.md
 create mode 100644 946-validate-stack-sequences/946-validate-stack-sequences.cpp
 create mode 100644 946-validate-stack-sequences/NOTES.md
 create mode 100644 946-validate-stack-sequences/README.md
 create mode 100644 977-squares-of-a-sorted-array/977-squares-of-a-sorted-array.cpp
 create mode 100644 977-squares-of-a-sorted-array/NOTES.md
 create mode 100644 977-squares-of-a-sorted-array/README.md
 create mode 100644 98-validate-binary-search-tree/98-validate-binary-search-tree.cpp
 create mode 100644 98-validate-binary-search-tree/NOTES.md
 create mode 100644 98-validate-binary-search-tree/README.md
 create mode 100644 981-time-based-key-value-store/981-time-based-key-value-store.cpp
 create mode 100644 983-minimum-cost-for-tickets/NOTES.md
 create mode 100644 983-minimum-cost-for-tickets/README.md
 create mode 100644 991-broken-calculator/991-broken-calculator.cpp
 create mode 100644 991-broken-calculator/NOTES.md
 create mode 100644 991-broken-calculator/README.md
 create mode 100644 994-rotting-oranges/994-rotting-oranges.cpp
 create mode 100644 994-rotting-oranges/NOTES.md
 create mode 100644 994-rotting-oranges/README.md
 create mode 100644 Add 1 to a number represented as linked list - GFG/README.md
 create mode 100644 Add 1 to a number represented as linked list - GFG/add-1-to-a-number-represented-as-linked-list.cpp
 create mode 100644 Allocate minimum number of pages - GFG/README.md
 create mode 100644 Allocate minimum number of pages - GFG/allocate-minimum-number-of-pages.cpp
 create mode 100644 Anagram of String - GFG/README.md
 create mode 100644 Anagram of String - GFG/anagram-of-string.cpp
 create mode 100644 Array to BST - GFG/README.md
 create mode 100644 Array to BST - GFG/array-to-bst.cpp
 create mode 100644 Biconnected Graph - GFG/README.md
 create mode 100644 Biconnected Graph - GFG/biconnected-graph.cpp
 create mode 100644 Binary Array Sorting - GFG/README.md
 create mode 100644 Binary Array Sorting - GFG/binary-array-sorting.cpp
 create mode 100644 Binary number to decimal number - GFG/README.md
 create mode 100644 Binary number to decimal number - GFG/binary-number-to-decimal-number.cpp
 create mode 100644 Bitwise AND of the Array - GFG/README.md
 create mode 100644 Bitwise AND of the Array - GFG/bitwise-and-of-the-array.cpp
 create mode 100644 Can Make Triangle - GFG/README.md
 create mode 100644 Can Make Triangle - GFG/can-make-triangle.cpp
 create mode 100644 Check Mirror in N-ary tree - GFG/README.md
 create mode 100644 Check Mirror in N-ary tree - GFG/check-mirror-in-nary-tree.cpp
 create mode 100644 Check if subtree - GFG/README.md
 create mode 100644 Check if subtree - GFG/check-if-subtree.cpp
 create mode 100644 Clone a stack without using extra space - GFG/README.md
 create mode 100644 Clone a stack without using extra space - GFG/clone-a-stack-without-using-extra-space.cpp
 create mode 100644 Clone a stack without usinig extra space - GFG/README.md
 create mode 100644 Clone a stack without usinig extra space - GFG/clone-a-stack-without-usinig-extra-space.cpp
 create mode 100644 Coins of Geekland - GFG/README.md
 create mode 100644 Coins of Geekland - GFG/coins-of-geekland.cpp
 create mode 100644 Compute Before Matrix - GFG/README.md
 create mode 100644 Compute Before Matrix - GFG/compute-before-matrix.cpp
 create mode 100644 Concatenate two numbers - GFG/README.md
 create mode 100644 Concatenate two numbers - GFG/concatenate-two-numbers.cpp
 create mode 100644 Corona Vaccine - GFG/README.md
 create mode 100644 Corona Vaccine - GFG/corona-vaccine.cpp
 create mode 100644 Counts Zeros Xor Pairs - GFG/README.md
 create mode 100644 Counts Zeros Xor Pairs - GFG/counts-zeros-xor-pairs.cpp
 create mode 100644 Cousins of a given node - GFG/README.md
 create mode 100644 Cousins of a given node - GFG/cousins-of-a-given-node.cpp
 create mode 100644 Cyclically rotate an array by one - GFG/README.md
 create mode 100644 Cyclically rotate an array by one - GFG/cyclically-rotate-an-array-by-one.cpp
 create mode 100644 Escape the Forbidden Forest - GFG/README.md
 create mode 100644 Escape the Forbidden Forest - GFG/escape-the-forbidden-forest.cpp
 create mode 100644 Even and Odd - GFG/README.md
 create mode 100644 Even and Odd - GFG/even-and-odd.cpp
 create mode 100644 Excel Sheet _ Part - 1 - GFG/README.md
 create mode 100644 Excel Sheet _ Part - 1 - GFG/excel-sheet-part-1.cpp
 create mode 100644 Find Missing And Repeating - GFG/README.md
 create mode 100644 Find Missing And Repeating - GFG/find-missing-and-repeating.cpp
 create mode 100644 Find Nth root of M - GFG/README.md
 create mode 100644 Find Nth root of M - GFG/find-nth-root-of-m.cpp
 create mode 100644 Find Prime numbers in a range - GFG/README.md
 create mode 100644 Find Prime numbers in a range - GFG/find-prime-numbers-in-a-range.cpp
 create mode 100644 Find position of set bit - GFG/README.md
 create mode 100644 Find position of set bit - GFG/find-position-of-set-bit.cpp
 create mode 100644 Find rectangle with corners as 1 - GFG/README.md
 create mode 100644 Find rectangle with corners as 1 - GFG/find-rectangle-with-corners-as-1.cpp
 create mode 100644 Find the Closest Element in BST - GFG/README.md
 create mode 100644 Find the Closest Element in BST - GFG/find-the-closest-element-in-bst.cpp
 create mode 100644 Find the Maximum Flow - GFG/README.md
 create mode 100644 Find the Maximum Flow - GFG/find-the-maximum-flow.cpp
 create mode 100644 Find the number of islands - GFG/README.md
 create mode 100644 Find the number of islands - GFG/find-the-number-of-islands.cpp
 create mode 100644 Form a palindrome - GFG/README.md
 create mode 100644 Form a palindrome - GFG/form-a-palindrome.cpp
 create mode 100644 Fraction Trouble - GFG/README.md
 create mode 100644 Fraction Trouble - GFG/fraction-trouble.cpp
 create mode 100644 Gadgets of Doraland - GFG/README.md
 create mode 100644 Gadgets of Doraland - GFG/gadgets-of-doraland.py
 create mode 100644 Handshakes - GFG/README.md
 create mode 100644 Handshakes - GFG/handshakes.cpp
 create mode 100644 Height Using Parent Array - GFG/README.md
 create mode 100644 Height Using Parent Array - GFG/height-using-parent-array.cpp
 create mode 100644 Help Classmates - GFG/README.md
 create mode 100644 Help Classmates - GFG/help-classmates.cpp
 create mode 100644 Hit most Balloons - GFG/README.md
 create mode 100644 Hit most Balloons - GFG/hit-most-balloons.cpp
 create mode 100644 Implement stack using array - GFG/README.md
 create mode 100644 Implement stack using array - GFG/implement-stack-using-array.cpp
 create mode 100644 Implementing Dijkstra Algorithm - GFG/README.md
 create mode 100644 Implementing Dijkstra Algorithm - GFG/implementing-dijkstra-algorithm.cpp
 create mode 100644 Insertion Sort for Singly Linked List - GFG/README.md
 create mode 100644 Insertion Sort for Singly Linked List - GFG/insertion-sort-for-singly-linked-list.cpp
 create mode 100644 K-th element of two sorted Arrays - GFG/README.md
 create mode 100644 K-th element of two sorted Arrays - GFG/kth-element-of-two-sorted-arrays.cpp
 create mode 100644 Kadane's Algorithm - GFG/README.md
 create mode 100644 Kadane's Algorithm - GFG/kadanes-algorithm.cpp
 create mode 100644 Kth smallest element - GFG/README.md
 create mode 100644 Kth smallest element - GFG/kth-smallest-element.cpp
 create mode 100644 Largest subarray with 0 sum - GFG/README.md
 create mode 100644 Largest subarray with 0 sum - GFG/largest-subarray-with-0-sum.cpp
 create mode 100644 Largest value in each level - GFG/README.md
 create mode 100644 Largest value in each level - GFG/largest-value-in-each-level.cpp
 create mode 100644 Leaves to DLL - GFG/README.md
 create mode 100644 Leaves to DLL - GFG/leaves-to-dll.cpp
 create mode 100644 Left View of Binary Tree - GFG/README.md
 create mode 100644 Left View of Binary Tree - GFG/left-view-of-binary-tree.cpp
 create mode 100644 Longest Common Prefix in an Array - GFG/README.md
 create mode 100644 Longest Common Prefix in an Array - GFG/longest-common-prefix-in-an-array.cpp
 create mode 100644 Longest substring to form a Palindrome - GFG/README.md
 create mode 100644 Longest substring to form a Palindrome - GFG/longest-substring-to-form-a-palindrome.cpp
 create mode 100644 M-Coloring Problem - GFG/README.md
 create mode 100644 M-Coloring Problem - GFG/mcoloring-problem.cpp
 create mode 100644 Matrix Operations - GFG/README.md
 create mode 100644 Matrix Operations - GFG/matrix-operations.cpp
 create mode 100644 Maximum Winning score - GFG/README.md
 create mode 100644 Maximum Winning score - GFG/maximum-winning-score.cpp
 create mode 100644 Maximum average subarray - GFG/README.md
 create mode 100644 Maximum average subarray - GFG/maximum-average-subarray.cpp
 create mode 100644 Maximum number of events that can be attended - GFG/maximum-number-of-events-that-can-be-attended.cpp
 create mode 100644 Maximum selections - GFG/README.md
 create mode 100644 Maximum selections - GFG/maximum-selections.cpp
 create mode 100644 Maximum sum of increasing order elements from n arrays - GFG/README.md
 create mode 100644 Maximum sum of increasing order elements from n arrays - GFG/maximum-sum-of-increasing-order-elements-from-n-arrays.cpp
 create mode 100644 Median in a row-wise sorted Matrix - GFG/README.md
 create mode 100644 Median in a row-wise sorted Matrix - GFG/median-in-a-rowwise-sorted-matrix.cpp
 create mode 100644 Merge K sorted linked lists - GFG/README.md
 create mode 100644 Merge K sorted linked lists - GFG/merge-k-sorted-linked-lists.cpp
 create mode 100644 Min Coin - GFG/README.md
 create mode 100644 Min Coin - GFG/min-coin.cpp
 create mode 100644 Minimum Swaps to Sort - GFG/README.md
 create mode 100644 Minimum Swaps to Sort - GFG/minimum-swaps-to-sort.cpp
 create mode 100644 Move all zeros to the front of the linked list - GFG/README.md
 create mode 100644 Move all zeros to the front of the linked list - GFG/move-all-zeros-to-the-front-of-the-linked-list.cpp
 create mode 100644 N Digit numbers with digits in increasing order - GFG/README.md
 create mode 100644 N Digit numbers with digits in increasing order - GFG/n-digit-numbers-with-digits-in-increasing-order.cpp
 create mode 100644 Negative weight cycle - GFG/README.md
 create mode 100644 Negative weight cycle - GFG/negative-weight-cycle.cpp
 create mode 100644 Next Permutation - GFG/README.md
 create mode 100644 Next Permutation - GFG/next-permutation.cpp
 create mode 100644 Nodes at even distance - GFG/README.md
 create mode 100644 Nodes at even distance - GFG/nodes-at-even-distance.cpp
 create mode 100644 Number of distinct Words with k maximum contiguous vowels - GFG/README.md
 create mode 100644 Number of distinct Words with k maximum contiguous vowels - GFG/number-of-distinct-words-with-k-maximum-contiguous-vowels.cpp
 create mode 100644 Optimal binary search tree - GFG/README.md
 create mode 100644 Optimal binary search tree - GFG/optimal-binary-search-tree.cpp
 create mode 100644 Partition Equal Subset Sum - GFG/README.md
 create mode 100644 Partition Equal Subset Sum - GFG/partition-equal-subset-sum.cpp
 create mode 100644 Positive Negative Pair - GFG/README.md
 create mode 100644 Positive Negative Pair - GFG/positive-negative-pair.cpp
 create mode 100644 Predecessor and Successor - GFG/README.md
 create mode 100644 Predecessor and Successor - GFG/predecessor-and-successor.cpp
 create mode 100644 Queries on Strings - GFG/README.md
 create mode 100644 Queries on Strings - GFG/queries-on-strings.cpp
 create mode 100644 Queue using two Stacks - GFG/README.md
 create mode 100644 Queue using two Stacks - GFG/queue-using-two-stacks.cpp
 create mode 100644 Rank The Permutations - GFG/README.md
 create mode 100644 Rank The Permutations - GFG/rank-the-permutations.cpp
 create mode 100644 Rat in a Maze Problem - I - GFG/README.md
 create mode 100644 Rat in a Maze Problem - I - GFG/rat-in-a-maze-problem-i.cpp
 create mode 100644 Rearrange Geek and his Classmates - GFG/README.md
 create mode 100644 Rearrange Geek and his Classmates - GFG/rearrange-geek-and-his-classmates.cpp
 create mode 100644 Remove leading zeros from an IP address - GFG/README.md
 create mode 100644 Remove leading zeros from an IP address - GFG/remove-leading-zeros-from-an-ip-address.cpp
 create mode 100644 Return two prime numbers - GFG/README.md
 create mode 100644 Return two prime numbers - GFG/return-two-prime-numbers.cpp
 create mode 100644 Reverse First K elements of Queue - GFG/README.md
 create mode 100644 Reverse First K elements of Queue - GFG/reverse-first-k-elements-of-queue.cpp
 create mode 100644 Reverse words in a given string - GFG/README.md
 create mode 100644 Reverse words in a given string - GFG/reverse-words-in-a-given-string.cpp
 create mode 100644 Rotate by 90 degree - GFG/README.md
 create mode 100644 Rotate by 90 degree - GFG/rotate-by-90-degree.cpp
 create mode 100644 Search Pattern (Z-algorithm) - GFG/README.md
 create mode 100644 Search Pattern (Z-algorithm) - GFG/search-pattern-zalgorithm.cpp
 create mode 100644 Search a node in BST - GFG/README.md
 create mode 100644 Search a node in BST - GFG/search-a-node-in-bst.cpp
 create mode 100644 Shortest Path between Cities - GFG/README.md
 create mode 100644 Shortest Path between Cities - GFG/shortest-path-between-cities.cpp
 create mode 100644 Shortest Unique prefix for every word - GFG/README.md
 create mode 100644 Shortest Unique prefix for every word - GFG/shortest-unique-prefix-for-every-word.cpp
 create mode 100644 Smallest Absolute Difference - GFG/README.md
 create mode 100644 Smallest Absolute Difference - GFG/smallest-absolute-difference.cpp
 create mode 100644 Smallest greater elements in whole array - GFG/README.md
 create mode 100644 Smallest greater elements in whole array - GFG/smallest-greater-elements-in-whole-array.cpp
 create mode 100644 Smallest window containing 0, 1 and 2 - GFG/README.md
 create mode 100644 Smallest window containing 0, 1 and 2 - GFG/smallest-window-containing-0-1-and-2.cpp
 create mode 100644 Sort a stack - GFG/README.md
 create mode 100644 Sort a stack - GFG/sort-a-stack.cpp
 create mode 100644 Sort an array of 0s, 1s and 2s - GFG/README.md
 create mode 100644 Sort an array of 0s, 1s and 2s - GFG/sort-an-array-of-0s-1s-and-2s.cpp
 create mode 100644 Sort by Set Bit Count - GFG/README.md
 create mode 100644 Sort by Set Bit Count - GFG/sort-by-set-bit-count.cpp
 create mode 100644 Special Matrix - GFG/README.md
 create mode 100644 Special Matrix - GFG/special-matrix.cpp
 create mode 100644 Spidey Sense - GFG/README.md
 create mode 100644 Spidey Sense - GFG/spidey-sense.cpp
 create mode 100644 Stack using two queues - GFG/README.md
 create mode 100644 Stack using two queues - GFG/stack-using-two-queues.cpp
 create mode 100644 Subset Sums - GFG/README.md
 create mode 100644 Subset Sums - GFG/subset-sums.cpp
 create mode 100644 Subsets - GFG/README.md
 create mode 100644 Subsets - GFG/subsets.cpp
 create mode 100644 Swap Kth nodes from ends - GFG/README.md
 create mode 100644 Swap Kth nodes from ends - GFG/swap-kth-nodes-from-ends.cpp
 create mode 100644 The Painter's Partition Problem-II - GFG/README.md
 create mode 100644 The Painter's Partition Problem-II - GFG/the-painters-partition-problem-ii.cpp
 create mode 100644 Transfiguration - GFG/README.md
 create mode 100644 Triangle and Square - GFG/README.md
 create mode 100644 Triangle and Square - GFG/triangle-and-square.cpp
 create mode 100644 Union of two arrays - GFG/README.md
 create mode 100644 Union of two arrays - GFG/union-of-two-arrays.cpp
 create mode 100644 Word Break - Part 2 - GFG/README.md
 create mode 100644 Word Break - Part 2 - GFG/word-break-part-2.cpp
 create mode 100644 XOR Game - GFG/README.md
 create mode 100644 XOR Game - GFG/xor-game.cpp
 create mode 100644 accounts-merge/README.md
 create mode 100644 accounts-merge/accounts-merge.cpp
 create mode 100644 add-digits/README.md
 create mode 100644 add-digits/add-digits.cpp
 create mode 100644 add-strings/README.md
 create mode 100644 add-strings/add-strings.cpp
 create mode 100644 add-two-numbers/README.md
 create mode 100644 add-two-numbers/add-two-numbers.cpp
 create mode 100644 all-elements-in-two-binary-search-trees/README.md
 create mode 100644 all-elements-in-two-binary-search-trees/all-elements-in-two-binary-search-trees.cpp
 create mode 100644 all-paths-from-source-to-target/README.md
 create mode 100644 all-paths-from-source-to-target/all-paths-from-source-to-target.cpp
 create mode 100644 all-possible-full-binary-trees/README.md
 create mode 100644 all-possible-full-binary-trees/all-possible-full-binary-trees.cpp
 create mode 100644 arranging-coins/README.md
 create mode 100644 arranging-coins/arranging-coins.cpp
 create mode 100644 array-of-doubled-pairs/README.md
 create mode 100644 balance-a-binary-search-tree/README.md
 create mode 100644 balanced-binary-tree/README.md
 create mode 100644 balanced-binary-tree/balanced-binary-tree.cpp
 create mode 100644 best-sightseeing-pair/README.md
 create mode 100644 best-sightseeing-pair/best-sightseeing-pair.cpp
 create mode 100644 best-time-to-buy-and-sell-stock-ii/README.md
 create mode 100644 best-time-to-buy-and-sell-stock-ii/best-time-to-buy-and-sell-stock-ii.cpp
 create mode 100644 best-time-to-buy-and-sell-stock-iii/README.md
 create mode 100644 best-time-to-buy-and-sell-stock-iv/README.md
 create mode 100644 best-time-to-buy-and-sell-stock-iv/best-time-to-buy-and-sell-stock-iv.cpp
 create mode 100644 best-time-to-buy-and-sell-stock-with-cooldown/README.md
 create mode 100644 best-time-to-buy-and-sell-stock-with-cooldown/best-time-to-buy-and-sell-stock-with-cooldown.cpp
 create mode 100644 best-time-to-buy-and-sell-stock/README.md
 create mode 100644 best-time-to-buy-and-sell-stock/best-time-to-buy-and-sell-stock.cpp
 create mode 100644 binary-search-tree-to-greater-sum-tree/README.md
 create mode 100644 binary-search-tree-to-greater-sum-tree/binary-search-tree-to-greater-sum-tree.cpp
 create mode 100644 binary-search/README.md
 create mode 100644 binary-search/binary-search.cpp
 create mode 100644 binary-tree-inorder-traversal/README.md
 create mode 100644 binary-tree-inorder-traversal/binary-tree-inorder-traversal.cpp
 create mode 100644 binary-tree-level-order-traversal/README.md
 create mode 100644 binary-tree-level-order-traversal/binary-tree-level-order-traversal.cpp
 create mode 100644 binary-tree-maximum-path-sum/README.md
 create mode 100644 binary-tree-maximum-path-sum/binary-tree-maximum-path-sum.cpp
 create mode 100644 binary-tree-paths/README.md
 create mode 100644 binary-tree-paths/binary-tree-paths.cpp
 create mode 100644 binary-tree-postorder-traversal/README.md
 create mode 100644 binary-tree-preorder-traversal/README.md
 create mode 100644 binary-tree-preorder-traversal/binary-tree-preorder-traversal.cpp
 create mode 100644 binary-tree-pruning/README.md
 create mode 100644 binary-tree-right-side-view/README.md
 create mode 100644 binary-tree-right-side-view/binary-tree-right-side-view.cpp
 create mode 100644 binary-tree-zigzag-level-order-traversal/README.md
 create mode 100644 binary-tree-zigzag-level-order-traversal/binary-tree-zigzag-level-order-traversal.cpp
 create mode 100644 binary-watch/README.md
 create mode 100644 binary-watch/binary-watch.cpp
 create mode 100644 build-array-from-permutation/README.md
 create mode 100644 build-array-from-permutation/build-array-from-permutation.cpp
 create mode 100644 burst-balloons/README.md
 create mode 100644 burst-balloons/burst-balloons.cpp
 create mode 100644 climbing-stairs/README.md
 create mode 100644 climbing-stairs/climbing-stairs.cpp
 create mode 100644 clone-graph/README.md
 create mode 100644 coin-change-2/README.md
 create mode 100644 coin-change-2/coin-change-2.cpp
 create mode 100644 coin-change/README.md
 create mode 100644 coin-change/coin-change.cpp
 create mode 100644 combination-sum-iv/README.md
 create mode 100644 combination-sum-iv/combination-sum-iv.cpp
 create mode 100644 combination-sum/README.md
 create mode 100644 combination-sum/combination-sum.cpp
 create mode 100644 combine-two-tables/README.md
 create mode 100644 combine-two-tables/combine-two-tables.sql
 create mode 100644 consecutive-characters/README.md
 create mode 100644 consecutive-characters/consecutive-characters.cpp
 create mode 100644 construct-binary-tree-from-inorder-and-postorder-traversal/README.md
 create mode 100644 construct-binary-tree-from-inorder-and-postorder-traversal/construct-binary-tree-from-inorder-and-postorder-traversal.cpp
 create mode 100644 construct-binary-tree-from-preorder-and-inorder-traversal/README.md
 create mode 100644 construct-binary-tree-from-preorder-and-inorder-traversal/construct-binary-tree-from-preorder-and-inorder-traversal.cpp
 create mode 100644 contains-duplicate-ii/README.md
 create mode 100644 contains-duplicate-ii/contains-duplicate-ii.cpp
 create mode 100644 contains-duplicate/README.md
 create mode 100644 contains-duplicate/contains-duplicate.cpp
 create mode 100644 convert-binary-number-in-a-linked-list-to-integer/README.md
 create mode 100644 convert-binary-number-in-a-linked-list-to-integer/convert-binary-number-in-a-linked-list-to-integer.cpp
 create mode 100644 convert-sorted-array-to-binary-search-tree/README.md
 create mode 100644 convert-sorted-array-to-binary-search-tree/convert-sorted-array-to-binary-search-tree.cpp
 create mode 100644 copy-list-with-random-pointer/README.md
 create mode 100644 copy-list-with-random-pointer/copy-list-with-random-pointer.cpp
 create mode 100644 count-number-of-teams/README.md
 create mode 100644 count-sorted-vowel-strings/README.md
 create mode 100644 count-substrings-that-differ-by-one-character/README.md
 create mode 100644 count-substrings-that-differ-by-one-character/count-substrings-that-differ-by-one-character.cpp
 create mode 100644 count-triplets-that-can-form-two-arrays-of-equal-xor/README.md
 create mode 100644 course-schedule-ii/README.md
 create mode 100644 course-schedule-ii/course-schedule-ii.cpp
 create mode 100644 course-schedule/README.md
 create mode 100644 custom-sort-string/README.md
 create mode 100644 custom-sort-string/custom-sort-string.cpp
 create mode 100644 daily-temperatures/README.md
 create mode 100644 daily-temperatures/daily-temperatures.cpp
 create mode 100644 decode-ways-ii/README.md
 create mode 100644 decode-ways/README.md
 create mode 100644 decode-ways/decode-ways.cpp
 create mode 100644 deepest-leaves-sum/README.md
 create mode 100644 deepest-leaves-sum/deepest-leaves-sum.cpp
 create mode 100644 delete-and-earn/README.md
 create mode 100644 delete-leaves-with-a-given-value/README.md
 create mode 100644 delete-node-in-a-bst/README.md
 create mode 100644 delete-node-in-a-bst/delete-node-in-a-bst.cpp
 create mode 100644 delete-node-in-a-linked-list/README.md
 create mode 100644 delete-node-in-a-linked-list/delete-node-in-a-linked-list.cpp
 create mode 100644 destination-city/README.md
 create mode 100644 detonate-the-maximum-bombs/README.md
 create mode 100644 detonate-the-maximum-bombs/detonate-the-maximum-bombs.cpp
 create mode 100644 di-string-match/README.md
 create mode 100644 di-string-match/di-string-match.cpp
 create mode 100644 diameter-of-binary-tree/README.md
 create mode 100644 diameter-of-binary-tree/diameter-of-binary-tree.cpp
 create mode 100644 different-ways-to-add-parentheses/README.md
 create mode 100644 divide-two-integers/README.md
 create mode 100644 edit-distance/README.md
 create mode 100644 encode-and-decode-tinyurl/README.md
 create mode 100644 encode-and-decode-tinyurl/encode-and-decode-tinyurl.cpp
 create mode 100644 excel-sheet-column-title/README.md
 create mode 100644 excel-sheet-column-title/excel-sheet-column-title.cpp
 create mode 100644 fibonacci-number/README.md
 create mode 100644 fibonacci-number/fibonacci-number.cpp
 create mode 100644 find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/README.md
 create mode 100644 find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree.cpp
 create mode 100644 find-all-numbers-disappeared-in-an-array/README.md
 create mode 100644 find-all-numbers-disappeared-in-an-array/find-all-numbers-disappeared-in-an-array.cpp
 create mode 100644 find-center-of-star-graph/README.md
 create mode 100644 find-center-of-star-graph/find-center-of-star-graph.cpp
 create mode 100644 find-first-and-last-position-of-element-in-sorted-array/README.md
 create mode 100644 find-first-and-last-position-of-element-in-sorted-array/find-first-and-last-position-of-element-in-sorted-array.cpp
 create mode 100644 find-median-from-data-stream/README.md
 create mode 100644 find-median-from-data-stream/find-median-from-data-stream.cpp
 create mode 100644 find-minimum-in-rotated-sorted-array-ii/README.md
 create mode 100644 find-minimum-in-rotated-sorted-array-ii/find-minimum-in-rotated-sorted-array-ii.cpp
 create mode 100644 find-minimum-in-rotated-sorted-array/README.md
 create mode 100644 find-minimum-in-rotated-sorted-array/find-minimum-in-rotated-sorted-array.cpp
 create mode 100644 find-peak-element/README.md
 create mode 100644 find-peak-element/find-peak-element.cpp
 create mode 100644 find-positive-integer-solution-for-a-given-equation/README.md
 create mode 100644 find-the-duplicate-number/README.md
 create mode 100644 find-the-duplicate-number/find-the-duplicate-number.cpp
 create mode 100644 find-the-town-judge/README.md
 create mode 100644 find-the-town-judge/find-the-town-judge.cpp
 create mode 100644 find-the-winner-of-the-circular-game/README.md
 create mode 100644 finding-the-users-active-minutes/README.md
 create mode 100644 first-bad-version/README.md
 create mode 100644 first-bad-version/first-bad-version.cpp
 create mode 100644 flatten-a-multilevel-doubly-linked-list/README.md
 create mode 100644 flatten-a-multilevel-doubly-linked-list/flatten-a-multilevel-doubly-linked-list.cpp
 create mode 100644 flatten-binary-tree-to-linked-list/README.md
 create mode 100644 flatten-binary-tree-to-linked-list/flatten-binary-tree-to-linked-list.cpp
 create mode 100644 flip-columns-for-maximum-number-of-equal-rows/README.md
 create mode 100644 flip-string-to-monotone-increasing/README.md
 create mode 100644 flip-string-to-monotone-increasing/flip-string-to-monotone-increasing.cpp
 create mode 100644 flood-fill/README.md
 create mode 100644 flood-fill/flood-fill.cpp
 create mode 100644 fruit-into-baskets/README.md
 create mode 100644 generate-parentheses/README.md
 create mode 100644 generate-parentheses/generate-parentheses.cpp
 create mode 100644 group-anagrams/README.md
 create mode 100644 group-anagrams/group-anagrams.cpp
 create mode 100644 group-the-people-given-the-group-size-they-belong-to/README.md
 create mode 100644 group-the-people-given-the-group-size-they-belong-to/group-the-people-given-the-group-size-they-belong-to.cpp
 create mode 100644 hamming-distance/README.md
 create mode 100644 hamming-distance/hamming-distance.cpp
 create mode 100644 house-robber-ii/README.md
 create mode 100644 house-robber-iii/README.md
 create mode 100644 house-robber-iii/house-robber-iii.cpp
 create mode 100644 house-robber/README.md
 create mode 100644 house-robber/house-robber.cpp
 create mode 100644 increasing-order-search-tree/README.md
 create mode 100644 insert-into-a-binary-search-tree/README.md
 create mode 100644 insert-into-a-binary-search-tree/insert-into-a-binary-search-tree.cpp
 create mode 100644 insertion-sort-list/README.md
 create mode 100644 insertion-sort-list/insertion-sort-list.cpp
 create mode 100644 integer-break/README.md
 create mode 100644 integer-break/integer-break.cpp
 create mode 100644 intersection-of-two-arrays/README.md
 create mode 100644 intersection-of-two-arrays/intersection-of-two-arrays.cpp
 create mode 100644 intersection-of-two-linked-lists/README.md
 create mode 100644 intersection-of-two-linked-lists/intersection-of-two-linked-lists.cpp
 create mode 100644 interval-list-intersections/README.md
 create mode 100644 interval-list-intersections/interval-list-intersections.cpp
 create mode 100644 intervals-between-identical-elements/README.md
 create mode 100644 invert-binary-tree/README.md
 create mode 100644 invert-binary-tree/invert-binary-tree.cpp
 create mode 100644 is-graph-bipartite/README.md
 create mode 100644 is-graph-bipartite/is-graph-bipartite.cpp
 create mode 100644 is-subsequence/README.md
 create mode 100644 is-subsequence/is-subsequence.cpp
 create mode 100644 isomorphic-strings/README.md
 create mode 100644 isomorphic-strings/isomorphic-strings.cpp
 create mode 100644 iterator-for-combination/README.md
 create mode 100644 iterator-for-combination/iterator-for-combination.cpp
 create mode 100644 jewels-and-stones/README.md
 create mode 100644 jewels-and-stones/jewels-and-stones.cpp
 create mode 100644 jump-game-ii/README.md
 create mode 100644 jump-game-ii/jump-game-ii.cpp
 create mode 100644 jump-game/README.md
 create mode 100644 k-closest-points-to-origin/README.md
 create mode 100644 k-closest-points-to-origin/k-closest-points-to-origin.cpp
 create mode 100644 koko-eating-bananas/README.md
 create mode 100644 kth-largest-element-in-an-array/README.md
 create mode 100644 kth-smallest-element-in-a-bst/README.md
 create mode 100644 kth-smallest-element-in-a-bst/kth-smallest-element-in-a-bst.cpp
 create mode 100644 kth-smallest-element-in-a-sorted-matrix/README.md
 create mode 100644 kth-smallest-element-in-a-sorted-matrix/kth-smallest-element-in-a-sorted-matrix.cpp
 create mode 100644 largest-component-size-by-common-factor/README.md
 create mode 100644 largest-component-size-by-common-factor/largest-component-size-by-common-factor.cpp
 create mode 100644 letter-combinations-of-a-phone-number/README.md
 create mode 100644 letter-combinations-of-a-phone-number/letter-combinations-of-a-phone-number.cpp
 create mode 100644 linked-list-cycle-ii/README.md
 create mode 100644 linked-list-cycle/README.md
 create mode 100644 linked-list-cycle/linked-list-cycle.cpp
 create mode 100644 longest-common-subsequence/README.md
 create mode 100644 longest-common-subsequence/longest-common-subsequence.cpp
 create mode 100644 longest-consecutive-sequence/README.md
 create mode 100644 longest-consecutive-sequence/longest-consecutive-sequence.cpp
 create mode 100644 longest-increasing-subsequence/README.md
 create mode 100644 longest-increasing-subsequence/longest-increasing-subsequence.cpp
 create mode 100644 longest-palindromic-subsequence/README.md
 create mode 100644 longest-palindromic-substring/README.md
 create mode 100644 longest-palindromic-substring/longest-palindromic-substring.cpp
 create mode 100644 longest-repeating-character-replacement/README.md
 create mode 100644 longest-substring-without-repeating-characters/README.md
 create mode 100644 longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.cpp
 create mode 100644 longest-uncommon-subsequence-ii/README.md
 create mode 100644 lowest-common-ancestor-of-a-binary-search-tree/README.md
 create mode 100644 lowest-common-ancestor-of-a-binary-search-tree/lowest-common-ancestor-of-a-binary-search-tree.cpp
 create mode 100644 lowest-common-ancestor-of-a-binary-tree/README.md
 create mode 100644 lowest-common-ancestor-of-a-binary-tree/lowest-common-ancestor-of-a-binary-tree.cpp
 create mode 100644 majority-element-ii/README.md
 create mode 100644 majority-element-ii/majority-element-ii.cpp
 create mode 100644 majority-element/README.md
 create mode 100644 majority-element/majority-element.cpp
 create mode 100644 make-the-string-great/README.md
 create mode 100644 make-the-string-great/make-the-string-great.cpp
 create mode 100644 matrix-block-sum/README.md
 create mode 100644 matrix-block-sum/matrix-block-sum.cpp
 create mode 100644 max-area-of-island/README.md
 create mode 100644 max-area-of-island/max-area-of-island.cpp
 create mode 100644 max-consecutive-ones-iii/README.md
 create mode 100644 max-consecutive-ones-iii/max-consecutive-ones-iii.cpp
 create mode 100644 max-consecutive-ones/README.md
 create mode 100644 max-consecutive-ones/max-consecutive-ones.cpp
 create mode 100644 maximal-rectangle/README.md
 create mode 100644 maximal-rectangle/maximal-rectangle.cpp
 create mode 100644 maximal-square/README.md
 create mode 100644 maximal-square/maximal-square.cpp
 create mode 100644 maximum-69-number/README.md
 create mode 100644 maximum-average-subarray-i/README.md
 create mode 100644 maximum-average-subarray-i/maximum-average-subarray-i.cpp
 create mode 100644 maximum-binary-tree/README.md
 create mode 100644 maximum-depth-of-binary-tree/README.md
 create mode 100644 maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.cpp
 create mode 100644 maximum-difference-between-node-and-ancestor/README.md
 create mode 100644 maximum-difference-between-node-and-ancestor/maximum-difference-between-node-and-ancestor.cpp
 create mode 100644 maximum-employees-to-be-invited-to-a-meeting/README.md
 create mode 100644 maximum-length-of-repeated-subarray/README.md
 create mode 100644 maximum-length-of-subarray-with-positive-product/README.md
 create mode 100644 maximum-product-subarray/README.md
 create mode 100644 maximum-product-subarray/maximum-product-subarray.cpp
 create mode 100644 maximum-profit-in-job-scheduling/README.md
 create mode 100644 maximum-profit-in-job-scheduling/maximum-profit-in-job-scheduling.cpp
 create mode 100644 maximum-score-from-removing-stones/README.md
 create mode 100644 maximum-subarray/README.md
 create mode 100644 maximum-subarray/maximum-subarray.cpp
 create mode 100644 maximum-sum-circular-subarray/README.md
 create mode 100644 maximum-sum-circular-subarray/maximum-sum-circular-subarray.cpp
 create mode 100644 maximum-units-on-a-truck/README.md
 create mode 100644 maximum-units-on-a-truck/maximum-units-on-a-truck.cpp
 create mode 100644 median-of-two-sorted-arrays/README.md
 create mode 100644 median-of-two-sorted-arrays/median-of-two-sorted-arrays.cpp
 create mode 100644 merge-intervals/README.md
 create mode 100644 merge-intervals/merge-intervals.cpp
 create mode 100644 merge-k-sorted-lists/README.md
 create mode 100644 merge-k-sorted-lists/merge-k-sorted-lists.cpp
 create mode 100644 merge-sorted-array/README.md
 create mode 100644 merge-sorted-array/merge-sorted-array.cpp
 create mode 100644 merge-two-binary-trees/README.md
 create mode 100644 merge-two-binary-trees/merge-two-binary-trees.cpp
 create mode 100644 merge-two-sorted-lists/README.md
 create mode 100644 merge-two-sorted-lists/merge-two-sorted-lists.cpp
 create mode 100644 middle-of-the-linked-list/README.md
 create mode 100644 middle-of-the-linked-list/middle-of-the-linked-list.cpp
 create mode 100644 min-cost-climbing-stairs/README.md
 create mode 100644 min-cost-climbing-stairs/min-cost-climbing-stairs.cpp
 create mode 100644 minimum-absolute-difference-in-bst/README.md
 create mode 100644 minimum-absolute-difference-in-bst/minimum-absolute-difference-in-bst.cpp
 create mode 100644 minimum-cost-to-move-chips-to-the-same-position/README.md
 create mode 100644 minimum-cost-to-move-chips-to-the-same-position/minimum-cost-to-move-chips-to-the-same-position.cpp
 create mode 100644 minimum-depth-of-binary-tree/README.md
 create mode 100644 minimum-depth-of-binary-tree/minimum-depth-of-binary-tree.cpp
 create mode 100644 minimum-distance-between-bst-nodes/README.md
 create mode 100644 minimum-distance-between-bst-nodes/minimum-distance-between-bst-nodes.cpp
 create mode 100644 minimum-falling-path-sum/README.md
 create mode 100644 minimum-falling-path-sum/minimum-falling-path-sum.cpp
 create mode 100644 minimum-height-trees/README.md
 create mode 100644 minimum-number-of-buckets-required-to-collect-rainwater-from-houses/README.md
 create mode 100644 minimum-number-of-steps-to-make-two-strings-anagram/README.md
 create mode 100644 minimum-number-of-steps-to-make-two-strings-anagram/minimum-number-of-steps-to-make-two-strings-anagram.cpp
 create mode 100644 minimum-operations-to-make-array-equal/README.md
 create mode 100644 minimum-operations-to-make-the-array-k-increasing/README.md
 create mode 100644 minimum-operations-to-make-the-array-k-increasing/minimum-operations-to-make-the-array-k-increasing.cpp
 create mode 100644 minimum-path-sum/README.md
 create mode 100644 minimum-path-sum/minimum-path-sum.cpp
 create mode 100644 minimum-size-subarray-sum/README.md
 create mode 100644 minimum-size-subarray-sum/minimum-size-subarray-sum.cpp
 create mode 100644 minimum-value-to-get-positive-step-by-step-sum/README.md
 create mode 100644 minimum-value-to-get-positive-step-by-step-sum/minimum-value-to-get-positive-step-by-step-sum.cpp
 create mode 100644 minimum-window-substring/README.md
 create mode 100644 minimum-window-substring/minimum-window-substring.cpp
 create mode 100644 move-zeroes/README.md
 create mode 100644 move-zeroes/move-zeroes.cpp
 create mode 100644 multiply-strings/README.md
 create mode 100644 multiply-strings/multiply-strings.cpp
 create mode 100644 n-ary-tree-level-order-traversal/README.md
 create mode 100644 n-ary-tree-level-order-traversal/n-ary-tree-level-order-traversal.cpp
 create mode 100644 n-ary-tree-preorder-traversal/README.md
 create mode 100644 n-ary-tree-preorder-traversal/n-ary-tree-preorder-traversal.cpp
 create mode 100644 n-th-tribonacci-number/README.md
 create mode 100644 n-th-tribonacci-number/n-th-tribonacci-number.cpp
 create mode 100644 nCr mod M _ Part 1 - GFG/README.md
 create mode 100644 nCr mod M _ Part 1 - GFG/n-cr-mod-m-part-1.cpp
 create mode 100644 next-greater-element-i/README.md
 create mode 100644 next-greater-element-i/next-greater-element-i.cpp
 create mode 100644 next-greater-element-ii/README.md
 create mode 100644 next-greater-element-ii/next-greater-element-ii.cpp
 create mode 100644 next-permutation/README.md
 create mode 100644 next-permutation/next-permutation.cpp
 create mode 100644 number-of-1-bits/README.md
 create mode 100644 number-of-islands/README.md
 create mode 100644 number-of-islands/number-of-islands.cpp
 create mode 100644 number-of-provinces/README.md
 create mode 100644 number-of-provinces/number-of-provinces.cpp
 create mode 100644 number-of-valid-words-for-each-puzzle/README.md
 create mode 100644 odd-even-linked-list/README.md
 create mode 100644 odd-even-linked-list/odd-even-linked-list.cpp
 create mode 100644 pairs-of-songs-with-total-durations-divisible-by-60/README.md
 create mode 100644 pairs-of-songs-with-total-durations-divisible-by-60/pairs-of-songs-with-total-durations-divisible-by-60.cpp
 create mode 100644 palindrome-linked-list/README.md
 create mode 100644 palindrome-linked-list/palindrome-linked-list.cpp
 create mode 100644 palindrome-partitioning-ii/README.md
 create mode 100644 partition-array-for-maximum-sum/README.md
 create mode 100644 partition-array-for-maximum-sum/partition-array-for-maximum-sum.cpp
 create mode 100644 partition-array-into-disjoint-intervals/README.md
 create mode 100644 partition-array-into-disjoint-intervals/partition-array-into-disjoint-intervals.cpp
 create mode 100644 pascals-triangle-ii/README.md
 create mode 100644 pascals-triangle/README.md
 create mode 100644 pascals-triangle/pascals-triangle.cpp
 create mode 100644 patching-array/README.md
 create mode 100644 patching-array/patching-array.cpp
 create mode 100644 path-sum-ii/README.md
 create mode 100644 path-sum-ii/path-sum-ii.cpp
 create mode 100644 path-sum/README.md
 create mode 100644 path-sum/path-sum.cpp
 create mode 100644 perfect-squares/README.md
 create mode 100644 perfect-squares/perfect-squares.cpp
 create mode 100644 permutations-ii/README.md
 create mode 100644 permutations-ii/permutations-ii.cpp
 create mode 100644 populating-next-right-pointers-in-each-node/README.md
 create mode 100644 populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node.cpp
 create mode 100644 populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node.java
 create mode 100644 power-of-four/README.md
 create mode 100644 power-of-four/power-of-four.cpp
 create mode 100644 power-of-three/README.md
 create mode 100644 power-of-three/power-of-three.cpp
 create mode 100644 power-of-two/README.md
 create mode 100644 power-of-two/power-of-two.cpp
 create mode 100644 powx-n/README.md
 create mode 100644 powx-n/powx-n.cpp
 create mode 100644 product-of-array-except-self/README.md
 create mode 100644 product-of-array-except-self/product-of-array-except-self.cpp
 create mode 100644 product-of-the-last-k-numbers/README.md
 create mode 100644 push-dominoes/README.md
 create mode 100644 push-dominoes/push-dominoes.cpp
 create mode 100644 range-addition-ii/README.md
 create mode 100644 range-addition-ii/range-addition-ii.cpp
 create mode 100644 range-sum-of-bst/README.md
 create mode 100644 range-sum-of-bst/range-sum-of-bst.cpp
 create mode 100644 range-sum-query-2d-immutable/README.md
 create mode 100644 range-sum-query-2d-immutable/range-sum-query-2d-immutable.cpp
 create mode 100644 range-sum-query-immutable/README.md
 create mode 100644 rank-transform-of-a-matrix/README.md
 create mode 100644 rank-transform-of-a-matrix/rank-transform-of-a-matrix.cpp
 create mode 100644 remove-boxes/README.md
 create mode 100644 remove-duplicates-from-sorted-array/README.md
 create mode 100644 remove-duplicates-from-sorted-array/remove-duplicates-from-sorted-array.cpp
 create mode 100644 remove-linked-list-elements/README.md
 create mode 100644 remove-linked-list-elements/remove-linked-list-elements.cpp
 create mode 100644 remove-nth-node-from-end-of-list/README.md
 create mode 100644 remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.cpp
 create mode 100644 reorder-list/README.md
 create mode 100644 reverse-linked-list/README.md
 create mode 100644 reverse-linked-list/reverse-linked-list.cpp
 create mode 100644 reverse-nodes-in-k-group/README.md
 create mode 100644 reverse-nodes-in-k-group/reverse-nodes-in-k-group.cpp
 create mode 100644 reverse-pairs/README.md
 create mode 100644 reverse-pairs/reverse-pairs.cpp
 create mode 100644 reverse-words-in-a-string-iii/README.md
 create mode 100644 robot-return-to-origin/README.md
 create mode 100644 robot-return-to-origin/robot-return-to-origin.cpp
 create mode 100644 roman-to-integer/README.md
 create mode 100644 roman-to-integer/roman-to-integer.cpp
 create mode 100644 rotate-array/README.md
 create mode 100644 rotate-array/rotate-array.cpp
 create mode 100644 rotate-image/README.md
 create mode 100644 rotate-image/rotate-image.cpp
 create mode 100644 rotate-list/README.md
 create mode 100644 rotate-list/rotate-list.cpp
 create mode 100644 rotated-digits/README.md
 create mode 100644 rotated-digits/rotated-digits.cpp
 create mode 100644 rotting-oranges/README.md
 create mode 100644 rotting-oranges/rotting-oranges.cpp
 create mode 100644 same-tree/README.md
 create mode 100644 same-tree/same-tree.cpp
 create mode 100644 search-a-2d-matrix-ii/README.md
 create mode 100644 search-a-2d-matrix-ii/search-a-2d-matrix-ii.cpp
 create mode 100644 search-a-2d-matrix/README.md
 create mode 100644 search-a-2d-matrix/search-a-2d-matrix.cpp
 create mode 100644 search-in-rotated-sorted-array/README.md
 create mode 100644 search-in-rotated-sorted-array/search-in-rotated-sorted-array.cpp
 create mode 100644 search-insert-position/README.md
 create mode 100644 search-insert-position/search-insert-position.cpp
 create mode 100644 second-highest-salary/README.md
 create mode 100644 second-highest-salary/second-highest-salary.sql
 create mode 100644 set-matrix-zeroes/README.md
 create mode 100644 set-matrix-zeroes/set-matrix-zeroes.cpp
 create mode 100644 shuffle-an-array/README.md
 create mode 100644 shuffle-an-array/shuffle-an-array.cpp
 create mode 100644 single-element-in-a-sorted-array/README.md
 create mode 100644 single-element-in-a-sorted-array/single-element-in-a-sorted-array.cpp
 create mode 100644 single-number-iii/README.md
 create mode 100644 single-number-iii/single-number-iii.cpp
 create mode 100644 slowest-key/README.md
 create mode 100644 slowest-key/slowest-key.cpp
 create mode 100644 smallest-integer-divisible-by-k/README.md
 create mode 100644 smallest-integer-divisible-by-k/smallest-integer-divisible-by-k.cpp
 create mode 100644 sort-an-array/README.md
 create mode 100644 sort-an-array/sort-an-array.cpp
 create mode 100644 sort-characters-by-frequency/README.md
 create mode 100644 sort-characters-by-frequency/sort-characters-by-frequency.cpp
 create mode 100644 sort-colors/README.md
 create mode 100644 sort-colors/sort-colors.cpp
 create mode 100644 sort-integers-by-the-number-of-1-bits/README.md
 create mode 100644 spiral-matrix/README.md
 create mode 100644 spiral-matrix/spiral-matrix.cpp
 create mode 100644 sqrtx/README.md
 create mode 100644 sqrtx/sqrtx.cpp
 create mode 100644 squares-of-a-sorted-array/README.md
 create mode 100644 squares-of-a-sorted-array/squares-of-a-sorted-array.cpp
 create mode 100644 stone-game/README.md
 create mode 100644 stone-game/stone-game.cpp
 create mode 100644 subsets/README.md
 create mode 100644 subsets/subsets.cpp
 create mode 100644 sum-of-left-leaves/README.md
 create mode 100644 sum-of-left-leaves/sum-of-left-leaves.cpp
 create mode 100644 sum-of-nodes-with-even-valued-grandparent/README.md
 create mode 100644 sum-of-nodes-with-even-valued-grandparent/sum-of-nodes-with-even-valued-grandparent.cpp
 create mode 100644 sum-of-square-numbers/README.md
 create mode 100644 sum-of-square-numbers/sum-of-square-numbers.cpp
 create mode 100644 sum-root-to-leaf-numbers/README.md
 create mode 100644 surrounded-regions/README.md
 create mode 100644 surrounded-regions/surrounded-regions.cpp
 create mode 100644 symmetric-tree/README.md
 create mode 100644 three-equal-parts/README.md
 create mode 100644 three-equal-parts/three-equal-parts.cpp
 create mode 100644 total-hamming-distance/README.md
 create mode 100644 trapping-rain-water/README.md
 create mode 100644 trapping-rain-water/trapping-rain-water.cpp
 create mode 100644 triangle/README.md
 create mode 100644 trim-a-binary-search-tree/README.md
 create mode 100644 trim-a-binary-search-tree/trim-a-binary-search-tree.cpp
 create mode 100644 two-sum-ii-input-array-is-sorted/README.md
 create mode 100644 two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted.cpp
 create mode 100644 two-sum-iv-input-is-a-bst/README.md
 create mode 100644 two-sum-iv-input-is-a-bst/two-sum-iv-input-is-a-bst.cpp
 create mode 100644 two-sum/README.md
 create mode 100644 two-sum/two-sum.cpp
 create mode 100644 ugly-number-ii/README.md
 create mode 100644 ugly-number-ii/ugly-number-ii.cpp
 create mode 100644 unique-binary-search-trees-ii/README.md
 create mode 100644 unique-binary-search-trees/README.md
 create mode 100644 unique-binary-search-trees/unique-binary-search-trees.cpp
 create mode 100644 unique-paths-ii/README.md
 create mode 100644 unique-paths-iii/README.md
 create mode 100644 unique-paths-iii/unique-paths-iii.cpp
 create mode 100644 unique-paths/README.md
 create mode 100644 unique-paths/unique-paths.cpp
 create mode 100644 valid-palindrome/README.md
 create mode 100644 valid-palindrome/valid-palindrome.cpp
 create mode 100644 valid-parentheses/README.md
 create mode 100644 valid-parentheses/valid-parentheses.cpp
 create mode 100644 valid-sudoku/README.md
 create mode 100644 valid-sudoku/valid-sudoku.cpp
 create mode 100644 valid-triangle-number/README.md
 create mode 100644 valid-triangle-number/valid-triangle-number.cpp
 create mode 100644 validate-binary-search-tree/README.md
 create mode 100644 validate-binary-search-tree/validate-binary-search-tree.cpp
 create mode 100644 verify-preorder-serialization-of-a-binary-tree/README.md
 create mode 100644 verify-preorder-serialization-of-a-binary-tree/verify-preorder-serialization-of-a-binary-tree.cpp
 create mode 100644 walking-robot-simulation-ii/README.md
 create mode 100644 walking-robot-simulation-ii/walking-robot-simulation-ii.cpp
 create mode 100644 wiggle-subsequence/README.md
 create mode 100644 wiggle-subsequence/wiggle-subsequence.cpp
 create mode 100644 wildcard-matching/README.md
 create mode 100644 word-break/README.md
 create mode 100644 word-break/word-break.cpp
 create mode 100644 word-ladder/README.md
 create mode 100644 word-search/README.md
 create mode 100644 xor-queries-of-a-subarray/README.md

diff --git a/01-matrix/README.md b/01-matrix/README.md
new file mode 100644
index 0000000..ec1fbc2
--- /dev/null
+++ b/01-matrix/README.md
@@ -0,0 +1,29 @@
+<h2>542. 01 Matrix</h2><h3>Medium</h3><hr><div><p>Given an <code>m x n</code> binary matrix <code>mat</code>, return <em>the distance of the nearest </em><code>0</code><em> for each cell</em>.</p>
+
+<p>The distance between two adjacent cells is <code>1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/04/24/01-1-grid.jpg" style="width: 253px; height: 253px;">
+<pre><strong>Input:</strong> mat = [[0,0,0],[0,1,0],[0,0,0]]
+<strong>Output:</strong> [[0,0,0],[0,1,0],[0,0,0]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/04/24/01-2-grid.jpg" style="width: 253px; height: 253px;">
+<pre><strong>Input:</strong> mat = [[0,0,0],[0,1,0],[1,1,1]]
+<strong>Output:</strong> [[0,0,0],[0,1,0],[1,2,1]]
+</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;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= m * n &lt;= 10<sup>4</sup></code></li>
+	<li><code>mat[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
+	<li>There is at least one <code>0</code> in <code>mat</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1's Complement - GFG/1s-complement.cpp b/1's Complement - GFG/1s-complement.cpp
new file mode 100644
index 0000000..c17c0dd
--- /dev/null
+++ b/1's Complement - GFG/1s-complement.cpp	
@@ -0,0 +1,42 @@
+// { Driver Code Starts
+ 
+#include<bits/stdc++.h>
+using namespace std; 
+
+ // } Driver Code Ends
+  
+class Solution{ 
+public:
+     string onesComplement(string S,int N){
+       //code here
+   int i=0;
+   string result="";
+   while(i<N){
+       if(S[i]=='1'){
+           result.append("0");
+       }
+       else{
+           result.append("1");
+           }
+           i++;
+       }
+       return result;
+   
+   }
+};
+
+// { Driver Code Starts.
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int n;
+        cin>>n;
+        string s;
+        cin>>s;
+        Solution ob;
+        cout<<ob.onesComplement(s,n)<<"\n";
+    }
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/1's Complement - GFG/README.md b/1's Complement - GFG/README.md
new file mode 100644
index 0000000..7df5849
--- /dev/null
+++ b/1's Complement - GFG/README.md	
@@ -0,0 +1,43 @@
+# 1's Complement
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an<strong> N </strong>bit binary number, find the 1's complement of the number.&nbsp;The ones'&nbsp;complement&nbsp;of a binary number is&nbsp;defined&nbsp;as the value obtained by inverting all the bits in the binary representation of the number (swapping 0s for 1s and vice versa).</span><br>
+&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 = 3
+S = 101
+<strong>Output:
+</strong>010
+<strong>Explanation:
+</strong>We get the output by converting 1's in S
+to 0 and 0s to 1</span><strong>
+</strong></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 2
+S = 10
+<strong>Output:</strong>
+01
+<strong>Explanation:</strong>
+We get the output by converting 1's in S
+to 0 and 0s to 1</span>
+</pre>
+
+<p><br>
+<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>onesComplement()</strong>&nbsp;which takes the binary string S, its size N<strong>&nbsp;</strong>as input parameters&nbsp;and returns 1's complement of S of size N.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N)<br>
+<strong>Expected Space Complexity:</strong> O(N)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1&lt;=N&lt;=100</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/1-two-sum/1-two-sum.cpp b/1-two-sum/1-two-sum.cpp
new file mode 100644
index 0000000..1222072
--- /dev/null
+++ b/1-two-sum/1-two-sum.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map <int,int> m;
+        vector <int> v;
+       
+        for(int i=0;i<nums.size();i++)
+        {
+            if(m.find(target - nums[i]) != m.end())
+            {
+                v.push_back(i);
+                v.push_back(m[target-nums[i]]);
+            }
+            else
+            {
+                m[nums[i]] = i;
+            }
+        }
+       
+        return v;
+    }
+};
\ No newline at end of file
diff --git a/1-two-sum/NOTES.md b/1-two-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1-two-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1-two-sum/README.md b/1-two-sum/README.md
new file mode 100644
index 0000000..2776ef3
--- /dev/null
+++ b/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/100-same-tree/NOTES.md b/100-same-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/100-same-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/100-same-tree/README.md b/100-same-tree/README.md
new file mode 100644
index 0000000..149d655
--- /dev/null
+++ b/100-same-tree/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/same-tree/">100. Same Tree</a></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/1009-complement-of-base-10-integer/1009-complement-of-base-10-integer.cpp b/1009-complement-of-base-10-integer/1009-complement-of-base-10-integer.cpp
new file mode 100644
index 0000000..f31ac59
--- /dev/null
+++ b/1009-complement-of-base-10-integer/1009-complement-of-base-10-integer.cpp
@@ -0,0 +1,7 @@
+class Solution {
+public:
+  int bitwiseComplement(int N, int c = 1) {
+  while (c < N) c = (c << 1) + 1;
+  return N ^ c;
+}
+};
\ No newline at end of file
diff --git a/1009-complement-of-base-10-integer/NOTES.md b/1009-complement-of-base-10-integer/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1009-complement-of-base-10-integer/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1009-complement-of-base-10-integer/README.md b/1009-complement-of-base-10-integer/README.md
new file mode 100644
index 0000000..428c4b9
--- /dev/null
+++ b/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/1010-pairs-of-songs-with-total-durations-divisible-by-60/1010-pairs-of-songs-with-total-durations-divisible-by-60.cpp b/1010-pairs-of-songs-with-total-durations-divisible-by-60/1010-pairs-of-songs-with-total-durations-divisible-by-60.cpp
new file mode 100644
index 0000000..30300e8
--- /dev/null
+++ b/1010-pairs-of-songs-with-total-durations-divisible-by-60/1010-pairs-of-songs-with-total-durations-divisible-by-60.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int numPairsDivisibleBy60(vector<int>& time) {
+        vector<long long int> modd(60);
+        long long int total = 0;
+        for(auto a:time) modd[a%60]++;
+        for(int i=1;i<=29;i++) total += (modd[i] * modd[60-i]);
+        total = total + modd[30]*(modd[30]-1)/2 ;
+        total += modd[0]*(modd[0]-1)/2;
+        return total;
+    }
+};
\ No newline at end of file
diff --git a/1010-pairs-of-songs-with-total-durations-divisible-by-60/NOTES.md b/1010-pairs-of-songs-with-total-durations-divisible-by-60/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1010-pairs-of-songs-with-total-durations-divisible-by-60/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1010-pairs-of-songs-with-total-durations-divisible-by-60/README.md b/1010-pairs-of-songs-with-total-durations-divisible-by-60/README.md
new file mode 100644
index 0000000..2cc6399
--- /dev/null
+++ b/1010-pairs-of-songs-with-total-durations-divisible-by-60/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/pairs-of-songs-with-total-durations-divisible-by-60/">1010. Pairs of Songs With Total Durations Divisible by 60</a></h2><h3>Medium</h3><hr><div><p>You are given a list of songs where the <code>i<sup>th</sup></code> song has a duration of <code>time[i]</code> seconds.</p>
+
+<p>Return <em>the number of pairs of songs for which their total duration in seconds is divisible by</em> <code>60</code>. Formally, we want the number of indices <code>i</code>, <code>j</code> such that <code>i &lt; j</code> with <code>(time[i] + time[j]) % 60 == 0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> time = [30,20,150,100,40]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Three pairs have a total duration divisible by 60:
+(time[0] = 30, time[2] = 150): total duration 180
+(time[1] = 20, time[3] = 100): total duration 120
+(time[1] = 20, time[4] = 40): total duration 60
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> time = [60,60,60]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> All three pairs have a total duration of 120, which is divisible by 60.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= time.length &lt;= 6 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= time[i] &lt;= 500</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1011-capacity-to-ship-packages-within-d-days/1011-capacity-to-ship-packages-within-d-days.cpp b/1011-capacity-to-ship-packages-within-d-days/1011-capacity-to-ship-packages-within-d-days.cpp
new file mode 100644
index 0000000..30ecdc1
--- /dev/null
+++ b/1011-capacity-to-ship-packages-within-d-days/1011-capacity-to-ship-packages-within-d-days.cpp
@@ -0,0 +1,51 @@
+class Solution {
+public:
+    bool isPossible(int mid, vector<int>& nums, int days)
+    {
+        int count = 1;
+        int curr_sum = 0;
+        for(int i=0;i<nums.size();i++)
+        {
+            if(curr_sum + nums[i] > mid)
+            {
+                count++;
+                if(count > days)
+                    return false;
+                
+                curr_sum = nums[i];
+            }
+            else
+            {
+                curr_sum += nums[i];
+            }
+        }
+        cout<<"count  mid "<<count<<" "<<mid<<endl;
+        return true;
+    }
+    int shipWithinDays(vector<int>& nums, int days) {
+        
+        int low = 0;
+        int high = 0;
+        
+        for(int i=0;i<nums.size();i++)
+        {
+            low = max(low,nums[i]);
+            high += nums[i];
+        }
+        int ans = 0;
+        while(low <= high)
+        {
+            int mid = (low+high)>>1;
+            //cout<<mid<<" ";
+            if(isPossible(mid,nums,days))
+            {
+                
+                ans = mid;
+                high = mid - 1;
+            }
+            else
+                low = mid + 1; 
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/1011-capacity-to-ship-packages-within-d-days/NOTES.md b/1011-capacity-to-ship-packages-within-d-days/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1011-capacity-to-ship-packages-within-d-days/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1011-capacity-to-ship-packages-within-d-days/README.md b/1011-capacity-to-ship-packages-within-d-days/README.md
new file mode 100644
index 0000000..24a2400
--- /dev/null
+++ b/1011-capacity-to-ship-packages-within-d-days/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/">1011. Capacity To Ship Packages Within D Days</a></h2><h3>Medium</h3><hr><div><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>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>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>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></div>
\ No newline at end of file
diff --git a/102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.cpp b/102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.cpp
new file mode 100644
index 0000000..efb4163
--- /dev/null
+++ b/102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.cpp
@@ -0,0 +1,40 @@
+/**
+ * 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:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> ans;
+        if(root == NULL)return ans;
+        
+        queue<TreeNode*> q;
+        q.push(root);
+        
+        while(!q.empty())
+        {
+            int size = q.size();
+            vector<int> temp;
+            while(size--)
+            {
+                TreeNode * front = q.front();
+                q.pop();
+                
+                temp.push_back(front->val);
+                if(front->left)
+                    q.push(front->left);
+                if(front->right)
+                    q.push(front->right);
+            }
+            ans.push_back(temp);
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/102-binary-tree-level-order-traversal/NOTES.md b/102-binary-tree-level-order-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/102-binary-tree-level-order-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/102-binary-tree-level-order-traversal/README.md b/102-binary-tree-level-order-traversal/README.md
new file mode 100644
index 0000000..f7470bf
--- /dev/null
+++ b/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/1022-sum-of-root-to-leaf-binary-numbers/1022-sum-of-root-to-leaf-binary-numbers.cpp b/1022-sum-of-root-to-leaf-binary-numbers/1022-sum-of-root-to-leaf-binary-numbers.cpp
new file mode 100644
index 0000000..e0aa904
--- /dev/null
+++ b/1022-sum-of-root-to-leaf-binary-numbers/1022-sum-of-root-to-leaf-binary-numbers.cpp
@@ -0,0 +1,36 @@
+/**
+ * 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:
+    int ans=0;
+    int convert_decimal(vector<int> v)
+    {
+        int n=0;
+        for(int i=0;i<v.size();i++)
+            n=n*2+v[i];
+        return n;
+    }
+    void findpath(TreeNode* root,vector<int> t)
+    {
+        if(!root)return;
+        t.push_back(root->val);
+        if(!root->left && !root->right)ans+=convert_decimal(t);
+        findpath(root->left,t);
+        findpath(root->right,t);
+    }
+    int sumRootToLeaf(TreeNode* root) {
+        if(!root)return 0;
+        vector<int> t;
+        findpath(root,t);
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/1022-sum-of-root-to-leaf-binary-numbers/NOTES.md b/1022-sum-of-root-to-leaf-binary-numbers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1022-sum-of-root-to-leaf-binary-numbers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1022-sum-of-root-to-leaf-binary-numbers/README.md b/1022-sum-of-root-to-leaf-binary-numbers/README.md
new file mode 100644
index 0000000..5f1c1ad
--- /dev/null
+++ b/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/1029-two-city-scheduling/1029-two-city-scheduling.cpp b/1029-two-city-scheduling/1029-two-city-scheduling.cpp
new file mode 100644
index 0000000..5aa6001
--- /dev/null
+++ b/1029-two-city-scheduling/1029-two-city-scheduling.cpp
@@ -0,0 +1,35 @@
+class Solution {
+public:
+    static bool comp(vector<int> &v1, vector<int> &v2)
+    {
+        return ( abs(v1[0]-v1[1]) > abs(v2[0]-v2[1]) );
+    }
+    int twoCitySchedCost(vector<vector<int>>& costs) {
+        int a = costs.size()/2;
+        int b = costs.size()/2;
+        int m = 0;
+        sort(costs.begin(), costs.end(), comp);
+        
+        for(int i=0;i<costs.size();i++)
+        {
+            if(a==0)
+            {
+                m += costs[i][1];
+                b--;
+            }
+            else if(b==0)
+            {
+                m += costs[i][0];
+                a++;
+            }
+            else
+            {
+                m += min(costs[i][0], costs[i][1]);
+                if( costs[i][0] < costs[i][1] ) a--;
+                else  b--;
+            }
+        }
+
+        return m;
+    }
+};
\ No newline at end of file
diff --git a/1029-two-city-scheduling/NOTES.md b/1029-two-city-scheduling/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1029-two-city-scheduling/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1029-two-city-scheduling/README.md b/1029-two-city-scheduling/README.md
new file mode 100644
index 0000000..133527b
--- /dev/null
+++ b/1029-two-city-scheduling/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/two-city-scheduling/">1029. Two City Scheduling</a></h2><h3>Medium</h3><hr><div><p>A company is planning to interview <code>2n</code> people. Given the array <code>costs</code> where <code>costs[i] = [aCost<sub>i</sub>, bCost<sub>i</sub>]</code>,&nbsp;the cost of flying the <code>i<sup>th</sup></code> person to city <code>a</code> is <code>aCost<sub>i</sub></code>, and the cost of flying the <code>i<sup>th</sup></code> person to city <code>b</code> is <code>bCost<sub>i</sub></code>.</p>
+
+<p>Return <em>the minimum cost to fly every person to a city</em> such that exactly <code>n</code> people arrive in each city.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> costs = [[10,20],[30,200],[400,50],[30,20]]
+<strong>Output:</strong> 110
+<strong>Explanation: </strong>
+The first person goes to city A for a cost of 10.
+The second person goes to city A for a cost of 30.
+The third person goes to city B for a cost of 50.
+The fourth person goes to city B for a cost of 20.
+
+The total minimum cost is 10 + 30 + 50 + 20 = 110 to have half the people interviewing in each city.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> costs = [[259,770],[448,54],[926,667],[184,139],[840,118],[577,469]]
+<strong>Output:</strong> 1859
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> costs = [[515,563],[451,713],[537,709],[343,819],[855,779],[457,60],[650,359],[631,42]]
+<strong>Output:</strong> 3086
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 * n == costs.length</code></li>
+	<li><code>2 &lt;= costs.length &lt;= 100</code></li>
+	<li><code>costs.length</code> is even.</li>
+	<li><code>1 &lt;= aCost<sub>i</sub>, bCost<sub>i</sub> &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/103-binary-tree-zigzag-level-order-traversal/NOTES.md b/103-binary-tree-zigzag-level-order-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/103-binary-tree-zigzag-level-order-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/103-binary-tree-zigzag-level-order-traversal/README.md b/103-binary-tree-zigzag-level-order-traversal/README.md
new file mode 100644
index 0000000..d5e31c0
--- /dev/null
+++ b/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/104-maximum-depth-of-binary-tree/104-maximum-depth-of-binary-tree.cpp b/104-maximum-depth-of-binary-tree/104-maximum-depth-of-binary-tree.cpp
new file mode 100644
index 0000000..ea7915a
--- /dev/null
+++ b/104-maximum-depth-of-binary-tree/104-maximum-depth-of-binary-tree.cpp
@@ -0,0 +1,23 @@
+/**
+ * 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:
+    int maxi = 0;
+    int maxDepth(TreeNode* root) {
+        if(root == NULL)return 0;
+        
+        int l = maxDepth(root->left);
+        int r = maxDepth(root->right);
+        
+        return 1 + max(l,r);
+    }
+};
\ No newline at end of file
diff --git a/104-maximum-depth-of-binary-tree/NOTES.md b/104-maximum-depth-of-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/104-maximum-depth-of-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/104-maximum-depth-of-binary-tree/README.md b/104-maximum-depth-of-binary-tree/README.md
new file mode 100644
index 0000000..48ceddf
--- /dev/null
+++ b/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/1041-robot-bounded-in-circle/1041-robot-bounded-in-circle.cpp b/1041-robot-bounded-in-circle/1041-robot-bounded-in-circle.cpp
new file mode 100644
index 0000000..a2f2b45
--- /dev/null
+++ b/1041-robot-bounded-in-circle/1041-robot-bounded-in-circle.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    bool isRobotBounded(string instructions)
+    {
+        vector position = {0, 0}, direction = {0, 1};
+        
+        for (size_t i = 0; i < instructions.length(); i++)
+        {
+            switch(instructions[i])
+            {
+                case 'L':
+                    direction = {-direction[1], direction[0]};
+                    break;
+                case 'R':
+                    direction = {direction[1], -direction[0]};
+                    break;
+                default:
+                    position = {position[0] + direction[0], position[1] + direction[1]};
+            }
+        }
+        return  (position[0] == 0 && position[1] == 0) || (direction[0] != 0 || direction[1] != 1) ? true : false;
+    }
+};
\ No newline at end of file
diff --git a/1041-robot-bounded-in-circle/NOTES.md b/1041-robot-bounded-in-circle/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1041-robot-bounded-in-circle/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1041-robot-bounded-in-circle/README.md b/1041-robot-bounded-in-circle/README.md
new file mode 100644
index 0000000..f29c0dd
--- /dev/null
+++ b/1041-robot-bounded-in-circle/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/robot-bounded-in-circle/">1041. Robot Bounded In Circle</a></h2><h3>Medium</h3><hr><div><p>On an infinite plane, a robot initially stands at <code>(0, 0)</code> and faces north. The robot can receive one of three instructions:</p>
+
+<ul>
+	<li><code>"G"</code>: go straight 1 unit;</li>
+	<li><code>"L"</code>: turn 90 degrees to the left;</li>
+	<li><code>"R"</code>: turn 90 degrees to the right.</li>
+</ul>
+
+<p>The robot performs the <code>instructions</code> given in order, and repeats them forever.</p>
+
+<p>Return <code>true</code> if and only if there exists a circle in the plane such that the robot never leaves the circle.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> instructions = "GGLLGG"
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The robot moves from (0,0) to (0,2), turns 180 degrees, and then returns to (0,0).
+When repeating these instructions, the robot remains in the circle of radius 2 centered at the origin.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> instructions = "GG"
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The robot moves north indefinitely.</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> instructions = "GL"
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The robot moves from (0, 0) -&gt; (0, 1) -&gt; (-1, 1) -&gt; (-1, 0) -&gt; (0, 0) -&gt; ...</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= instructions.length &lt;= 100</code></li>
+	<li><code>instructions[i]</code> is <code>'G'</code>, <code>'L'</code> or, <code>'R'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1049-last-stone-weight-ii/1049-last-stone-weight-ii.cpp b/1049-last-stone-weight-ii/1049-last-stone-weight-ii.cpp
new file mode 100644
index 0000000..c81e856
--- /dev/null
+++ b/1049-last-stone-weight-ii/1049-last-stone-weight-ii.cpp
@@ -0,0 +1,36 @@
+class Solution {
+public:
+    int lastStoneWeightII(vector<int>& stones) {
+        
+        int n = stones.size();
+        if(n == 1)return stones[0];
+        int sum = 0;
+        for(auto i:stones)sum+=i;
+        vector<vector<int>> dp(stones.size(),vector<int> (sum+1,0));
+        
+        dp[0][stones[0]] = 1;
+        for(int i=0;i<n;i++)
+            dp[i][0] = 1;
+        
+        int ans = INT_MIN;
+        for(int i=1;i<n;i++)
+        {
+            for(int j = 1;j<=sum;j++)
+            {
+                int nottake = dp[i-1][j];
+                int take = 0;
+                if(stones[i] <= j)
+                    take = dp[i-1][j-stones[i]];
+                
+                dp[i][j] = take|nottake;
+                
+                if(i == n-1 && j<=sum/2 && dp[i][j] == 1)
+                    ans = max(ans,j);
+            }
+        }
+        if(ans == INT_MIN)
+            return -1;
+        
+        return (sum - (2*ans));
+    }
+};
\ No newline at end of file
diff --git a/1049-last-stone-weight-ii/NOTES.md b/1049-last-stone-weight-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1049-last-stone-weight-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1049-last-stone-weight-ii/README.md b/1049-last-stone-weight-ii/README.md
new file mode 100644
index 0000000..1d3d01a
--- /dev/null
+++ b/1049-last-stone-weight-ii/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/last-stone-weight-ii/">1049. Last Stone Weight II</a></h2><h3>Medium</h3><hr><div><p>You are given an array of integers <code>stones</code> where <code>stones[i]</code> is the weight of the <code>i<sup>th</sup></code> stone.</p>
+
+<p>We are playing a game with the stones. On each turn, we choose any two stones and smash them together. Suppose the stones have weights <code>x</code> and <code>y</code> with <code>x &lt;= y</code>. The result of this smash is:</p>
+
+<ul>
+	<li>If <code>x == y</code>, both stones are destroyed, and</li>
+	<li>If <code>x != y</code>, the stone of weight <code>x</code> is destroyed, and the stone of weight <code>y</code> has new weight <code>y - x</code>.</li>
+</ul>
+
+<p>At the end of the game, there is <strong>at most one</strong> stone left.</p>
+
+<p>Return <em>the smallest possible weight of the left stone</em>. If there are no stones left, return <code>0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> stones = [2,7,4,1,8,1]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong>
+We can combine 2 and 4 to get 2, so the array converts to [2,7,1,8,1] then,
+we can combine 7 and 8 to get 1, so the array converts to [2,1,1,1] then,
+we can combine 2 and 1 to get 1, so the array converts to [1,1,1] then,
+we can combine 1 and 1 to get 0, so the array converts to [1], then that's the optimal value.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> stones = [31,26,33,21,40]
+<strong>Output:</strong> 5
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= stones.length &lt;= 30</code></li>
+	<li><code>1 &lt;= stones[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/105-construct-binary-tree-from-preorder-and-inorder-traversal/105-construct-binary-tree-from-preorder-and-inorder-traversal.cpp b/105-construct-binary-tree-from-preorder-and-inorder-traversal/105-construct-binary-tree-from-preorder-and-inorder-traversal.cpp
new file mode 100644
index 0000000..9c0a134
--- /dev/null
+++ b/105-construct-binary-tree-from-preorder-and-inorder-traversal/105-construct-binary-tree-from-preorder-and-inorder-traversal.cpp
@@ -0,0 +1,57 @@
+/**
+ * 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:
+    TreeNode * helper(vector<int>& preorder, vector<int>& inorder,int pres,int pree,int ins,int ine)
+    {
+      
+        if(ins > ine)
+            return NULL;
+        
+        int rootIndex = -1;
+        int rootData = preorder[pres];
+        
+        for(int i=ins;i<=ine;i++)
+        {
+            if(inorder[i] == rootData)
+            {
+                rootIndex = i;
+                break;
+            } 
+        }
+        
+        int lins = ins;
+        int line = rootIndex-1;
+        int lpres = pres+1;
+        int lpree = line - lins + lpres;
+        int rins = rootIndex+1;
+        int rine = ine;
+        int rpree = pree;
+        int rpres = lpree + 1; ; 
+       
+        
+        TreeNode * root = new TreeNode(rootData);
+        TreeNode * leftChild = helper(preorder,inorder,lpres,lpres,lins,line);
+        TreeNode * rightChild = helper(preorder,inorder,rpres,rpree,rins,rine);
+        
+        root->left = leftChild;
+        root->right = rightChild;
+        
+        return root;
+      
+    }
+  
+    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
+      
+        return helper(preorder,inorder,0,preorder.size()-1,0,inorder.size()-1);
+    }
+};
\ No newline at end of file
diff --git a/105-construct-binary-tree-from-preorder-and-inorder-traversal/NOTES.md b/105-construct-binary-tree-from-preorder-and-inorder-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/105-construct-binary-tree-from-preorder-and-inorder-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/105-construct-binary-tree-from-preorder-and-inorder-traversal/README.md b/105-construct-binary-tree-from-preorder-and-inorder-traversal/README.md
new file mode 100644
index 0000000..050dde7
--- /dev/null
+++ b/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/108-convert-sorted-array-to-binary-search-tree/108-convert-sorted-array-to-binary-search-tree.cpp b/108-convert-sorted-array-to-binary-search-tree/108-convert-sorted-array-to-binary-search-tree.cpp
new file mode 100644
index 0000000..e4bb3bb
--- /dev/null
+++ b/108-convert-sorted-array-to-binary-search-tree/108-convert-sorted-array-to-binary-search-tree.cpp
@@ -0,0 +1,38 @@
+/**
+ * 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:
+    
+    TreeNode* helper(vector<int>& nums,int start,int end)
+    {
+      if(start<= end)
+      {
+        int mid = (start+end)/2;
+        TreeNode * root = new TreeNode(nums[mid]);
+        TreeNode * left = helper(nums,start,mid-1);
+        TreeNode * right = helper(nums,mid+1,end);
+        root->left = left;
+        root->right = right;
+        return root;
+      }
+      return NULL;
+    }
+  
+    TreeNode* sortedArrayToBST(vector<int>& nums) {
+        
+      if(nums.size()==0)
+          return NULL;
+      
+      return helper(nums,0,nums.size()-1);
+      
+    }
+};
\ No newline at end of file
diff --git a/108-convert-sorted-array-to-binary-search-tree/NOTES.md b/108-convert-sorted-array-to-binary-search-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/108-convert-sorted-array-to-binary-search-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/108-convert-sorted-array-to-binary-search-tree/README.md b/108-convert-sorted-array-to-binary-search-tree/README.md
new file mode 100644
index 0000000..fad3656
--- /dev/null
+++ b/108-convert-sorted-array-to-binary-search-tree/README.md
@@ -0,0 +1,29 @@
+<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><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,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>
+</div>
\ No newline at end of file
diff --git a/1094-car-pooling/1094-car-pooling.cpp b/1094-car-pooling/1094-car-pooling.cpp
new file mode 100644
index 0000000..fcc2979
--- /dev/null
+++ b/1094-car-pooling/1094-car-pooling.cpp
@@ -0,0 +1,10 @@
+class Solution {
+public:
+    
+  bool carPooling(vector<vector<int>>& trips, int capacity) {
+  int stops[1001] = {};
+  for (auto t : trips) stops[t[1]] += t[0], stops[t[2]] -= t[0];
+  for (auto i = 0; capacity >= 0 && i < 1001; ++i) capacity -= stops[i];
+  return capacity >= 0;
+}
+};
\ No newline at end of file
diff --git a/1094-car-pooling/NOTES.md b/1094-car-pooling/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1094-car-pooling/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1094-car-pooling/README.md b/1094-car-pooling/README.md
new file mode 100644
index 0000000..a51c026
--- /dev/null
+++ b/1094-car-pooling/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/car-pooling/">1094. Car Pooling</a></h2><h3>Medium</h3><hr><div><p>There is a car with <code>capacity</code> empty seats. The vehicle only drives east (i.e., it cannot turn around and drive west).</p>
+
+<p>You are given the integer <code>capacity</code> and an array <code>trips</code> where <code>trip[i] = [numPassengers<sub>i</sub>, from<sub>i</sub>, to<sub>i</sub>]</code> indicates that the <code>i<sup>th</sup></code> trip has <code>numPassengers<sub>i</sub></code> passengers and the locations to pick them up and drop them off are <code>from<sub>i</sub></code> and <code>to<sub>i</sub></code> respectively. The locations are given as the number of kilometers due east from the car's initial location.</p>
+
+<p>Return <code>true</code><em> if it is possible to pick up and drop off all passengers for all the given trips, or </em><code>false</code><em> otherwise</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> trips = [[2,1,5],[3,3,7]], capacity = 4
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> trips = [[2,1,5],[3,3,7]], capacity = 5
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= trips.length &lt;= 1000</code></li>
+	<li><code>trips[i].length == 3</code></li>
+	<li><code>1 &lt;= numPassengers<sub>i</sub> &lt;= 100</code></li>
+	<li><code>0 &lt;= from<sub>i</sub> &lt; to<sub>i</sub> &lt;= 1000</code></li>
+	<li><code>1 &lt;= capacity &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/11-container-with-most-water/11-container-with-most-water.cpp b/11-container-with-most-water/11-container-with-most-water.cpp
new file mode 100644
index 0000000..c321884
--- /dev/null
+++ b/11-container-with-most-water/11-container-with-most-water.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int i = 0;
+        int j = height.size() - 1;   
+        int ans  = 0; 
+        while(j>i)
+        {
+            ans = max(ans,(j-i)*( min(height[i],height[j]) ) );
+            if(height[i]<= height[j])
+                i++;
+            else
+                j--;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/11-container-with-most-water/NOTES.md b/11-container-with-most-water/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/11-container-with-most-water/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/11-container-with-most-water/README.md b/11-container-with-most-water/README.md
new file mode 100644
index 0000000..fcf8ccc
--- /dev/null
+++ b/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/110-balanced-binary-tree/110-balanced-binary-tree.cpp b/110-balanced-binary-tree/110-balanced-binary-tree.cpp
new file mode 100644
index 0000000..b13df18
--- /dev/null
+++ b/110-balanced-binary-tree/110-balanced-binary-tree.cpp
@@ -0,0 +1,35 @@
+/**
+ * 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:
+    
+    int isBalHelper(TreeNode * root)
+    {
+        if(root == NULL)return 0;
+        
+        int l = isBalHelper(root->left);
+        int r = isBalHelper(root->right);
+        
+        if(l != -1 && r != -1  && abs(l-r) <= 1)
+            return 1 + max(l,r);
+        return -1;
+    }
+    
+    bool isBalanced(TreeNode* root) {
+        if(root == NULL )return true;
+        int ans = isBalHelper(root);
+        
+        if(ans == -1)
+            return false;
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/110-balanced-binary-tree/NOTES.md b/110-balanced-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/110-balanced-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/110-balanced-binary-tree/README.md b/110-balanced-binary-tree/README.md
new file mode 100644
index 0000000..ef9bb64
--- /dev/null
+++ b/110-balanced-binary-tree/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/balanced-binary-tree/">110. Balanced Binary Tree</a></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/1111-maximum-nesting-depth-of-two-valid-parentheses-strings/NOTES.md b/1111-maximum-nesting-depth-of-two-valid-parentheses-strings/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1111-maximum-nesting-depth-of-two-valid-parentheses-strings/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1111-maximum-nesting-depth-of-two-valid-parentheses-strings/README.md b/1111-maximum-nesting-depth-of-two-valid-parentheses-strings/README.md
new file mode 100644
index 0000000..f4f367a
--- /dev/null
+++ b/1111-maximum-nesting-depth-of-two-valid-parentheses-strings/README.md
@@ -0,0 +1,46 @@
+<h2><a href="https://leetcode.com/problems/maximum-nesting-depth-of-two-valid-parentheses-strings/">1111. Maximum Nesting Depth of Two Valid Parentheses Strings</a></h2><h3>Medium</h3><hr><div><p>A string is a <em>valid parentheses string</em>&nbsp;(denoted VPS) if and only if it consists of <code>"("</code> and <code>")"</code> characters only, and:</p>
+
+<ul>
+	<li>It is the empty string, or</li>
+	<li>It can be written as&nbsp;<code>AB</code>&nbsp;(<code>A</code>&nbsp;concatenated with&nbsp;<code>B</code>), where&nbsp;<code>A</code>&nbsp;and&nbsp;<code>B</code>&nbsp;are VPS's, or</li>
+	<li>It can be written as&nbsp;<code>(A)</code>, where&nbsp;<code>A</code>&nbsp;is a VPS.</li>
+</ul>
+
+<p>We can&nbsp;similarly define the <em>nesting depth</em> <code>depth(S)</code> of any VPS <code>S</code> as follows:</p>
+
+<ul>
+	<li><code>depth("") = 0</code></li>
+	<li><code>depth(A + B) = max(depth(A), depth(B))</code>, where <code>A</code> and <code>B</code> are VPS's</li>
+	<li><code>depth("(" + A + ")") = 1 + depth(A)</code>, where <code>A</code> is a VPS.</li>
+</ul>
+
+<p>For example,&nbsp; <code>""</code>,&nbsp;<code>"()()"</code>, and&nbsp;<code>"()(()())"</code>&nbsp;are VPS's (with nesting depths 0, 1, and 2), and <code>")("</code> and <code>"(()"</code> are not VPS's.</p>
+
+<p>&nbsp;</p>
+
+<p>Given a VPS <font face="monospace">seq</font>, split it into two disjoint subsequences <code>A</code> and <code>B</code>, such that&nbsp;<code>A</code> and <code>B</code> are VPS's (and&nbsp;<code>A.length + B.length = seq.length</code>).</p>
+
+<p>Now choose <strong>any</strong> such <code>A</code> and <code>B</code> such that&nbsp;<code>max(depth(A), depth(B))</code> is the minimum possible value.</p>
+
+<p>Return an <code>answer</code> array (of length <code>seq.length</code>) that encodes such a&nbsp;choice of <code>A</code> and <code>B</code>:&nbsp; <code>answer[i] = 0</code> if <code>seq[i]</code> is part of <code>A</code>, else <code>answer[i] = 1</code>.&nbsp; Note that even though multiple answers may exist, you may return any of them.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> seq = "(()())"
+<strong>Output:</strong> [0,1,1,1,1,0]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> seq = "()(())()"
+<strong>Output:</strong> [0,0,0,1,1,0,1,1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= seq.size &lt;= 10000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/114-flatten-binary-tree-to-linked-list/114-flatten-binary-tree-to-linked-list.cpp b/114-flatten-binary-tree-to-linked-list/114-flatten-binary-tree-to-linked-list.cpp
new file mode 100644
index 0000000..4784c06
--- /dev/null
+++ b/114-flatten-binary-tree-to-linked-list/114-flatten-binary-tree-to-linked-list.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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:
+    void flatten(TreeNode* root) {
+      
+      TreeNode * curr = root;
+      while(curr != NULL)
+      {
+        if(curr->left)
+        {
+        TreeNode * prev = curr->left;
+        while(prev->right)
+        {
+          prev = prev->right;
+        }
+        prev->right = curr->right;
+        curr->right = curr->left;
+        curr->left = NULL;
+        
+        }
+        curr = curr->right;
+       
+      }
+      
+      return ;
+    }
+};
\ No newline at end of file
diff --git a/114-flatten-binary-tree-to-linked-list/NOTES.md b/114-flatten-binary-tree-to-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/114-flatten-binary-tree-to-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/114-flatten-binary-tree-to-linked-list/README.md b/114-flatten-binary-tree-to-linked-list/README.md
new file mode 100644
index 0000000..03e1f9d
--- /dev/null
+++ b/114-flatten-binary-tree-to-linked-list/README.md
@@ -0,0 +1,36 @@
+<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><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/115-distinct-subsequences/115-distinct-subsequences.cpp b/115-distinct-subsequences/115-distinct-subsequences.cpp
new file mode 100644
index 0000000..592d334
--- /dev/null
+++ b/115-distinct-subsequences/115-distinct-subsequences.cpp
@@ -0,0 +1,27 @@
+class Solution {
+public:
+    
+int count(string &s, string &t, int i, int j,vector<vector<int>>& dp)
+{
+    if( j < 0)
+    {
+        return 1;
+    }
+    if(i < 0)
+        return 0;
+    if(dp[i][j] != -1)return dp[i][j];
+    
+    if(s[i] == t[j])
+    {
+        return dp[i][j] = (count(s,t,i-1,j-1,dp) + count(s,t,i-1,j,dp));
+    }
+    else
+        return dp[i][j] = count(s,t,i-1,j,dp);
+}
+    int numDistinct(string s, string t) {
+        int ls = s.size();
+        int lt = t.size();
+        vector<vector<int>> dp(ls+1,vector<int> (lt+1,-1));
+        return count(s,t,ls-1,lt-1,dp);
+    }
+};
\ No newline at end of file
diff --git a/115-distinct-subsequences/NOTES.md b/115-distinct-subsequences/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/115-distinct-subsequences/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/115-distinct-subsequences/README.md b/115-distinct-subsequences/README.md
new file mode 100644
index 0000000..b48c71b
--- /dev/null
+++ b/115-distinct-subsequences/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/distinct-subsequences/">115. Distinct Subsequences</a></h2><h3>Hard</h3><hr><div><p>Given two strings <code>s</code> and <code>t</code>, return <em>the number of distinct subsequences of <code>s</code> which equals <code>t</code></em>.</p>
+
+<p>A string's <strong>subsequence</strong> is a new string formed from the original string by deleting some (can be none) of the characters without disturbing the remaining characters' relative positions. (i.e., <code>"ACE"</code> is a subsequence of <code>"ABCDE"</code> while <code>"AEC"</code> is not).</p>
+
+<p>The test cases are generated so that the answer fits on a 32-bit signed integer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "rabbbit", t = "rabbit"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+As shown below, there are 3 ways you can generate "rabbit" from S.
+<code><strong><u>rabb</u></strong>b<strong><u>it</u></strong></code>
+<code><strong><u>ra</u></strong>b<strong><u>bbit</u></strong></code>
+<code><strong><u>rab</u></strong>b<strong><u>bit</u></strong></code>
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "babgbag", t = "bag"
+<strong>Output:</strong> 5
+<strong>Explanation:</strong>
+As shown below, there are 5 ways you can generate "bag" from S.
+<code><strong><u>ba</u></strong>b<u><strong>g</strong></u>bag</code>
+<code><strong><u>ba</u></strong>bgba<strong><u>g</u></strong></code>
+<code><u><strong>b</strong></u>abgb<strong><u>ag</u></strong></code>
+<code>ba<u><strong>b</strong></u>gb<u><strong>ag</strong></u></code>
+<code>babg<strong><u>bag</u></strong></code></pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length, t.length &lt;= 1000</code></li>
+	<li><code>s</code> and <code>t</code> consist of English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/116-populating-next-right-pointers-in-each-node/NOTES.md b/116-populating-next-right-pointers-in-each-node/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/116-populating-next-right-pointers-in-each-node/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/116-populating-next-right-pointers-in-each-node/README.md b/116-populating-next-right-pointers-in-each-node/README.md
new file mode 100644
index 0000000..99d6a63
--- /dev/null
+++ b/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/118-pascals-triangle/NOTES.md b/118-pascals-triangle/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/118-pascals-triangle/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/118-pascals-triangle/README.md b/118-pascals-triangle/README.md
new file mode 100644
index 0000000..9750c83
--- /dev/null
+++ b/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/120-triangle/120-triangle.cpp b/120-triangle/120-triangle.cpp
new file mode 100644
index 0000000..a3db30e
--- /dev/null
+++ b/120-triangle/120-triangle.cpp
@@ -0,0 +1,32 @@
+class Solution {
+public:
+    int minimumTotal(vector<vector<int>>& triangle) {
+        int n = triangle.size();
+        
+        vector<vector<int>> dp(n,vector<int> (n,0));
+        int ans = INT_MAX;
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<=i;j++)
+            {
+                if(i == 0 && j == 0)
+                    dp[i][j] = triangle[i][j];
+                else if(j==0)
+                {
+                    dp[i][j] = dp[i-1][j] + triangle[i][j];
+                }
+                else if(j==i)
+                {
+                    dp[i][j] = dp[i-1][j-1] + triangle[i][j];
+                }
+                else
+                    dp[i][j] = min(dp[i-1][j], dp[i-1][j-1]) + triangle[i][j];
+                
+                if(i==n-1)
+                    ans = min(ans,dp[i][j]); 
+            }
+        }
+        return ans;
+        
+    }
+};
\ No newline at end of file
diff --git a/120-triangle/NOTES.md b/120-triangle/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/120-triangle/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/120-triangle/README.md b/120-triangle/README.md
new file mode 100644
index 0000000..9637b47
--- /dev/null
+++ b/120-triangle/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/triangle/">120. Triangle</a></h2><h3>Medium</h3><hr><div><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>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>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?</div>
\ No newline at end of file
diff --git a/121-best-time-to-buy-and-sell-stock/121-best-time-to-buy-and-sell-stock.cpp b/121-best-time-to-buy-and-sell-stock/121-best-time-to-buy-and-sell-stock.cpp
new file mode 100644
index 0000000..64fe2cf
--- /dev/null
+++ b/121-best-time-to-buy-and-sell-stock/121-best-time-to-buy-and-sell-stock.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        
+       int lsf = INT_MAX; // least so far
+        int op = 0; // overall profit
+        int pist = 0; // profit if sold today
+        
+        for(int i = 0; i < prices.size(); i++){
+            if(prices[i] < lsf){ // if we found new buy value which is more smaller then previous one
+                lsf = prices[i]; // update our least so far
+            }
+            pist = prices[i] - lsf; // calculating profit if sold today by, Buy - sell
+            if(op < pist){ // if pist is more then our previous overall profit
+                op = pist; // update overall profit
+            }
+        }
+        return op; // return op 
+        
+    }
+};
\ No newline at end of file
diff --git a/121-best-time-to-buy-and-sell-stock/NOTES.md b/121-best-time-to-buy-and-sell-stock/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/121-best-time-to-buy-and-sell-stock/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/121-best-time-to-buy-and-sell-stock/README.md b/121-best-time-to-buy-and-sell-stock/README.md
new file mode 100644
index 0000000..9350a49
--- /dev/null
+++ b/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/122-best-time-to-buy-and-sell-stock-ii/122-best-time-to-buy-and-sell-stock-ii.cpp b/122-best-time-to-buy-and-sell-stock-ii/122-best-time-to-buy-and-sell-stock-ii.cpp
new file mode 100644
index 0000000..9262fa7
--- /dev/null
+++ b/122-best-time-to-buy-and-sell-stock-ii/122-best-time-to-buy-and-sell-stock-ii.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int ans = 0;
+        for(int i=1;i<prices.size();i++)
+        {
+            if(prices[i]-prices[i-1] >=0)
+            {
+                ans += prices[i]-prices[i-1];
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/122-best-time-to-buy-and-sell-stock-ii/NOTES.md b/122-best-time-to-buy-and-sell-stock-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/122-best-time-to-buy-and-sell-stock-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/122-best-time-to-buy-and-sell-stock-ii/README.md b/122-best-time-to-buy-and-sell-stock-ii/README.md
new file mode 100644
index 0000000..1627b40
--- /dev/null
+++ b/122-best-time-to-buy-and-sell-stock-ii/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/">122. Best Time to Buy and Sell Stock II</a></h2><h3>Medium</h3><hr><div><p>You are given an integer 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>On each day, you may decide to buy and/or sell the stock. You can only hold <strong>at most one</strong> share of the stock at any time. However, you can buy it then immediately sell it on the <strong>same day</strong>.</p>
+
+<p>Find and return <em>the <strong>maximum</strong> profit you can achieve</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> prices = [7,1,5,3,6,4]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+Total profit is 4 + 3 = 7.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> prices = [1,2,3,4,5]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+Total profit is 4.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> prices = [7,6,4,3,1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= prices.length &lt;= 3 * 10<sup>4</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/1220-count-vowels-permutation/1220-count-vowels-permutation.cpp b/1220-count-vowels-permutation/1220-count-vowels-permutation.cpp
new file mode 100644
index 0000000..56b5a68
--- /dev/null
+++ b/1220-count-vowels-permutation/1220-count-vowels-permutation.cpp
@@ -0,0 +1,37 @@
+//Matrix exponentiation.
+class Solution {
+public:
+    int MOD=1e9+7;
+    vector<vector<int>> Multiply(vector<vector<int>> &l,vector<vector<int>> &r)  
+    {
+        vector<vector<int>> result(l.size(),vector<int>(r[0].size(),0));
+        for(int i=0;i<l.size();i++)
+            for(int j=0;j<r[0].size();j++)
+                for(int k=0;k<l[0].size();k++)
+                    result[i][j]+=(long long)l[i][k]*r[k][j]%MOD,result[i][j]%=MOD;
+        return result;
+    }
+    int countVowelPermutation(int n) 
+    {
+        vector<vector<int>> M={ {0,1,0,0,0},       
+                                {1,0,1,0,0},
+                                {1,1,0,1,1},
+                                {0,0,1,0,1},
+                                {1,0,0,0,0}},result(5,vector<int>(5));
+        for(int i=0;i<5;i++)   
+            result[i][i]=1;
+        int sum=0;
+        n--;
+        while(n)    
+        {
+            if(n&1)
+                result=Multiply(M,result);
+            n>>=1;
+            M=Multiply(M,M);
+        }
+        for(vector<int> &i:result)          
+            for(int &j:i)
+                sum+=j,sum%=MOD;
+        return sum;
+    }
+};
\ No newline at end of file
diff --git a/1220-count-vowels-permutation/NOTES.md b/1220-count-vowels-permutation/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1220-count-vowels-permutation/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1220-count-vowels-permutation/README.md b/1220-count-vowels-permutation/README.md
new file mode 100644
index 0000000..6e959cb
--- /dev/null
+++ b/1220-count-vowels-permutation/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/count-vowels-permutation/">1220. Count Vowels Permutation</a></h2><h3>Hard</h3><hr><div><p>Given an integer <code>n</code>, your task is to count how many strings of length <code>n</code> can be formed under the following rules:</p>
+
+<ul>
+	<li>Each character is a lower case vowel&nbsp;(<code>'a'</code>, <code>'e'</code>, <code>'i'</code>, <code>'o'</code>, <code>'u'</code>)</li>
+	<li>Each vowel&nbsp;<code>'a'</code> may only be followed by an <code>'e'</code>.</li>
+	<li>Each vowel&nbsp;<code>'e'</code> may only be followed by an <code>'a'</code>&nbsp;or an <code>'i'</code>.</li>
+	<li>Each vowel&nbsp;<code>'i'</code> <strong>may not</strong> be followed by another <code>'i'</code>.</li>
+	<li>Each vowel&nbsp;<code>'o'</code> may only be followed by an <code>'i'</code> or a&nbsp;<code>'u'</code>.</li>
+	<li>Each vowel&nbsp;<code>'u'</code> may only be followed by an <code>'a'.</code></li>
+</ul>
+
+<p>Since the answer&nbsp;may be too large,&nbsp;return it modulo <code>10^9 + 7.</code></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> All possible strings are: "a", "e", "i" , "o" and "u".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> All possible strings are: "ae", "ea", "ei", "ia", "ie", "io", "iu", "oi", "ou" and "ua".
+</pre>
+
+<p><strong>Example 3:&nbsp;</strong></p>
+
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> 68</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 2 * 10^4</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/123-best-time-to-buy-and-sell-stock-iii/123-best-time-to-buy-and-sell-stock-iii.cpp b/123-best-time-to-buy-and-sell-stock-iii/123-best-time-to-buy-and-sell-stock-iii.cpp
new file mode 100644
index 0000000..7068a8b
--- /dev/null
+++ b/123-best-time-to-buy-and-sell-stock-iii/123-best-time-to-buy-and-sell-stock-iii.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    
+    int rec(vector<int>& prices,int transactions,int buy,int i,vector<vector<vector<int>>> & dp)
+    {
+        if(transactions == 0 || i == prices.size())return 0;
+        if(dp[i][buy][transactions] != -1 )return dp[i][buy][transactions];
+        if(buy)
+        {
+            return dp[i][buy][transactions] = max(-prices[i] + rec(prices,transactions,0,i+1,dp) , rec(prices,transactions,1,i+1,dp));
+        }
+        else
+        {
+            return dp[i][buy][transactions] = max(prices[i]+rec(prices,transactions-1,1,i+1,dp) , rec(prices,transactions,0,i+1,dp));
+        }
+    }
+    
+    int maxProfit(vector<int>& prices) {
+        vector<vector<vector<int>>> dp(prices.size(), vector<vector<int>> (2,vector<int> (3,-1)));
+        return rec(prices,2,1,0,dp);
+    }
+};
\ No newline at end of file
diff --git a/123-best-time-to-buy-and-sell-stock-iii/NOTES.md b/123-best-time-to-buy-and-sell-stock-iii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/123-best-time-to-buy-and-sell-stock-iii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/123-best-time-to-buy-and-sell-stock-iii/README.md b/123-best-time-to-buy-and-sell-stock-iii/README.md
new file mode 100644
index 0000000..6303c52
--- /dev/null
+++ b/123-best-time-to-buy-and-sell-stock-iii/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/">123. Best Time to Buy and Sell Stock III</a></h2><h3>Hard</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>Find the maximum profit you can achieve. You may complete <strong>at most two transactions</strong>.</p>
+
+<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> prices = [3,3,5,0,0,3,1,4]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> prices = [1,2,3,4,5]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> prices = [7,6,4,3,1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> In this case, no transaction is done, i.e. 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>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1249-minimum-remove-to-make-valid-parentheses/1249-minimum-remove-to-make-valid-parentheses.cpp b/1249-minimum-remove-to-make-valid-parentheses/1249-minimum-remove-to-make-valid-parentheses.cpp
new file mode 100644
index 0000000..625d73c
--- /dev/null
+++ b/1249-minimum-remove-to-make-valid-parentheses/1249-minimum-remove-to-make-valid-parentheses.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    string minRemoveToMakeValid(string s) {
+  stack<int> st;
+  for (auto i = 0; i < s.size(); ++i) {
+    if (s[i] == '(') st.push(i);
+    if (s[i] == ')') {
+      if (!st.empty()) st.pop();
+      else s[i] = '*';
+    }
+  }
+  while (!st.empty()) {
+    s[st.top()] = '*';
+    st.pop();
+  }
+  s.erase(remove(s.begin(), s.end(), '*'), s.end());
+  return s;
+}
+};
\ No newline at end of file
diff --git a/1249-minimum-remove-to-make-valid-parentheses/README.md b/1249-minimum-remove-to-make-valid-parentheses/README.md
new file mode 100644
index 0000000..a7562ff
--- /dev/null
+++ b/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>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>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "a)b(c)d"
+<strong>Output:</strong> "ab(c)d"
+</pre>
+
+<p><strong>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<code>'('</code> , <code>')'</code>, or lowercase English letter<code>.</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/126-word-ladder-ii/126-word-ladder-ii.cpp b/126-word-ladder-ii/126-word-ladder-ii.cpp
new file mode 100644
index 0000000..8124bc1
--- /dev/null
+++ b/126-word-ladder-ii/126-word-ladder-ii.cpp
@@ -0,0 +1,68 @@
+class Solution {
+public:
+    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
+        unordered_set<string> dict(wordList.begin(), wordList.end());
+        if(!dict.count(endWord)) return {};
+        dict.erase(beginWord);
+        dict.erase(endWord);
+        unordered_map<string, int> steps;
+        steps[beginWord] = 0;
+        unordered_map<string, vector<string> > parents;
+        const int len = beginWord.size();
+        int step = 0;
+        bool found = false;
+        queue<string> q;
+        q.push(beginWord);
+        while(!q.empty() && !found){
+            ++step;
+            for(int size = q.size(); size > 0; size--){
+                const string p = q.front(); q.pop();
+                string word = p;
+                for(int j = 0; j < len; j++){
+                    const char ch = word[j];
+                    for(int i = 'a'; i <= 'z'; i++){
+                        if(i == ch) continue;
+                        word[j] = i;
+                        if(word == endWord){
+                            found = true;
+                            parents[word].push_back(p);
+                        }else{
+                            if(steps.count(word) && step == steps.at(word) - 1)
+                                parents[word].push_back(p);
+                        }
+                        if(!dict.count(word)) continue;
+                        dict.erase(word);
+                        q.push(word);
+                        steps[word] = step + 1;
+                        parents[word].push_back(p);                        
+                    }
+                    word[j] = ch;
+                }
+            }
+        }
+        
+        vector<vector<string>> ans;
+        if(found){
+            vector<string> path; path.push_back(endWord);
+            genPath(parents, endWord, beginWord, path, ans);
+        }
+        return ans;
+    }
+    
+    void genPath(const unordered_map<string, vector<string> >& parents, 
+                 const string& currWord, 
+                 const string& beginWord, 
+                 vector<string> path, 
+                 vector<vector<string>>& ans){
+        if(currWord == beginWord){
+            ans.push_back(vector<string> (path.rbegin(), path.rend()));
+            return;
+        }
+        
+        for(const auto p: parents.at(currWord)){
+            path.push_back(p);
+            genPath(parents, p, beginWord, path, ans);
+            path.pop_back();
+        }
+    }
+};
\ No newline at end of file
diff --git a/126-word-ladder-ii/NOTES.md b/126-word-ladder-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/126-word-ladder-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/126-word-ladder-ii/README.md b/126-word-ladder-ii/README.md
new file mode 100644
index 0000000..0f47ef8
--- /dev/null
+++ b/126-word-ladder-ii/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/word-ladder-ii/">126. Word Ladder II</a></h2><h3>Hard</h3><hr><div><p>A <strong>transformation sequence</strong> from word <code>beginWord</code> to word <code>endWord</code> using a dictionary <code>wordList</code> is a sequence of words <code>beginWord -&gt; s<sub>1</sub> -&gt; s<sub>2</sub> -&gt; ... -&gt; s<sub>k</sub></code> such that:</p>
+
+<ul>
+	<li>Every adjacent pair of words differs by a single letter.</li>
+	<li>Every <code>s<sub>i</sub></code> for <code>1 &lt;= i &lt;= k</code> is in <code>wordList</code>. Note that <code>beginWord</code> does not need to be in <code>wordList</code>.</li>
+	<li><code>s<sub>k</sub> == endWord</code></li>
+</ul>
+
+<p>Given two words, <code>beginWord</code> and <code>endWord</code>, and a dictionary <code>wordList</code>, return <em>all the <strong>shortest transformation sequences</strong> from</em> <code>beginWord</code> <em>to</em> <code>endWord</code><em>, or an empty list if no such sequence exists. Each sequence should be returned as a list of the words </em><code>[beginWord, s<sub>1</sub>, s<sub>2</sub>, ..., s<sub>k</sub>]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
+<strong>Output:</strong> [["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]
+<strong>Explanation:</strong>&nbsp;There are 2 shortest transformation sequences:
+"hit" -&gt; "hot" -&gt; "dot" -&gt; "dog" -&gt; "cog"
+"hit" -&gt; "hot" -&gt; "lot" -&gt; "log" -&gt; "cog"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
+<strong>Output:</strong> []
+<strong>Explanation:</strong> The endWord "cog" is not in wordList, therefore there is no valid transformation sequence.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= beginWord.length &lt;= 5</code></li>
+	<li><code>endWord.length == beginWord.length</code></li>
+	<li><code>1 &lt;= wordList.length &lt;= 500</code></li>
+	<li><code>wordList[i].length == beginWord.length</code></li>
+	<li><code>beginWord</code>, <code>endWord</code>, and <code>wordList[i]</code> consist of lowercase English letters.</li>
+	<li><code>beginWord != endWord</code></li>
+	<li>All the words in <code>wordList</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/127-word-ladder/127-word-ladder.cpp b/127-word-ladder/127-word-ladder.cpp
new file mode 100644
index 0000000..77e1755
--- /dev/null
+++ b/127-word-ladder/127-word-ladder.cpp
@@ -0,0 +1,32 @@
+class Solution {
+public:
+    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
+        unordered_set<string> dict(wordList.begin(), wordList.end());
+        queue<string> todo;
+        todo.push(beginWord);
+        int ladder = 1;
+        while (!todo.empty()) {
+            int n = todo.size();
+            for (int i = 0; i < n; i++) {
+                string word = todo.front();
+                todo.pop();
+                if (word == endWord) {
+                    return ladder;
+                }
+                dict.erase(word);
+                for (int j = 0; j < word.size(); j++) {
+                    char c = word[j];
+                    for (int k = 0; k < 26; k++) {
+                        word[j] = 'a' + k;
+                        if (dict.find(word) != dict.end()) {
+                            todo.push(word);
+                        }
+                     }
+                    word[j] = c;
+                }
+            }
+            ladder++;
+        }
+        return 0;
+    }
+};
\ No newline at end of file
diff --git a/127-word-ladder/NOTES.md b/127-word-ladder/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/127-word-ladder/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/127-word-ladder/README.md b/127-word-ladder/README.md
new file mode 100644
index 0000000..b7bf23a
--- /dev/null
+++ b/127-word-ladder/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/word-ladder/">127. Word Ladder</a></h2><h3>Hard</h3><hr><div><p>A <strong>transformation sequence</strong> from word <code>beginWord</code> to word <code>endWord</code> using a dictionary <code>wordList</code> is a sequence of words <code>beginWord -&gt; s<sub>1</sub> -&gt; s<sub>2</sub> -&gt; ... -&gt; s<sub>k</sub></code> such that:</p>
+
+<ul>
+	<li>Every adjacent pair of words differs by a single letter.</li>
+	<li>Every <code>s<sub>i</sub></code> for <code>1 &lt;= i &lt;= k</code> is in <code>wordList</code>. Note that <code>beginWord</code> does not need to be in <code>wordList</code>.</li>
+	<li><code>s<sub>k</sub> == endWord</code></li>
+</ul>
+
+<p>Given two words, <code>beginWord</code> and <code>endWord</code>, and a dictionary <code>wordList</code>, return <em>the <strong>number of words</strong> in the <strong>shortest transformation sequence</strong> from</em> <code>beginWord</code> <em>to</em> <code>endWord</code><em>, or </em><code>0</code><em> if no such sequence exists.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> One shortest transformation sequence is "hit" -&gt; "hot" -&gt; "dot" -&gt; "dog" -&gt; cog", which is 5 words long.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The endWord "cog" is not in wordList, therefore there is no valid transformation sequence.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= beginWord.length &lt;= 10</code></li>
+	<li><code>endWord.length == beginWord.length</code></li>
+	<li><code>1 &lt;= wordList.length &lt;= 5000</code></li>
+	<li><code>wordList[i].length == beginWord.length</code></li>
+	<li><code>beginWord</code>, <code>endWord</code>, and <code>wordList[i]</code> consist of lowercase English letters.</li>
+	<li><code>beginWord != endWord</code></li>
+	<li>All the words in <code>wordList</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1283-find-the-smallest-divisor-given-a-threshold/1283-find-the-smallest-divisor-given-a-threshold.cpp b/1283-find-the-smallest-divisor-given-a-threshold/1283-find-the-smallest-divisor-given-a-threshold.cpp
new file mode 100644
index 0000000..a00416c
--- /dev/null
+++ b/1283-find-the-smallest-divisor-given-a-threshold/1283-find-the-smallest-divisor-given-a-threshold.cpp
@@ -0,0 +1,39 @@
+class Solution {
+public:
+    int sum(vector<int>& nums,int num)
+    {
+        int ans = 0;
+        for(int i=0;i<nums.size();i++)
+            ans += nums[i]%num == 0 ? (nums[i]/num) : (nums[i]/num + 1);
+       // cout<<ans<<" "<<num<<endl;
+        return ans;
+    }
+    
+    int smallestDivisor(vector<int>& nums, int threshold) {
+        
+        int maxi = INT_MIN;
+        
+        for(auto a:nums){
+            if(a>maxi)
+                maxi = a;
+        }
+        
+        int low =1;
+        int high = maxi;
+        
+        while(low<high)
+        {
+            int mid = low + (high-low)/2;
+            if(sum(nums,mid) <= threshold)
+            {
+                high = mid;
+            }
+            else
+            {
+                low = mid+1;
+            }
+        }
+        return low;
+        
+    }
+};
\ No newline at end of file
diff --git a/1283-find-the-smallest-divisor-given-a-threshold/NOTES.md b/1283-find-the-smallest-divisor-given-a-threshold/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1283-find-the-smallest-divisor-given-a-threshold/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1283-find-the-smallest-divisor-given-a-threshold/README.md b/1283-find-the-smallest-divisor-given-a-threshold/README.md
new file mode 100644
index 0000000..826de9c
--- /dev/null
+++ b/1283-find-the-smallest-divisor-given-a-threshold/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/find-the-smallest-divisor-given-a-threshold/">1283. Find the Smallest Divisor Given a Threshold</a></h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>nums</code> and an integer <code>threshold</code>, we will choose a positive integer <code>divisor</code>, divide all the array by it, and sum the division's result. Find the <strong>smallest</strong> <code>divisor</code> such that the result mentioned above is less than or equal to <code>threshold</code>.</p>
+
+<p>Each result of the division is rounded to the nearest integer greater than or equal to that element. (For example: <code>7/3 = 3</code> and <code>10/2 = 5</code>).</p>
+
+<p>The test cases are generated so&nbsp;that there will be an answer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,5,9], threshold = 6
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> We can get a sum to 17 (1+2+5+9) if the divisor is 1. 
+If the divisor is 4 we can get a sum of 7 (1+1+2+3) and if the divisor is 5 the sum will be 5 (1+1+1+2). 
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [44,22,33,11,1], threshold = 5
+<strong>Output:</strong> 44
+</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>1 &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+	<li><code>nums.length &lt;= threshold &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1288-remove-covered-intervals/1288-remove-covered-intervals.cpp b/1288-remove-covered-intervals/1288-remove-covered-intervals.cpp
new file mode 100644
index 0000000..3cc152e
--- /dev/null
+++ b/1288-remove-covered-intervals/1288-remove-covered-intervals.cpp
@@ -0,0 +1,33 @@
+						// \U0001f609\U0001f609\U0001f609\U0001f609Please upvote if it helps \U0001f609\U0001f609\U0001f609\U0001f609
+class Solution {
+public:
+    int removeCoveredIntervals(vector<vector<int>>& intervals) {
+        
+        // sorting the intervals(vector)
+        sort(intervals.begin(),intervals.end());        
+           
+        int x1 = intervals[0][0];
+        int x2 = intervals[0][1];
+        
+		 int res = 1;  //one for x1 and x2;
+		
+		// ifa[i][0] && a[i][1] both greater than a[i-1][0] && a[i-1][1]
+		// increase the cnt.
+        for(int i= 1; i<intervals.size(); ++i)
+        {
+            if(intervals[i][0] > x1 && intervals[i][1] > x2)
+                ++res;
+            
+			// updating x1 & x2 with next intervals
+			//as we are comparing from upcoming ones.
+            if(intervals[i][1] > x2)
+            {
+                x1 = intervals[i][0];
+                x2 = intervals [i][1];
+            }
+        }
+        
+        return res;       // return cnt
+    }
+
+}; 
\ No newline at end of file
diff --git a/1288-remove-covered-intervals/NOTES.md b/1288-remove-covered-intervals/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1288-remove-covered-intervals/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1288-remove-covered-intervals/README.md b/1288-remove-covered-intervals/README.md
new file mode 100644
index 0000000..4f6dd99
--- /dev/null
+++ b/1288-remove-covered-intervals/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/remove-covered-intervals/">1288. Remove Covered Intervals</a></h2><h3>Medium</h3><hr><div><p>Given an array <code>intervals</code> where <code>intervals[i] = [l<sub>i</sub>, r<sub>i</sub>]</code> represent the interval <code>[l<sub>i</sub>, r<sub>i</sub>)</code>, remove all intervals that are covered by another interval in the list.</p>
+
+<p>The interval <code>[a, b)</code> is covered by the interval <code>[c, d)</code> if and only if <code>c &lt;= a</code> and <code>b &lt;= d</code>.</p>
+
+<p>Return <em>the number of remaining intervals</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> intervals = [[1,4],[3,6],[2,8]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Interval [3,6] is covered by [2,8], therefore it is removed.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> intervals = [[1,4],[2,3]]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= intervals.length &lt;= 1000</code></li>
+	<li><code>intervals[i].length == 2</code></li>
+	<li><code>0 &lt;= l<sub>i</sub> &lt;= r<sub>i</sub> &lt;= 10<sup>5</sup></code></li>
+	<li>All the given intervals are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1291-sequential-digits/1291-sequential-digits.cpp b/1291-sequential-digits/1291-sequential-digits.cpp
new file mode 100644
index 0000000..0ae06ac
--- /dev/null
+++ b/1291-sequential-digits/1291-sequential-digits.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    vector<int> sequentialDigits(int l, int h) {
+        queue<int> q;
+        for(int i = 1; i <= 9; i++) {
+            q.push(i);
+        }
+        vector<int> ret;
+        while(!q.empty()) {
+            int f = q.front();
+            q.pop();
+            if(f <= h && f >= l) {
+                ret.push_back(f);
+            }
+            if(f > h)
+                break;
+            int num = f % 10;
+            if(num < 9) {
+                q.push(f * 10 + (num + 1));
+            }
+        }
+        return ret;
+    }
+};
\ No newline at end of file
diff --git a/1291-sequential-digits/NOTES.md b/1291-sequential-digits/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1291-sequential-digits/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1291-sequential-digits/README.md b/1291-sequential-digits/README.md
new file mode 100644
index 0000000..c3dc79c
--- /dev/null
+++ b/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/13-Roman-to-Integer/13-roman-to-integer.cpp b/13-Roman-to-Integer/13-roman-to-integer.cpp
new file mode 100644
index 0000000..e982b04
--- /dev/null
+++ b/13-Roman-to-Integer/13-roman-to-integer.cpp
@@ -0,0 +1,28 @@
+class Solution {
+public:
+int romanToInt(string s) 
+{
+    unordered_map<char, int> T = { { 'I' , 1 },
+                                   { 'V' , 5 },
+                                   { 'X' , 10 },
+                                   { 'L' , 50 },
+                                   { 'C' , 100 },
+                                   { 'D' , 500 },
+                                   { 'M' , 1000 } };
+                                   
+   int sum = T[s.back()];
+   for (int i = s.length() - 2; i >= 0; --i) 
+   {
+       if (T[s[i]] < T[s[i + 1]])
+       {
+           sum -= T[s[i]];
+       }
+       else
+       {
+           sum += T[s[i]];
+       }
+   }
+   
+   return sum;
+}
+};
\ No newline at end of file
diff --git a/13-Roman-to-Integer/NOTES.md b/13-Roman-to-Integer/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/13-Roman-to-Integer/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1305-all-elements-in-two-binary-search-trees/1305-all-elements-in-two-binary-search-trees.cpp b/1305-all-elements-in-two-binary-search-trees/1305-all-elements-in-two-binary-search-trees.cpp
new file mode 100644
index 0000000..2d2ead2
--- /dev/null
+++ b/1305-all-elements-in-two-binary-search-trees/1305-all-elements-in-two-binary-search-trees.cpp
@@ -0,0 +1,60 @@
+/**
+ * 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:
+   void inOrderTraverse(TreeNode *root, vector<int>& vec)
+    {
+        if(root)
+	    {
+		    inOrderTraverse(root->left, vec);
+		    vec.push_back(root->val);
+		    inOrderTraverse(root->right, vec);
+
+	    }
+    }
+  void mergeVectors(vector<int> vec1, vector<int> vec2, vector<int>& mergedVectors)
+    {
+        int i = 0, j = 0, k = 0; 
+
+        // Traverse both array 
+        while (i < vec1.size() && j < vec2.size()) 
+        { 
+        
+            if (vec1[i] < vec2[j]) 
+                mergedVectors[k++] = vec1[i++]; 
+            else
+                mergedVectors[k++] = vec2[j++]; 
+        } 
+  
+    
+        while (i < vec1.size()) 
+            mergedVectors[k++] = vec1[i++]; 
+  
+    
+        while (j < vec2.size()) 
+            mergedVectors[k++] = vec2[j++]; 
+        
+        
+    } 
+  
+    vector<int> getAllElements(TreeNode* root1, TreeNode* root2) {
+      vector<int> v1;
+      vector<int> v2;
+       inOrderTraverse(root1, v1);
+        inOrderTraverse(root2, v2);
+        
+     vector<int> mergedVectors(v1.size() + v2.size());
+		
+        mergeVectors(v1, v2, mergedVectors);
+        return  mergedVectors;
+    }
+};
\ No newline at end of file
diff --git a/1305-all-elements-in-two-binary-search-trees/NOTES.md b/1305-all-elements-in-two-binary-search-trees/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1305-all-elements-in-two-binary-search-trees/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1305-all-elements-in-two-binary-search-trees/README.md b/1305-all-elements-in-two-binary-search-trees/README.md
new file mode 100644
index 0000000..b199713
--- /dev/null
+++ b/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/131-palindrome-partitioning/131-palindrome-partitioning.cpp b/131-palindrome-partitioning/131-palindrome-partitioning.cpp
new file mode 100644
index 0000000..31604cf
--- /dev/null
+++ b/131-palindrome-partitioning/131-palindrome-partitioning.cpp
@@ -0,0 +1,44 @@
+class Solution {
+public:
+    
+   bool isPalindrome(string s, int start, int end) {
+        while(start <= end) {
+            if(s[start++] != s[end--])
+                return false;
+        }
+        return true;
+    }
+    
+    void solve( vector<vector<string>> & ans,vector<string>& temp,int index,string s)
+    {
+        if(index == s.size())
+        {
+            ans.push_back(temp);
+            return;
+        }
+       
+        
+        for(int i=index;i<s.size();i++)
+        {
+              
+            // string g = s.substr(index,i-index);
+            // cout<<index<<" "<<i<<endl;
+            // cout<<"g -> "<<g<<endl;
+            if(isPalindrome(s,index,i))
+            {
+              
+                temp.push_back(s.substr(index, i - index + 1));
+                solve(ans,temp,i+1,s);
+              //  cout<<"RRR"<<endl;
+                temp.pop_back();
+            }
+        }
+    }
+    
+    vector<vector<string>> partition(string s) {
+        vector<vector<string>> ans;
+        vector<string> temp;
+        solve(ans,temp,0,s);
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/131-palindrome-partitioning/NOTES.md b/131-palindrome-partitioning/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/131-palindrome-partitioning/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/131-palindrome-partitioning/README.md b/131-palindrome-partitioning/README.md
new file mode 100644
index 0000000..0ab9fa3
--- /dev/null
+++ b/131-palindrome-partitioning/README.md
@@ -0,0 +1,20 @@
+<h2><a href="https://leetcode.com/problems/palindrome-partitioning/">131. Palindrome Partitioning</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code>, partition <code>s</code> such that every substring of the partition is a <strong>palindrome</strong>. Return all possible palindrome partitioning of <code>s</code>.</p>
+
+<p>A <strong>palindrome</strong> string is a string that reads the same backward as forward.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "aab"
+<strong>Output:</strong> [["a","a","b"],["aa","b"]]
+</pre><p><strong>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>
+</div>
\ No newline at end of file
diff --git a/133-clone-graph/NOTES.md b/133-clone-graph/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/133-clone-graph/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/133-clone-graph/README.md b/133-clone-graph/README.md
new file mode 100644
index 0000000..65ef7c6
--- /dev/null
+++ b/133-clone-graph/README.md
@@ -0,0 +1,59 @@
+<h2><a href="https://leetcode.com/problems/clone-graph/">133. Clone Graph</a></h2><h3>Medium</h3><hr><div><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's value is the same as the node'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>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)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+</pre>
+
+<p><strong>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>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>
+</div>
\ No newline at end of file
diff --git a/1337-the-k-weakest-rows-in-a-matrix/1337-the-k-weakest-rows-in-a-matrix.cpp b/1337-the-k-weakest-rows-in-a-matrix/1337-the-k-weakest-rows-in-a-matrix.cpp
new file mode 100644
index 0000000..7c0993f
--- /dev/null
+++ b/1337-the-k-weakest-rows-in-a-matrix/1337-the-k-weakest-rows-in-a-matrix.cpp
@@ -0,0 +1,38 @@
+class Solution {
+public:
+    vector<int> kWeakestRows(vector<vector<int>>& mat, int k) {
+        
+        int n = mat.size();
+        int col = mat[0].size();
+        map<int,vector<int>> m;
+        for(int i=0;i<n;i++)
+        {
+            int count  = 0;
+            for(int j=0;j<col;j++)
+            {
+                if(mat[i][j] == 1)
+                    count++;
+            }
+            m[count].push_back(i);
+        }
+        vector<int> ans;
+        for(auto it = m.begin();it != m.end(); it++)
+        {
+            if(k >= it->second.size())
+            {
+                for(int i=0;i<it->second.size();i++)
+                    ans.push_back(it->second[i]);
+            }
+            else
+            {
+                for(int i=0;i<k;i++)
+                {
+                    ans.push_back(it->second[i]);
+                }
+                break;
+            }
+            k = k - it->second.size();
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/1337-the-k-weakest-rows-in-a-matrix/NOTES.md b/1337-the-k-weakest-rows-in-a-matrix/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1337-the-k-weakest-rows-in-a-matrix/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1337-the-k-weakest-rows-in-a-matrix/README.md b/1337-the-k-weakest-rows-in-a-matrix/README.md
new file mode 100644
index 0000000..38d0c1e
--- /dev/null
+++ b/1337-the-k-weakest-rows-in-a-matrix/README.md
@@ -0,0 +1,61 @@
+<h2><a href="https://leetcode.com/problems/the-k-weakest-rows-in-a-matrix/">1337. The K Weakest Rows in a Matrix</a></h2><h3>Easy</h3><hr><div><p>You are given an <code>m x n</code> binary matrix <code>mat</code> of <code>1</code>'s (representing soldiers) and <code>0</code>'s (representing civilians). The soldiers are positioned <strong>in front</strong> of the civilians. That is, all the <code>1</code>'s will appear to the <strong>left</strong> of all the <code>0</code>'s in each row.</p>
+
+<p>A row <code>i</code> is <strong>weaker</strong> than a row <code>j</code> if one of the following is true:</p>
+
+<ul>
+	<li>The number of soldiers in row <code>i</code> is less than the number of soldiers in row <code>j</code>.</li>
+	<li>Both rows have the same number of soldiers and <code>i &lt; j</code>.</li>
+</ul>
+
+<p>Return <em>the indices of the </em><code>k</code><em> <strong>weakest</strong> rows in the matrix ordered from weakest to strongest</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> mat = 
+[[1,1,0,0,0],
+ [1,1,1,1,0],
+ [1,0,0,0,0],
+ [1,1,0,0,0],
+ [1,1,1,1,1]], 
+k = 3
+<strong>Output:</strong> [2,0,3]
+<strong>Explanation:</strong> 
+The number of soldiers in each row is: 
+- Row 0: 2 
+- Row 1: 4 
+- Row 2: 1 
+- Row 3: 2 
+- Row 4: 5 
+The rows ordered from weakest to strongest are [2,0,3,1,4].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> mat = 
+[[1,0,0,0],
+ [1,1,1,1],
+ [1,0,0,0],
+ [1,0,0,0]], 
+k = 2
+<strong>Output:</strong> [0,2]
+<strong>Explanation:</strong> 
+The number of soldiers in each row is: 
+- Row 0: 1 
+- Row 1: 4 
+- Row 2: 1 
+- Row 3: 1 
+The rows ordered from weakest to strongest are [0,2,3,1].
+</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>2 &lt;= n, m &lt;= 100</code></li>
+	<li><code>1 &lt;= k &lt;= m</code></li>
+	<li><code>matrix[i][j]</code> is either 0 or 1.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/134-gas-station/NOTES.md b/134-gas-station/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/134-gas-station/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/134-gas-station/README.md b/134-gas-station/README.md
new file mode 100644
index 0000000..0969b0a
--- /dev/null
+++ b/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/1359-count-all-valid-pickup-and-delivery-options/1359-count-all-valid-pickup-and-delivery-options.cpp b/1359-count-all-valid-pickup-and-delivery-options/1359-count-all-valid-pickup-and-delivery-options.cpp
new file mode 100644
index 0000000..a0e6047
--- /dev/null
+++ b/1359-count-all-valid-pickup-and-delivery-options/1359-count-all-valid-pickup-and-delivery-options.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int countOrders(int n) {
+        long res = 1, mod = 1000000007;
+        for(int i = 1; i <=n; ++i)
+        {
+            res *= i;
+            res %= mod;
+            res *= (2*i-1);
+            res %= mod;
+        }
+        return res % mod;
+    }
+};
\ No newline at end of file
diff --git a/1359-count-all-valid-pickup-and-delivery-options/README.md b/1359-count-all-valid-pickup-and-delivery-options/README.md
new file mode 100644
index 0000000..5124350
--- /dev/null
+++ b/1359-count-all-valid-pickup-and-delivery-options/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/count-all-valid-pickup-and-delivery-options/">1359. Count All Valid Pickup and Delivery Options</a></h2><h3>Hard</h3><hr><div><p>Given <code>n</code> orders, each order consist in pickup and delivery services.&nbsp;</p>
+
+<p>Count all valid pickup/delivery possible sequences such that delivery(i) is always after of&nbsp;pickup(i).&nbsp;</p>
+
+<p>Since the answer&nbsp;may be too large,&nbsp;return it modulo&nbsp;10^9 + 7.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> Unique order (P1, D1), Delivery 1 always is after of Pickup 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> All possible orders: 
+(P1,P2,D1,D2), (P1,P2,D2,D1), (P1,D1,P2,D2), (P2,P1,D1,D2), (P2,P1,D2,D1) and (P2,D2,P1,D1).
+This is an invalid order (P1,D2,P2,D1) because Pickup 2 is after of Delivery 2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 90
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 500</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/136-single-number/136-single-number.cpp b/136-single-number/136-single-number.cpp
new file mode 100644
index 0000000..865a287
--- /dev/null
+++ b/136-single-number/136-single-number.cpp
@@ -0,0 +1,9 @@
+class Solution {
+public:
+    int singleNumber(vector<int>& nums) {
+        int a = 0;
+        for(auto d:nums)
+            a^=d;
+        return a;
+    }
+};
\ No newline at end of file
diff --git a/136-single-number/README.md b/136-single-number/README.md
new file mode 100644
index 0000000..6ca2f18
--- /dev/null
+++ b/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/138-copy-list-with-random-pointer/138-copy-list-with-random-pointer.cpp b/138-copy-list-with-random-pointer/138-copy-list-with-random-pointer.cpp
new file mode 100644
index 0000000..a2c1b70
--- /dev/null
+++ b/138-copy-list-with-random-pointer/138-copy-list-with-random-pointer.cpp
@@ -0,0 +1,61 @@
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* next;
+    Node* random;
+    
+    Node(int _val) {
+        val = _val;
+        next = NULL;
+        random = NULL;
+    }
+};
+*/
+
+class Solution {
+public:
+    Node* copyRandomList(Node* head) {
+        
+        if(head == NULL)return NULL;
+        
+        Node * it = head;
+        Node * front = head;
+        
+        while(it != NULL)
+        {
+            front = it->next;
+            Node * newNode = new Node(it->val);
+            it->next = newNode;
+            newNode->next = front;
+            it = front;
+        }
+        
+        it = head;
+        front = NULL;
+        while(it != NULL)
+        {
+            if(it->random)
+            {
+                it->next->random = it->random->next;
+            }
+            it = it->next->next;
+        }
+        
+        Node * dummy = new Node(0);
+        Node * temp = dummy;
+        
+        it = head;
+        while(it != NULL)
+        {
+            front = it->next->next;
+            temp->next = it->next;
+            it->next = front;
+            it = front;
+            temp = temp->next;
+        }
+        
+        return dummy->next;
+    }
+};
\ No newline at end of file
diff --git a/138-copy-list-with-random-pointer/NOTES.md b/138-copy-list-with-random-pointer/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/138-copy-list-with-random-pointer/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/138-copy-list-with-random-pointer/README.md b/138-copy-list-with-random-pointer/README.md
new file mode 100644
index 0000000..b60daa2
--- /dev/null
+++ b/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/1381-design-a-stack-with-increment-operation/NOTES.md b/1381-design-a-stack-with-increment-operation/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1381-design-a-stack-with-increment-operation/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1381-design-a-stack-with-increment-operation/README.md b/1381-design-a-stack-with-increment-operation/README.md
new file mode 100644
index 0000000..5e2500e
--- /dev/null
+++ b/1381-design-a-stack-with-increment-operation/README.md
@@ -0,0 +1,46 @@
+<h2><a href="https://leetcode.com/problems/design-a-stack-with-increment-operation/">1381. Design a Stack With Increment Operation</a></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/139-word-break/README.md b/139-word-break/README.md
new file mode 100644
index 0000000..ccdcdbe
--- /dev/null
+++ b/139-word-break/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/word-break/">139. Word Break</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code> and a dictionary of strings <code>wordDict</code>, return <code>true</code> if <code>s</code> can be segmented into a space-separated sequence of one or more dictionary words.</p>
+
+<p><strong>Note</strong> that the same word in the dictionary may be reused multiple times in the segmentation.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "leetcode", wordDict = ["leet","code"]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Return true because "leetcode" can be segmented as "leet code".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "applepenapple", wordDict = ["apple","pen"]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Return true because "applepenapple" can be segmented as "apple pen apple".
+Note that you are allowed to reuse a dictionary word.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 300</code></li>
+	<li><code>1 &lt;= wordDict.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= wordDict[i].length &lt;= 20</code></li>
+	<li><code>s</code> and <code>wordDict[i]</code> consist of only lowercase English letters.</li>
+	<li>All the strings of <code>wordDict</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/141-linked-list-cycle/141-linked-list-cycle.cpp b/141-linked-list-cycle/141-linked-list-cycle.cpp
new file mode 100644
index 0000000..880570b
--- /dev/null
+++ b/141-linked-list-cycle/141-linked-list-cycle.cpp
@@ -0,0 +1,28 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasCycle(ListNode *head) {
+        if(head == NULL || head->next == NULL )
+            return false;
+        
+        ListNode * slow = head;
+        ListNode * fast = head;
+        
+        do{
+            slow = slow->next;
+            fast = fast->next->next;
+        }while(fast && fast->next && slow != fast);
+            
+        if(fast == NULL || fast->next == NULL)
+            return false;
+        
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/141-linked-list-cycle/NOTES.md b/141-linked-list-cycle/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/141-linked-list-cycle/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/141-linked-list-cycle/README.md b/141-linked-list-cycle/README.md
new file mode 100644
index 0000000..73491c5
--- /dev/null
+++ b/141-linked-list-cycle/README.md
@@ -0,0 +1,40 @@
+<h2><a href="https://leetcode.com/problems/linked-list-cycle/">141. Linked List Cycle</a></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/142-linked-list-cycle-ii/142-linked-list-cycle-ii.cpp b/142-linked-list-cycle-ii/142-linked-list-cycle-ii.cpp
new file mode 100644
index 0000000..b3b6d06
--- /dev/null
+++ b/142-linked-list-cycle-ii/142-linked-list-cycle-ii.cpp
@@ -0,0 +1,38 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *detectCycle(ListNode *head) {
+        if(head == NULL || head->next == NULL)
+            return NULL;
+        ListNode * slow = head;
+        ListNode * fast = head;
+        
+        do{
+            slow = slow->next;
+            fast = fast->next->next;
+        }while(slow != fast && fast && fast->next);
+          
+        if(slow == fast)
+        {
+            fast = head;
+
+            while(slow != fast)
+            {
+                slow = slow->next;
+                fast = fast->next;
+            }
+
+            return fast;
+        }
+        else
+            return NULL;
+    
+    }
+};
\ No newline at end of file
diff --git a/142-linked-list-cycle-ii/NOTES.md b/142-linked-list-cycle-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/142-linked-list-cycle-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/142-linked-list-cycle-ii/README.md b/142-linked-list-cycle-ii/README.md
new file mode 100644
index 0000000..25cb254
--- /dev/null
+++ b/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/1423-maximum-points-you-can-obtain-from-cards/1423-maximum-points-you-can-obtain-from-cards.cpp b/1423-maximum-points-you-can-obtain-from-cards/1423-maximum-points-you-can-obtain-from-cards.cpp
new file mode 100644
index 0000000..e90ce5d
--- /dev/null
+++ b/1423-maximum-points-you-can-obtain-from-cards/1423-maximum-points-you-can-obtain-from-cards.cpp
@@ -0,0 +1,46 @@
+class Solution {
+public:
+    
+//     int solve(vector<int>& nums, int k,int i,int j,vector<vector<int>>& dp)
+//     {
+//         if(i>=j)
+//             return dp[i][j] = 0;
+//         if(k == 0)
+//             return dp[i][j] = 0;
+//         if(dp[i][j] != -1)return dp[i][j];
+        
+//         int poss1  = nums[i] + solve(nums,k-1,i+1,j,dp);
+//         int poss2  = nums[j] + solve(nums,k-1,i,j-1,dp);
+        
+//         return dp[i][j] = max(poss1,poss2);
+//     }
+    
+    int maxScore(vector<int>& nums, int k) {
+        if(k == nums.size())
+        {   int ans = 0;
+            for(auto a:nums)ans+=a;
+            return ans;
+        }
+        // vector<vector<int>> dp(nums.size(),vector<int> (nums.size(),-1));
+        // int ans = solve(nums,k,0,nums.size()-1,dp);
+        // return ans;
+        
+        int rem = nums.size() - k;
+        int ans = 0;
+        for(int i=0;i<rem;i++)
+            ans += nums[i];
+     //   cout<<ans<<endl;
+        int curr = ans;
+        for(int i=rem;i<nums.size();i++)
+        {
+            curr = curr - nums[i-rem] + nums[i];
+            ans = min(ans,curr); 
+        }
+            
+        
+        int totsum  = 0;
+        for(auto a:nums)totsum+=a;
+       // cout<<totsum<<" "<<ans<<" "<<rem<<endl;
+        return totsum - ans;
+    }
+};
\ No newline at end of file
diff --git a/1423-maximum-points-you-can-obtain-from-cards/NOTES.md b/1423-maximum-points-you-can-obtain-from-cards/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1423-maximum-points-you-can-obtain-from-cards/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1423-maximum-points-you-can-obtain-from-cards/README.md b/1423-maximum-points-you-can-obtain-from-cards/README.md
new file mode 100644
index 0000000..d9b1efb
--- /dev/null
+++ b/1423-maximum-points-you-can-obtain-from-cards/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/maximum-points-you-can-obtain-from-cards/">1423. Maximum Points You Can Obtain from Cards</a></h2><h3>Medium</h3><hr><div><p>There are several cards <strong>arranged in a row</strong>, and each card has an associated number of points. The points are given in the integer array <code>cardPoints</code>.</p>
+
+<p>In one step, you can take one card from the beginning or from the end of the row. You have to take exactly <code>k</code> cards.</p>
+
+<p>Your score is the sum of the points of the cards you have taken.</p>
+
+<p>Given the integer array <code>cardPoints</code> and the integer <code>k</code>, return the <em>maximum score</em> you can obtain.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> cardPoints = [1,2,3,4,5,6,1], k = 3
+<strong>Output:</strong> 12
+<strong>Explanation:</strong> After the first step, your score will always be 1. However, choosing the rightmost card first will maximize your total score. The optimal strategy is to take the three cards on the right, giving a final score of 1 + 6 + 5 = 12.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> cardPoints = [2,2,2], k = 2
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Regardless of which two cards you take, your score will always be 4.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> cardPoints = [9,7,7,9,7,7,9], k = 7
+<strong>Output:</strong> 55
+<strong>Explanation:</strong> You have to take all the cards. Your score is the sum of points of all cards.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= cardPoints.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= cardPoints[i] &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= k &lt;= cardPoints.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/144-binary-tree-preorder-traversal/NOTES.md b/144-binary-tree-preorder-traversal/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/144-binary-tree-preorder-traversal/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/144-binary-tree-preorder-traversal/README.md b/144-binary-tree-preorder-traversal/README.md
new file mode 100644
index 0000000..5c5308e
--- /dev/null
+++ b/144-binary-tree-preorder-traversal/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/binary-tree-preorder-traversal/">144. Binary Tree Preorder Traversal</a></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: 125px; height: 200px;">
+<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>&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/146-lru-cache/146-lru-cache.cpp b/146-lru-cache/146-lru-cache.cpp
new file mode 100644
index 0000000..c58c40d
--- /dev/null
+++ b/146-lru-cache/146-lru-cache.cpp
@@ -0,0 +1,70 @@
+class LRUCache {
+  public:
+    class node {
+      public:
+        int key;
+      int val;
+      node * next;
+      node * prev;
+      node(int _key, int _val) {
+        key = _key;
+        val = _val;
+      }
+    };
+
+  node * head = new node(-1, -1);
+  node * tail = new node(-1, -1);
+
+  int cap;
+  unordered_map < int, node * > m;
+
+  LRUCache(int capacity) {
+    cap = capacity;
+    head -> next = tail;
+    tail -> prev = head;
+  }
+
+  void addnode(node * newnode) {
+    node * temp = head -> next;
+    newnode -> next = temp;
+    newnode -> prev = head;
+    head -> next = newnode;
+    temp -> prev = newnode;
+  }
+
+  void deletenode(node * delnode) {
+    node * delprev = delnode -> prev;
+    node * delnext = delnode -> next;
+    delprev -> next = delnext;
+    delnext -> prev = delprev;
+  }
+
+  int get(int key_) {
+    if (m.find(key_) != m.end()) {
+      node * resnode = m[key_];
+      int res = resnode -> val;
+      m.erase(key_);
+      deletenode(resnode);
+      addnode(resnode);
+      m[key_] = head -> next;
+      return res;
+    }
+
+    return -1;
+  }
+
+  void put(int key_, int value) {
+    if (m.find(key_) != m.end()) {
+      node * existingnode = m[key_];
+      m.erase(key_);
+      deletenode(existingnode);
+    }
+    if (m.size() == cap) {
+      m.erase(tail -> prev -> key);
+      deletenode(tail -> prev);
+    }
+
+    addnode(new node(key_, value));
+    m[key_] = head -> next;
+  }
+};
\ No newline at end of file
diff --git a/146-lru-cache/NOTES.md b/146-lru-cache/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/146-lru-cache/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/146-lru-cache/README.md b/146-lru-cache/README.md
new file mode 100644
index 0000000..dbe2bbe
--- /dev/null
+++ b/146-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>&nbsp;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&nbsp;<code data-stringify-type="code">get</code>&nbsp;and&nbsp;<code data-stringify-type="code">put</code>&nbsp;must each run in <code>O(1)</code> average time complexity.</p>
+
+<p>&nbsp;</p>
+<p><strong>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 2<code>&nbsp;* 10<sup>5</sup></code>&nbsp;calls will be made to <code>get</code> and <code>put</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.cpp b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.cpp
new file mode 100644
index 0000000..62edb7b
--- /dev/null
+++ b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    long long int maxArea(int h, int w, vector<int>& a, vector<int>& b) {
+        sort(a.begin(),a.end());
+        sort(b.begin(),b.end());
+        a.insert(a.begin(),0);
+        a.push_back(h);
+        b.insert(b.begin(),0);
+        b.push_back(w);
+        
+        long long int p = a[1]-a[0];
+        for(int i=1;i<a.size()-1;i++)
+            p = max((int)p,a[i+1]-a[i]);
+        
+        long long int q = b[1]-b[0];
+        for(int i=1;i<b.size()-1;i++)
+            q = max((int)q,b[i+1]-b[i]);
+        
+        return (long long int)p * ( long long int)q % 1000000007;;
+    }
+};
\ No newline at end of file
diff --git a/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/NOTES.md b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/README.md b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/README.md
new file mode 100644
index 0000000..9fb1d14
--- /dev/null
+++ b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/">1465. Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts</a></h2><h3>Medium</h3><hr><div><p>You are given a rectangular cake of size <code>h x w</code> and two arrays of integers <code>horizontalCuts</code> and <code>verticalCuts</code> where:</p>
+
+<ul>
+	<li><code>horizontalCuts[i]</code> is the distance from the top of the rectangular cake to the <code>i<sup>th</sup></code> horizontal cut and similarly, and</li>
+	<li><code>verticalCuts[j]</code> is the distance from the left of the rectangular cake to the <code>j<sup>th</sup></code> vertical cut.</li>
+</ul>
+
+<p>Return <em>the maximum area of a piece of cake after you cut at each horizontal and vertical position provided in the arrays</em> <code>horizontalCuts</code> <em>and</em> <code>verticalCuts</code>. Since the answer can be a large number, return this <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/05/14/leetcode_max_area_2.png" style="width: 225px; height: 240px;">
+<pre><strong>Input:</strong> h = 5, w = 4, horizontalCuts = [1,2,4], verticalCuts = [1,3]
+<strong>Output:</strong> 4 
+<strong>Explanation:</strong> The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green piece of cake has the maximum area.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/05/14/leetcode_max_area_3.png" style="width: 225px; height: 240px;">
+<pre><strong>Input:</strong> h = 5, w = 4, horizontalCuts = [3,1], verticalCuts = [1]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green and yellow pieces of cake have the maximum area.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> h = 5, w = 4, horizontalCuts = [3], verticalCuts = [3]
+<strong>Output:</strong> 9
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= h, w &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= horizontalCuts.length &lt;= min(h - 1, 10<sup>5</sup>)</code></li>
+	<li><code>1 &lt;= verticalCuts.length &lt;= min(w - 1, 10<sup>5</sup>)</code></li>
+	<li><code>1 &lt;= horizontalCuts[i] &lt; h</code></li>
+	<li><code>1 &lt;= verticalCuts[i] &lt; w</code></li>
+	<li>All the elements in <code>horizontalCuts</code> are distinct.</li>
+	<li>All the elements in <code>verticalCuts</code> are distinct.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1472-design-browser-history/1472-design-browser-history.cpp b/1472-design-browser-history/1472-design-browser-history.cpp
new file mode 100644
index 0000000..c562100
--- /dev/null
+++ b/1472-design-browser-history/1472-design-browser-history.cpp
@@ -0,0 +1,27 @@
+class BrowserHistory {
+public:
+    vector<string> history;
+int pos =0;
+BrowserHistory(string homepage) { history.push_back(homepage); }
+void visit(string url) {
+    ++pos;
+    history.resize(pos);
+    history.push_back(url);
+}
+string back(int steps) {
+    pos = max(0, pos - steps);
+    return history[pos];
+}
+string forward(int steps) {
+    pos = min((int)history.size() -1, pos + steps);
+    return history[pos];
+}
+};
+
+/**
+ * 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/1472-design-browser-history/NOTES.md b/1472-design-browser-history/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1472-design-browser-history/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1472-design-browser-history/README.md b/1472-design-browser-history/README.md
new file mode 100644
index 0000000..de385f5
--- /dev/null
+++ b/1472-design-browser-history/README.md
@@ -0,0 +1,45 @@
+<h2><a href="https://leetcode.com/problems/design-browser-history/">1472. Design Browser History</a></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/148-sort-list/148-sort-list.cpp b/148-sort-list/148-sort-list.cpp
new file mode 100644
index 0000000..8eb36f5
--- /dev/null
+++ b/148-sort-list/148-sort-list.cpp
@@ -0,0 +1,50 @@
+class Solution {
+public:
+    ListNode* sortList(ListNode* head) {
+        if (head == NULL || head->next == NULL)
+            return head;
+        
+        ListNode* slow = head;
+        ListNode* fast = head->next;
+        
+        while (fast != NULL && fast->next != NULL)
+        {
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+        //divide the list into two parts 
+        fast = slow->next;
+        slow->next = NULL;
+        
+        return merge(sortList(head), sortList(fast));
+    }
+    
+    ListNode* merge(ListNode* l1, ListNode* l2)
+    {
+        ListNode dump(0);
+        ListNode* cur = &dump;
+        
+        while (l1 != NULL && l2 != NULL)
+        {
+            if (l1->val < l2->val)
+            {
+                cur->next = l1;
+                l1 = l1->next;
+            }
+            else
+            {
+                cur->next = l2;
+                l2 = l2->next;
+            }
+                
+            cur = cur->next;
+        }
+        
+        if (l1 != NULL)
+            cur->next = l1;
+        else
+            cur->next = l2;
+            
+        return dump.next;
+    }
+};
\ No newline at end of file
diff --git a/148-sort-list/NOTES.md b/148-sort-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/148-sort-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/148-sort-list/README.md b/148-sort-list/README.md
new file mode 100644
index 0000000..1446549
--- /dev/null
+++ b/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/1510-stone-game-iv/1510-stone-game-iv.cpp b/1510-stone-game-iv/1510-stone-game-iv.cpp
new file mode 100644
index 0000000..be84b4c
--- /dev/null
+++ b/1510-stone-game-iv/1510-stone-game-iv.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+     bool winnerSquareGame(int n) {
+        vector<bool> dp(n + 1, false);
+        for (int i = 1; i <= n; ++i) {
+            for (int k = 1; k * k <= i; ++k) {
+                if (!dp[i - k * k]) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+        return dp[n];
+    }
+};
\ No newline at end of file
diff --git a/1510-stone-game-iv/NOTES.md b/1510-stone-game-iv/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1510-stone-game-iv/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1510-stone-game-iv/README.md b/1510-stone-game-iv/README.md
new file mode 100644
index 0000000..63f9fb5
--- /dev/null
+++ b/1510-stone-game-iv/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/stone-game-iv/">1510. Stone Game IV</a></h2><h3>Hard</h3><hr><div><p>Alice and Bob take turns playing a game, with Alice starting first.</p>
+
+<p>Initially, there are <code>n</code> stones in a pile. On each player's turn, that player makes a <em>move</em> consisting of removing <strong>any</strong> non-zero <strong>square number</strong> of stones in the pile.</p>
+
+<p>Also, if a player cannot make a move, he/she loses the game.</p>
+
+<p>Given a positive integer <code>n</code>, return <code>true</code> if and only if Alice wins the game otherwise return <code>false</code>, assuming both players play optimally.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> true
+<strong>Explanation: </strong>Alice can remove 1 stone winning the game because Bob doesn't have any moves.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> false
+<strong>Explanation: </strong>Alice can only remove 1 stone, after that Bob removes the last one winning the game (2 -&gt; 1 -&gt; 0).
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> true
+<strong>Explanation:</strong> n is already a perfect square, Alice can win with one move, removing 4 stones (4 -&gt; 0).
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/153-find-minimum-in-rotated-sorted-array/153-find-minimum-in-rotated-sorted-array.cpp b/153-find-minimum-in-rotated-sorted-array/153-find-minimum-in-rotated-sorted-array.cpp
new file mode 100644
index 0000000..c115bdb
--- /dev/null
+++ b/153-find-minimum-in-rotated-sorted-array/153-find-minimum-in-rotated-sorted-array.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int findMin(vector<int>& nums) {
+        int s = 0;
+        int e = nums.size() - 1;
+
+    while (s < e)
+    {
+        int mid = (s + e) / 2;
+
+        if (nums[mid] < nums[e])
+        {
+            e = mid;
+        }
+        else
+        {
+            s = mid + 1;
+        }
+    }
+    return nums[s];
+    }
+};
\ No newline at end of file
diff --git a/153-find-minimum-in-rotated-sorted-array/NOTES.md b/153-find-minimum-in-rotated-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/153-find-minimum-in-rotated-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/153-find-minimum-in-rotated-sorted-array/README.md b/153-find-minimum-in-rotated-sorted-array/README.md
new file mode 100644
index 0000000..946447e
--- /dev/null
+++ b/153-find-minimum-in-rotated-sorted-array/README.md
@@ -0,0 +1,46 @@
+<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><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/154-find-minimum-in-rotated-sorted-array-ii/154-find-minimum-in-rotated-sorted-array-ii.cpp b/154-find-minimum-in-rotated-sorted-array-ii/154-find-minimum-in-rotated-sorted-array-ii.cpp
new file mode 100644
index 0000000..7e50e74
--- /dev/null
+++ b/154-find-minimum-in-rotated-sorted-array-ii/154-find-minimum-in-rotated-sorted-array-ii.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int findMin(vector<int>& nums) {
+         int s = 0;
+    int e = nums.size() - 1;
+
+    while (s < e)
+    {
+        int mid = (s + e) / 2;
+
+        if (nums[mid] < nums[e])
+        {
+            e = mid;
+        }
+        else if(nums[mid] > nums[e])
+        {
+            s = mid + 1;
+        }
+        else
+        {
+            e--;
+        }
+    }
+    return nums[s];
+    }
+};
\ No newline at end of file
diff --git a/154-find-minimum-in-rotated-sorted-array-ii/NOTES.md b/154-find-minimum-in-rotated-sorted-array-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/154-find-minimum-in-rotated-sorted-array-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/154-find-minimum-in-rotated-sorted-array-ii/README.md b/154-find-minimum-in-rotated-sorted-array-ii/README.md
new file mode 100644
index 0000000..17832ad
--- /dev/null
+++ b/154-find-minimum-in-rotated-sorted-array-ii/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/">154. Find Minimum in Rotated Sorted Array II</a></h2><h3>Hard</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,4,4,5,6,7]</code> might become:</p>
+
+<ul>
+	<li><code>[4,5,6,7,0,1,4]</code> if it was rotated <code>4</code> times.</li>
+	<li><code>[0,1,4,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> that may contain <strong>duplicates</strong>, return <em>the minimum element of this array</em>.</p>
+
+<p>You must decrease the overall operation steps as much as possible.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,3,5]
+<strong>Output:</strong> 1
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,2,0,1]
+<strong>Output:</strong> 0
+</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><code>nums</code> is sorted and rotated between <code>1</code> and <code>n</code> times.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> This problem is similar to&nbsp;<a href="https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/" target="_blank">Find Minimum in Rotated Sorted Array</a>, but&nbsp;<code>nums</code> may contain <strong>duplicates</strong>. Would this affect the runtime complexity? How and why?</p>
+
+<p>&nbsp;</p>
+</div>
\ No newline at end of file
diff --git a/155-min-stack/155-min-stack.cpp b/155-min-stack/155-min-stack.cpp
new file mode 100644
index 0000000..84a4248
--- /dev/null
+++ b/155-min-stack/155-min-stack.cpp
@@ -0,0 +1,82 @@
+class MinStack {
+public:
+    stack<long long int>s;
+    
+        long long int min = 0;
+    
+    void push(int val) {
+        
+        if(s.size()==0)
+        {
+            s.push(val);
+            
+            min = val;
+        }
+        
+        else if(val>=min)
+        {
+            s.push(val);
+        }
+        
+        else
+        {
+            long long int p = 2*(long long)val-min;
+            
+            s.push(p);
+            
+            min = val;
+        }
+    }
+    
+    void pop() {
+        if(s.size()==0) return;
+        
+        else
+        {
+            if(s.top()>=min)
+            {
+                s.pop();
+            }
+            
+            else
+            {
+                int ov = min;
+                
+                min = 2*min-s.top();
+                
+                s.pop();
+            }
+        }
+    }
+    
+    int top() {
+        if(s.size()==0) return -1;
+        
+        else
+        {
+            if(s.top()>=min)
+            {
+                return s.top();
+            }
+            
+            else
+            {
+                return min;
+            }
+        }
+    }
+    
+    int getMin() {
+        return 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/155-min-stack/NOTES.md b/155-min-stack/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/155-min-stack/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/155-min-stack/README.md b/155-min-stack/README.md
new file mode 100644
index 0000000..ca1a124
--- /dev/null
+++ b/155-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><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>You must implement a solution with <code>O(1)</code> time complexity for each function.</p>
+
+<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/1552-magnetic-force-between-two-balls/1552-magnetic-force-between-two-balls.cpp b/1552-magnetic-force-between-two-balls/1552-magnetic-force-between-two-balls.cpp
new file mode 100644
index 0000000..8887412
--- /dev/null
+++ b/1552-magnetic-force-between-two-balls/1552-magnetic-force-between-two-balls.cpp
@@ -0,0 +1,52 @@
+class Solution {
+    bool isPossible(vector<int>& nums, int mid,int m)
+    {
+        int count = 1;
+        int sum = 0;
+        
+        for(int i=0;i<nums.size()-1;i++)
+        {
+            if( sum  + (nums[i+1] - nums[i]) >= mid )
+            {
+                count++;
+                sum = 0;
+                if(count >= m)
+                    return true;
+            }
+            else
+                sum += (nums[i+1] - nums[i]);
+        }
+       // cout<<count<<"  "<<sum<<" "<<mid<<endl;
+        
+        return false;
+    }
+public:
+    int maxDistance(vector<int>& nums, int m) {
+        
+        sort(nums.begin(),nums.end());
+        int low = nums[1] - nums[0] ;
+        int high = low;
+        
+        for(int i=1;i<nums.size()-1;i++)
+        {
+            low = min(low,nums[i+1]-nums[i]);
+            high += ( nums[i+1]-nums[i] );
+        }
+        
+        int ans = -1;
+       // cout<<low<<" "<<high<<endl;
+        while(low<=high)
+        {
+            int mid = low + (high-low)/2;
+            
+            if(isPossible(nums,mid,m) == true)
+            {
+                ans = mid;
+                low = mid+1;
+            }
+            else
+                high = mid-1;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/1552-magnetic-force-between-two-balls/NOTES.md b/1552-magnetic-force-between-two-balls/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1552-magnetic-force-between-two-balls/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1552-magnetic-force-between-two-balls/README.md b/1552-magnetic-force-between-two-balls/README.md
new file mode 100644
index 0000000..6981962
--- /dev/null
+++ b/1552-magnetic-force-between-two-balls/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/magnetic-force-between-two-balls/">1552. Magnetic Force Between Two Balls</a></h2><h3>Medium</h3><hr><div><p>In the universe Earth C-137, Rick discovered a special form of magnetic force between two balls if they are put in his new invented basket. Rick has <code>n</code> empty baskets, the <code>i<sup>th</sup></code> basket is at <code>position[i]</code>, Morty has <code>m</code> balls and needs to distribute the balls into the baskets such that the <strong>minimum magnetic force</strong> between any two balls is <strong>maximum</strong>.</p>
+
+<p>Rick stated that magnetic force between two different balls at positions <code>x</code> and <code>y</code> is <code>|x - y|</code>.</p>
+
+<p>Given the integer array <code>position</code> and the integer <code>m</code>. Return <em>the required force</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/11/q3v1.jpg" style="width: 562px; height: 195px;">
+<pre><strong>Input:</strong> position = [1,2,3,4,7], m = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Distributing the 3 balls into baskets 1, 4 and 7 will make the magnetic force between ball pairs [3, 3, 6]. The minimum magnetic force is 3. We cannot achieve a larger minimum magnetic force than 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> position = [5,4,3,2,1,1000000000], m = 2
+<strong>Output:</strong> 999999999
+<strong>Explanation:</strong> We can use baskets 1 and 1000000000.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == position.length</code></li>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= position[i] &lt;= 10<sup>9</sup></code></li>
+	<li>All integers in <code>position</code> are <strong>distinct</strong>.</li>
+	<li><code>2 &lt;= m &lt;= position.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/16-3sum-closest/16-3sum-closest.cpp b/16-3sum-closest/16-3sum-closest.cpp
new file mode 100644
index 0000000..5c0c5ca
--- /dev/null
+++ b/16-3sum-closest/16-3sum-closest.cpp
@@ -0,0 +1,34 @@
+class Solution {
+public:
+    int threeSumClosest(vector<int>& nums, int target) {
+        
+        int closest = nums[0]+nums[1]+nums[2];
+        sort(nums.begin(),nums.end());
+        for(int i=0;i<nums.size()-2;i++)
+        {
+            if(i == 0 || nums[i] != nums[i-1])
+            {
+                int j = i+1;
+                int k = nums.size()-1;
+                
+                while(j<k)
+                {
+                    int sum = nums[i]+nums[j]+nums[k];
+                    if(sum == target)return sum;
+                    if(abs(target - sum) < abs(target-closest))
+                    {
+                        closest = sum;
+                    }
+                    else if(target > sum )
+                    {
+                        j++;
+                    }
+                    else
+                        k--;
+                }
+            }
+        }
+        return closest;
+        
+    }
+};
\ No newline at end of file
diff --git a/16-3sum-closest/NOTES.md b/16-3sum-closest/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/16-3sum-closest/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/160-intersection-of-two-linked-lists/160-intersection-of-two-linked-lists.cpp b/160-intersection-of-two-linked-lists/160-intersection-of-two-linked-lists.cpp
new file mode 100644
index 0000000..2a2f03c
--- /dev/null
+++ b/160-intersection-of-two-linked-lists/160-intersection-of-two-linked-lists.cpp
@@ -0,0 +1,24 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
+        
+        if(headA == NULL || headB == NULL)return NULL;
+        ListNode * a = headA;
+        ListNode * b = headB;
+        while(headA != headB)
+        {
+            headA = headA == NULL ? b : headA->next;
+            headB = headB == NULL ? a : headB->next;
+        }
+        return headA;
+        
+    }
+};
\ No newline at end of file
diff --git a/160-intersection-of-two-linked-lists/README.md b/160-intersection-of-two-linked-lists/README.md
new file mode 100644
index 0000000..085d444
--- /dev/null
+++ b/160-intersection-of-two-linked-lists/README.md
@@ -0,0 +1,63 @@
+<h2><a href="https://leetcode.com/problems/intersection-of-two-linked-lists/">160. Intersection of Two Linked Lists</a></h2><h3>Easy</h3><hr><div><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>&nbsp;to your program. If you correctly return the intersected node, then your solution will be <strong>accepted</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>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 '8'
+<strong>Explanation:</strong> The intersected node'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.
+</pre>
+
+<p><strong>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 '2'
+<strong>Explanation:</strong> The intersected node'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>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;&nbsp;m</code></li>
+	<li><code>0 &lt;= skipB &lt;&nbsp;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?</div>
\ No newline at end of file
diff --git a/162-find-peak-element/162-find-peak-element.cpp b/162-find-peak-element/162-find-peak-element.cpp
new file mode 100644
index 0000000..73769fd
--- /dev/null
+++ b/162-find-peak-element/162-find-peak-element.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int findPeakElement(vector<int>& nums) {
+        
+        
+        int low = 0;
+        int high = nums.size()-1;
+        
+        while(low<high)
+        {
+            int mid = low + (high-low)/2;
+            
+            if(nums[mid] < nums[mid+1])
+                low = mid+1;
+            else
+                high = mid;
+        }
+        return low;
+    }
+};
\ No newline at end of file
diff --git a/162-find-peak-element/NOTES.md b/162-find-peak-element/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/162-find-peak-element/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/162-find-peak-element/README.md b/162-find-peak-element/README.md
new file mode 100644
index 0000000..96d085a
--- /dev/null
+++ b/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/165-compare-version-numbers/README.md b/165-compare-version-numbers/README.md
new file mode 100644
index 0000000..8b228e8
--- /dev/null
+++ b/165-compare-version-numbers/README.md
@@ -0,0 +1,49 @@
+<h2><a href="https://leetcode.com/problems/compare-version-numbers/">165. Compare Version Numbers</a></h2><h3>Medium</h3><hr><div><p>Given two version numbers,&nbsp;<code>version1</code> and <code>version2</code>, compare them.</p>
+
+<ul>
+</ul>
+
+<p>Version numbers consist of <strong>one or more revisions</strong> joined by a dot&nbsp;<code>'.'</code>. Each revision&nbsp;consists of <strong>digits</strong>&nbsp;and may contain leading <strong>zeros</strong>. Every revision contains <strong>at least one character</strong>. Revisions are <strong>0-indexed from left to right</strong>, with the leftmost revision being revision 0, the next revision being revision 1, and so on. For example&nbsp;<code>2.5.33</code>&nbsp;and&nbsp;<code>0.1</code>&nbsp;are valid version numbers.</p>
+
+<p>To compare version numbers, compare their revisions in <strong>left-to-right order</strong>. Revisions are compared using their&nbsp;<strong>integer value ignoring any leading zeros</strong>. This means that revisions&nbsp;<code>1</code>&nbsp;and&nbsp;<code>001</code>&nbsp;are considered&nbsp;<strong>equal</strong>. If a version number does not specify a revision at an index, then&nbsp;<strong>treat the revision as&nbsp;<code>0</code></strong>. For example, version&nbsp;<code>1.0</code> is less than version&nbsp;<code>1.1</code>&nbsp;because their revision 0s are the same, but their revision 1s are&nbsp;<code>0</code>&nbsp;and&nbsp;<code>1</code>&nbsp;respectively, and&nbsp;<code>0 &lt; 1</code>.</p>
+
+<p><em>Return the following:</em></p>
+
+<ul>
+	<li>If <code>version1 &lt; version2</code>, return <code>-1</code>.</li>
+	<li>If <code>version1 &gt; version2</code>, return <code>1</code>.</li>
+	<li>Otherwise, return <code>0</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> version1 = "1.01", version2 = "1.001"
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> Ignoring leading zeroes, both "01" and "001" represent the same integer "1".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> version1 = "1.0", version2 = "1.0.0"
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> version1 does not specify revision 2, which means it is treated as "0".
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> version1 = "0.1", version2 = "1.1"
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> version1's revision 0 is "0", while version2's revision 0 is "1". 0 &lt; 1, so version1 &lt; version2.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= version1.length, version2.length &lt;= 500</code></li>
+	<li><code>version1</code> and <code>version2</code>&nbsp;only contain digits and <code>'.'</code>.</li>
+	<li><code>version1</code> and <code>version2</code>&nbsp;<strong>are valid version numbers</strong>.</li>
+	<li>All the given revisions in&nbsp;<code>version1</code> and <code>version2</code>&nbsp;can be stored in&nbsp;a&nbsp;<strong>32-bit integer</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1672-richest-customer-wealth/1672-richest-customer-wealth.cpp b/1672-richest-customer-wealth/1672-richest-customer-wealth.cpp
new file mode 100644
index 0000000..84a707a
--- /dev/null
+++ b/1672-richest-customer-wealth/1672-richest-customer-wealth.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int maximumWealth(vector<vector<int>>& accounts) {
+        int ans = 0;
+        for(int i=0;i<accounts.size();i++)
+        {
+            int count = 0;
+            for(int j=0;j<accounts[i].size();j++)
+                count+=accounts[i][j];
+            if(count>ans)
+                ans = count;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/1672-richest-customer-wealth/NOTES.md b/1672-richest-customer-wealth/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1672-richest-customer-wealth/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1672-richest-customer-wealth/README.md b/1672-richest-customer-wealth/README.md
new file mode 100644
index 0000000..e75b70d
--- /dev/null
+++ b/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/1675-minimize-deviation-in-array/NOTES.md b/1675-minimize-deviation-in-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1675-minimize-deviation-in-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1675-minimize-deviation-in-array/README.md b/1675-minimize-deviation-in-array/README.md
new file mode 100644
index 0000000..9728ab1
--- /dev/null
+++ b/1675-minimize-deviation-in-array/README.md
@@ -0,0 +1,52 @@
+<h2><a href="https://leetcode.com/problems/minimize-deviation-in-array/">1675. Minimize Deviation in Array</a></h2><h3>Hard</h3><hr><div><p>You are given an array <code>nums</code> of <code>n</code> positive integers.</p>
+
+<p>You can perform two types of operations on any element of the array any number of times:</p>
+
+<ul>
+	<li>If the element is <strong>even</strong>, <strong>divide</strong> it by <code>2</code>.
+
+	<ul>
+		<li>For example, if the array is <code>[1,2,3,4]</code>, then you can do this operation on the last element, and the array will be <code>[1,2,3,<u>2</u>].</code></li>
+	</ul>
+	</li>
+	<li>If the element is <strong>odd</strong>, <strong>multiply</strong> it by <code>2</code>.
+	<ul>
+		<li>For example, if the array is <code>[1,2,3,4]</code>, then you can do this operation on the first element, and the array will be <code>[<u>2</u>,2,3,4].</code></li>
+	</ul>
+	</li>
+</ul>
+
+<p>The <strong>deviation</strong> of the array is the <strong>maximum difference</strong> between any two elements in the array.</p>
+
+<p>Return <em>the <strong>minimum deviation</strong> the array can have after performing some number of operations.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> You can transform the array to [1,2,3,<u>2</u>], then to [<u>2</u>,2,3,2], then the deviation will be 3 - 2 = 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [4,1,5,20,3]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> You can transform the array after two operations to [4,<u>2</u>,5,<u>5</u>,3], then the deviation will be 5 - 2 = 3.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,10,8]
+<strong>Output:</strong> 3
+</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><span style="font-size: 10.8333px;">5</span></sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/169-majority-element/169-majority-element.cpp b/169-majority-element/169-majority-element.cpp
new file mode 100644
index 0000000..383b252
--- /dev/null
+++ b/169-majority-element/169-majority-element.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int majorityElement(vector<int>& nums) {
+        
+        int count = 1;
+        int major = nums[0];
+            
+        for(int i=1;i<nums.size();i++)
+        {
+            
+            if(nums[i] == major)
+                count++;
+            else if(count == 0)
+                 major = nums[i];
+            else if(nums[i] != major)
+               count--;
+            
+        }
+        return major;
+    }
+};
\ No newline at end of file
diff --git a/169-majority-element/NOTES.md b/169-majority-element/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/169-majority-element/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/169-majority-element/README.md b/169-majority-element/README.md
new file mode 100644
index 0000000..d1393d2
--- /dev/null
+++ b/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/171-excel-sheet-column-number/171-excel-sheet-column-number.cpp b/171-excel-sheet-column-number/171-excel-sheet-column-number.cpp
new file mode 100644
index 0000000..cc0818f
--- /dev/null
+++ b/171-excel-sheet-column-number/171-excel-sheet-column-number.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int titleToNumber(string s) {
+        long ans = 0;
+        long poww = 1;
+        while(s.size())
+        {
+            char last = s[s.size()-1];
+            ans += (poww*(last - 'A' + 1));
+            poww *= 26;
+            s.pop_back();
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/171-excel-sheet-column-number/NOTES.md b/171-excel-sheet-column-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/171-excel-sheet-column-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/171-excel-sheet-column-number/README.md b/171-excel-sheet-column-number/README.md
new file mode 100644
index 0000000..d46ff97
--- /dev/null
+++ b/171-excel-sheet-column-number/README.md
@@ -0,0 +1,42 @@
+<h2><a href="https://leetcode.com/problems/excel-sheet-column-number/">171. Excel Sheet Column Number</a></h2><h3>Easy</h3><hr><div><p>Given a string <code>columnTitle</code> that represents the column title as appear in an Excel sheet, return <em>its corresponding column number</em>.</p>
+
+<p>For example:</p>
+
+<pre>A -&gt; 1
+B -&gt; 2
+C -&gt; 3
+...
+Z -&gt; 26
+AA -&gt; 27
+AB -&gt; 28 
+...
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> columnTitle = "A"
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> columnTitle = "AB"
+<strong>Output:</strong> 28
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> columnTitle = "ZY"
+<strong>Output:</strong> 701
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= columnTitle.length &lt;= 7</code></li>
+	<li><code>columnTitle</code> consists only of uppercase English letters.</li>
+	<li><code>columnTitle</code> is in the range <code>["A", "FXSHRXW"]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1760-minimum-limit-of-balls-in-a-bag/1760-minimum-limit-of-balls-in-a-bag.cpp b/1760-minimum-limit-of-balls-in-a-bag/1760-minimum-limit-of-balls-in-a-bag.cpp
new file mode 100644
index 0000000..059618a
--- /dev/null
+++ b/1760-minimum-limit-of-balls-in-a-bag/1760-minimum-limit-of-balls-in-a-bag.cpp
@@ -0,0 +1,38 @@
+class Solution {
+public:
+    
+    bool isPossible(int mid,vector<int>& nums, int maxOperations)
+    {
+        int count = 0;
+        
+        for(int i=0;i<nums.size();i++)
+        {
+            count += ((nums[i] - 1 )/mid);
+        }
+        
+        if(maxOperations >= count)
+            return true;
+        return false;
+    }
+    int minimumSize(vector<int>& nums, int maxOperations) {
+        
+        int low  = 1;
+        int high = 1e9;
+        int ans = 0;
+        while(low<=high)
+        {
+            int mid = (low+high)>>1;
+            
+            if(isPossible(mid,nums,maxOperations))
+            {
+                ans = mid;
+                high = mid - 1;
+            }
+            else
+            {
+                low = mid + 1;
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/1760-minimum-limit-of-balls-in-a-bag/NOTES.md b/1760-minimum-limit-of-balls-in-a-bag/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1760-minimum-limit-of-balls-in-a-bag/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1760-minimum-limit-of-balls-in-a-bag/README.md b/1760-minimum-limit-of-balls-in-a-bag/README.md
new file mode 100644
index 0000000..d102e9e
--- /dev/null
+++ b/1760-minimum-limit-of-balls-in-a-bag/README.md
@@ -0,0 +1,54 @@
+<h2><a href="https://leetcode.com/problems/minimum-limit-of-balls-in-a-bag/">1760. Minimum Limit of Balls in a Bag</a></h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>nums</code> where the <code>i<sup>th</sup></code> bag contains <code>nums[i]</code> balls. You are also given an integer <code>maxOperations</code>.</p>
+
+<p>You can perform the following operation at most <code>maxOperations</code> times:</p>
+
+<ul>
+	<li>Take any bag of balls and divide it into two new bags with a <strong>positive </strong>number of balls.
+
+	<ul>
+		<li>For example, a bag of <code>5</code> balls can become two new bags of <code>1</code> and <code>4</code> balls, or two new bags of <code>2</code> and <code>3</code> balls.</li>
+	</ul>
+	</li>
+</ul>
+
+<p>Your penalty is the <strong>maximum</strong> number of balls in a bag. You want to <strong>minimize</strong> your penalty after the operations.</p>
+
+<p>Return <em>the minimum possible penalty&nbsp;after performing the operations</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [9], maxOperations = 2
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 
+- Divide the bag with 9 balls into two bags of sizes 6 and 3. [<strong><u>9</u></strong>] -&gt; [6,3].
+- Divide the bag with 6 balls into two bags of sizes 3 and 3. [<strong><u>6</u></strong>,3] -&gt; [3,3,3].
+The bag with the most number of balls has 3 balls, so your penalty is 3 and you should return 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,4,8,2], maxOperations = 4
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+- Divide the bag with 8 balls into two bags of sizes 4 and 4. [2,4,<strong><u>8</u></strong>,2] -&gt; [2,4,4,4,2].
+- Divide the bag with 4 balls into two bags of sizes 2 and 2. [2,<strong><u>4</u></strong>,4,4,2] -&gt; [2,2,2,4,4,2].
+- Divide the bag with 4 balls into two bags of sizes 2 and 2. [2,2,2,<strong><u>4</u></strong>,4,2] -&gt; [2,2,2,2,2,4,2].
+- Divide the bag with 4 balls into two bags of sizes 2 and 2. [2,2,2,2,2,<strong><u>4</u></strong>,2] -&gt; [2,2,2,2,2,2,2,2].
+The bag with the most number of balls has 2 balls, so your penalty is 2 an you should return 2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [7,17], maxOperations = 2
+<strong>Output:</strong> 7
+</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;= maxOperations, nums[i] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/179-largest-number/179-largest-number.cpp b/179-largest-number/179-largest-number.cpp
new file mode 100644
index 0000000..c34f89a
--- /dev/null
+++ b/179-largest-number/179-largest-number.cpp
@@ -0,0 +1,49 @@
+class Solution {
+public:
+    
+    static bool  comp(string a,string b)
+    {
+        return (a+b)>(b+a);
+    }
+    
+    string largestNumber(vector<int>& nums) {
+         
+        vector<string> num(nums.size());
+        
+        for(int i=0;i<nums.size();i++)
+        {
+            num[i] = to_string(nums[i]);
+        }
+        
+        sort(num.begin(),num.end(),comp);
+        if(num[0]=="0") return "0";
+        string ans = "";
+        for(int i=0;i<nums.size();i++)
+        {
+            ans += num[i];
+        }
+        return ans;
+    }
+};
+
+
+// class Solution {
+// public:
+//     static bool myCmp(string a,string b){
+//         return (a+b)>(b+a);
+//     }
+    
+//     string largestNumber(vector<int>& nums) {
+//         string s = "";
+//         vector<string> str;
+//         for(auto& x:nums){
+//             str.push_back(to_string(x));
+//         }
+//         sort(str.begin(),str.end(),myCmp);
+//         if(str[0]=="0") return "0";
+//         for(auto& x:str){
+//             s += x;
+//         }
+//         return s;
+//     }
+// };
\ No newline at end of file
diff --git a/179-largest-number/NOTES.md b/179-largest-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/179-largest-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/179-largest-number/README.md b/179-largest-number/README.md
new file mode 100644
index 0000000..f292471
--- /dev/null
+++ b/179-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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [10,2]
+<strong>Output:</strong> "210"
+</pre>
+
+<p><strong>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/18-4sum/18-4sum.cpp b/18-4sum/18-4sum.cpp
new file mode 100644
index 0000000..4d23c36
--- /dev/null
+++ b/18-4sum/18-4sum.cpp
@@ -0,0 +1,44 @@
+class Solution {
+public:
+    vector<vector<int>> fourSum(vector<int>& nums, int target) {
+        vector<vector<int>> ans;
+        if(nums.size()<4)return ans;
+        sort(nums.begin(),nums.end());
+        for(int i=0;i<nums.size()-3;i++)
+        {
+            if(i==0 || nums[i] != nums[i-1])
+            {
+                for(int j=i+1;j<nums.size()-2;j++)
+                {
+                    if(j==i+1 || nums[j] != nums[j-1])
+                    {
+                        int k = j+1;
+                        int l = nums.size()-1;
+                        
+                        while(k<l)
+                        {
+                            long long int sum = ( long long int)nums[i]+( long long int)nums[j]+( long long int)nums[k]+( long long int)nums[l];
+                            if(sum == target)
+                            {
+                                ans.push_back({nums[i],nums[j],nums[k],nums[l]});
+                                
+                                while(k<l && nums[k] == nums[k+1])k++;
+                                while(k<l && nums[l] == nums[l-1])l--;
+                                
+                                k++;
+                                l--;
+                            }
+                            else if(sum > target)
+                            {
+                                l--;
+                            }
+                            else
+                                k++;
+                        }
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/18-4sum/NOTES.md b/18-4sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/18-4sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/18-4sum/README.md b/18-4sum/README.md
new file mode 100644
index 0000000..5c92452
--- /dev/null
+++ b/18-4sum/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/4sum/">18. 4Sum</a></h2><h3>Medium</h3><hr><div><p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
+
+<ul>
+	<li><code>0 &lt;= a, b, c, d&nbsp;&lt; n</code></li>
+	<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
+	<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
+</ul>
+
+<p>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,0,-1,0,-2,2], target = 0
+<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,2,2,2,2], target = 8
+<strong>Output:</strong> [[2,2,2,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>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>
+</ul>
+</div>
\ No newline at end of file
diff --git a/1823-find-the-winner-of-the-circular-game/1823-find-the-winner-of-the-circular-game.cpp b/1823-find-the-winner-of-the-circular-game/1823-find-the-winner-of-the-circular-game.cpp
new file mode 100644
index 0000000..4064c06
--- /dev/null
+++ b/1823-find-the-winner-of-the-circular-game/1823-find-the-winner-of-the-circular-game.cpp
@@ -0,0 +1,9 @@
+class Solution {
+public:
+    int findTheWinner(int n, int k) {
+             int res = 0;
+        for (int i = 1; i <= n; ++i)
+            res = (res + k) % i;
+      return res+1;
+    }
+};
\ No newline at end of file
diff --git a/1823-find-the-winner-of-the-circular-game/NOTES.md b/1823-find-the-winner-of-the-circular-game/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/1823-find-the-winner-of-the-circular-game/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/1823-find-the-winner-of-the-circular-game/README.md b/1823-find-the-winner-of-the-circular-game/README.md
new file mode 100644
index 0000000..42e9370
--- /dev/null
+++ b/1823-find-the-winner-of-the-circular-game/README.md
@@ -0,0 +1,43 @@
+<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>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>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></div>
\ No newline at end of file
diff --git a/189-rotate-array/NOTES.md b/189-rotate-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/189-rotate-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/189-rotate-array/README.md b/189-rotate-array/README.md
new file mode 100644
index 0000000..7164839
--- /dev/null
+++ b/189-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 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/2-add-two-numbers/2-add-two-numbers.cpp b/2-add-two-numbers/2-add-two-numbers.cpp
new file mode 100644
index 0000000..85a5c8e
--- /dev/null
+++ b/2-add-two-numbers/2-add-two-numbers.cpp
@@ -0,0 +1,58 @@
+/**
+ * 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 * reverse(ListNode * l1)
+//     {
+//         if(!l1 || l1->next == NULL)
+//             return l1;
+        
+//         ListNode * nextnode=l1->next;
+//         ListNode * reversed = reverse(l1->next);
+//         l1->next = NULL;
+//         nextnode->next = l1;
+//         return reversed;
+//     }
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+   //     l1 = reverse(l1);
+   //     l2 = reverse(l2);
+        int carry = 0;
+        ListNode * dummy = new ListNode(0);
+        ListNode * temp = dummy;
+        while(l1 != NULL || l2 !=NULL)
+        {
+            int sum = carry;
+            if(l1)
+                sum+=l1->val;
+            if(l2)
+                sum+=l2->val;
+            
+            int value = sum%10;
+            carry = sum/10;
+            ListNode * newNode = new ListNode(value);
+            temp->next = newNode;
+            temp = temp->next;
+            if(l1)
+            l1 = l1->next;
+            if(l2)
+            l2 = l2->next;
+        }
+        
+        if(carry)
+        {
+            ListNode * newNode = new ListNode(carry);
+            temp->next = newNode;
+            temp = temp->next;
+        }
+        return dummy->next;
+        
+    }
+};
\ No newline at end of file
diff --git a/2-add-two-numbers/NOTES.md b/2-add-two-numbers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/2-add-two-numbers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/2-add-two-numbers/README.md b/2-add-two-numbers/README.md
new file mode 100644
index 0000000..23f654a
--- /dev/null
+++ b/2-add-two-numbers/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/add-two-numbers/">2. Add Two Numbers</a></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/20-valid-parentheses/20-valid-parentheses.cpp b/20-valid-parentheses/20-valid-parentheses.cpp
new file mode 100644
index 0000000..d8d9095
--- /dev/null
+++ b/20-valid-parentheses/20-valid-parentheses.cpp
@@ -0,0 +1,53 @@
+class Solution {
+public:
+    bool isValid(string s) {
+        stack<char> sc;
+      
+      for(int i=0;i<s.size();i++)
+      {
+        if(s[i] == '{')
+          sc.push(s[i]);
+        else if(s[i] == '(')
+          sc.push(s[i]);
+        else if(s[i] == '[')
+          sc.push(s[i]);
+        
+        if(sc.empty())
+          return false;
+        
+        if(s[i] == '}')
+        {
+          if(sc.top() == '{')
+          {
+            sc.pop();
+          }
+          else
+          {
+            return false;
+          }
+        }
+        else if(s[i] == ']')
+        {
+          if(sc.top() == '[')
+          {
+            sc.pop();
+          }
+          else
+            return false;
+        }
+        else if(s[i] == ')')
+        {
+          if(sc.top() == '(')
+            sc.pop();
+          else
+            return false;
+        }
+          
+      }
+      
+      if(sc.empty())
+        return true;
+      else
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/20-valid-parentheses/NOTES.md b/20-valid-parentheses/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/20-valid-parentheses/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/20-valid-parentheses/README.md b/20-valid-parentheses/README.md
new file mode 100644
index 0000000..2fa17b8
--- /dev/null
+++ b/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/203-remove-linked-list-elements/203-remove-linked-list-elements.cpp b/203-remove-linked-list-elements/203-remove-linked-list-elements.cpp
new file mode 100644
index 0000000..c6ffda7
--- /dev/null
+++ b/203-remove-linked-list-elements/203-remove-linked-list-elements.cpp
@@ -0,0 +1,35 @@
+/**
+ * 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* solve(ListNode* head, int val)
+    {
+        if(head == NULL)return head;
+        if(head->val == val)
+        {
+            return solve(head->next,val);
+        }
+        else
+        {
+            head->next = solve(head->next,val);
+            return head;
+        }
+        return NULL;
+    }
+    
+    ListNode* removeElements(ListNode* head, int val) {
+        ListNode * dummy = new ListNode(-1);
+        dummy->next = head;
+        dummy = solve(dummy,val);
+        return dummy->next;
+    }
+};
\ No newline at end of file
diff --git a/203-remove-linked-list-elements/NOTES.md b/203-remove-linked-list-elements/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/203-remove-linked-list-elements/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/203-remove-linked-list-elements/README.md b/203-remove-linked-list-elements/README.md
new file mode 100644
index 0000000..7548824
--- /dev/null
+++ b/203-remove-linked-list-elements/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/remove-linked-list-elements/">203. Remove Linked List Elements</a></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/206-reverse-linked-list/206-reverse-linked-list.cpp b/206-reverse-linked-list/206-reverse-linked-list.cpp
new file mode 100644
index 0000000..029d188
--- /dev/null
+++ b/206-reverse-linked-list/206-reverse-linked-list.cpp
@@ -0,0 +1,23 @@
+/**
+ * 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* reverseList(ListNode* head) {
+        if(head == NULL || head->next == NULL)
+            return head;
+        
+        ListNode* nextNode = head->next;
+        ListNode * reversed = reverseList(nextNode);
+        nextNode->next = head;
+        head->next = NULL;
+        return reversed;
+    }
+};
\ No newline at end of file
diff --git a/206-reverse-linked-list/NOTES.md b/206-reverse-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/206-reverse-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/206-reverse-linked-list/README.md b/206-reverse-linked-list/README.md
new file mode 100644
index 0000000..8343480
--- /dev/null
+++ b/206-reverse-linked-list/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/reverse-linked-list/">206. Reverse Linked List</a></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/209-minimum-size-subarray-sum/209-minimum-size-subarray-sum.cpp b/209-minimum-size-subarray-sum/209-minimum-size-subarray-sum.cpp
new file mode 100644
index 0000000..699e4a8
--- /dev/null
+++ b/209-minimum-size-subarray-sum/209-minimum-size-subarray-sum.cpp
@@ -0,0 +1,64 @@
+class Solution {
+public:
+    
+    int maxSumOfSizeK(vector<int> &nums,int k)
+    {
+        int maxi = INT_MIN;
+        int sum = 0;
+        for(int i=0;i<k;i++)
+        {
+            sum += nums[i];
+        }
+        maxi = max(sum,maxi);
+        
+        for(int i=k;i<nums.size();i++)
+        {
+            sum += nums[i] - nums[i-k];
+            maxi = max(sum,maxi);
+        }
+        return maxi;
+    }
+    
+   int minSubArrayLen(int s, vector<int>& nums)
+{
+    int n = nums.size();
+    int ans = INT_MAX;
+    int left = 0;
+    int sum = 0;
+    for (int i = 0; i < n; i++) {
+        sum += nums[i];
+        while (sum >= s) {
+            ans = min(ans, i + 1 - left);
+            sum -= nums[left++];
+        }
+    }
+    return (ans != INT_MAX) ? ans : 0;
+}
+};
+
+
+
+
+
+
+
+ //   int low = 1;
+//         int high = nums.size();
+        
+//         while(low < high)
+//         {
+//             int mid = low + (high-low)/2;
+            
+//             if(maxSumOfSizeK(nums,mid) >= target)
+//             {
+//                 high = mid;
+//             }
+//             else if(maxSumOfSizeK(nums,mid) < target)
+//             {
+//               low = mid+1;  
+//             }
+//         }
+//         if(maxSumOfSizeK(nums,low) >= target)
+//         return low;
+//         else
+//             return 0;
\ No newline at end of file
diff --git a/209-minimum-size-subarray-sum/NOTES.md b/209-minimum-size-subarray-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/209-minimum-size-subarray-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/209-minimum-size-subarray-sum/README.md b/209-minimum-size-subarray-sum/README.md
new file mode 100644
index 0000000..4b03299
--- /dev/null
+++ b/209-minimum-size-subarray-sum/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/minimum-size-subarray-sum/">209. Minimum Size Subarray Sum</a></h2><h3>Medium</h3><hr><div><p>Given an array of positive integers <code>nums</code> and a positive integer <code>target</code>, return the minimal length of a <strong>contiguous subarray</strong> <code>[nums<sub>l</sub>, nums<sub>l+1</sub>, ..., nums<sub>r-1</sub>, nums<sub>r</sub>]</code> of which the sum is greater than or equal to <code>target</code>. If there is no such subarray, return <code>0</code> instead.</p>
+
+<p>&nbsp;</p>
+<p><strong>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>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> target = 4, nums = [1,4,4]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>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>5</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>.</div>
\ No newline at end of file
diff --git a/21-merge-two-sorted-lists/21-merge-two-sorted-lists.cpp b/21-merge-two-sorted-lists/21-merge-two-sorted-lists.cpp
new file mode 100644
index 0000000..a8a0fd3
--- /dev/null
+++ b/21-merge-two-sorted-lists/21-merge-two-sorted-lists.cpp
@@ -0,0 +1,46 @@
+/**
+ * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
+        
+        if(list1 == NULL)return list2;
+        if(list2 == NULL)return list1;
+        
+        ListNode * dummy  = new ListNode;
+        ListNode * head = dummy;
+        
+        while(list1 && list2)
+        {
+            if(list1->val <= list2->val)
+            {
+                head->next = list1;
+                list1 = list1->next;
+            }
+            else
+            {
+                head->next = list2;
+                list2 = list2->next;
+            }
+            head = head->next;
+        }
+        
+        if(list1)
+        {
+            head->next = list1;
+        }
+        if(list2)
+        {
+            head->next = list2;
+        }
+        return dummy->next;
+    }
+};
\ No newline at end of file
diff --git a/21-merge-two-sorted-lists/NOTES.md b/21-merge-two-sorted-lists/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/21-merge-two-sorted-lists/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/21-merge-two-sorted-lists/README.md b/21-merge-two-sorted-lists/README.md
new file mode 100644
index 0000000..b5058a6
--- /dev/null
+++ b/21-merge-two-sorted-lists/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/merge-two-sorted-lists/">21. Merge Two Sorted Lists</a></h2><h3>Easy</h3><hr><div><p>You are given the heads of two sorted linked lists <code>list1</code> and <code>list2</code>.</p>
+
+<p>Merge the two lists in a 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>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>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> list1 = [], list2 = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>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>
+</div>
\ No newline at end of file
diff --git a/2145-count-the-hidden-sequences/2145-count-the-hidden-sequences.cpp b/2145-count-the-hidden-sequences/2145-count-the-hidden-sequences.cpp
new file mode 100644
index 0000000..24d2c7d
--- /dev/null
+++ b/2145-count-the-hidden-sequences/2145-count-the-hidden-sequences.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int numberOfArrays(vector<int>& diff, int lower, int upper) {
+        long a = 0, ma = 0, mi = 0;
+        for (int d: diff) {
+            a += d;
+            ma = max(ma, a);
+            mi = min(mi, a);
+        }
+        return max(0L, (upper - lower) - (ma - mi) + 1);
+    }
+};
\ No newline at end of file
diff --git a/2145-count-the-hidden-sequences/NOTES.md b/2145-count-the-hidden-sequences/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/2145-count-the-hidden-sequences/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/2145-count-the-hidden-sequences/README.md b/2145-count-the-hidden-sequences/README.md
new file mode 100644
index 0000000..dc0188a
--- /dev/null
+++ b/2145-count-the-hidden-sequences/README.md
@@ -0,0 +1,57 @@
+<h2><a href="https://leetcode.com/problems/count-the-hidden-sequences/">2145. Count the Hidden Sequences</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> array of <code>n</code> integers <code>differences</code>, which describes the <strong>differences </strong>between each pair of <strong>consecutive </strong>integers of a <strong>hidden</strong> sequence of length <code>(n + 1)</code>. More formally, call the hidden sequence <code>hidden</code>, then we have that <code>differences[i] = hidden[i + 1] - hidden[i]</code>.</p>
+
+<p>You are further given two integers <code>lower</code> and <code>upper</code> that describe the <strong>inclusive</strong> range of values <code>[lower, upper]</code> that the hidden sequence can contain.</p>
+
+<ul>
+	<li>For example, given <code>differences = [1, -3, 4]</code>, <code>lower = 1</code>, <code>upper = 6</code>, the hidden sequence is a sequence of length <code>4</code> whose elements are in between <code>1</code> and <code>6</code> (<strong>inclusive</strong>).
+
+	<ul>
+		<li><code>[3, 4, 1, 5]</code> and <code>[4, 5, 2, 6]</code> are possible hidden sequences.</li>
+		<li><code>[5, 6, 3, 7]</code> is not possible since it contains an element greater than <code>6</code>.</li>
+		<li><code>[1, 2, 3, 4]</code> is not possible since the differences are not correct.</li>
+	</ul>
+	</li>
+</ul>
+
+<p>Return <em>the number of <strong>possible</strong> hidden sequences there are.</em> If there are no possible sequences, return <code>0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> differences = [1,-3,4], lower = 1, upper = 6
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The possible hidden sequences are:
+- [3, 4, 1, 5]
+- [4, 5, 2, 6]
+Thus, we return 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> differences = [3,-4,5,1,-2], lower = -4, upper = 5
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The possible hidden sequences are:
+- [-3, 0, -4, 1, 2, 0]
+- [-2, 1, -3, 2, 3, 1]
+- [-1, 2, -2, 3, 4, 2]
+- [0, 3, -1, 4, 5, 3]
+Thus, we return 4.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> differences = [4,-7,2], lower = 3, upper = 6
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There are no possible hidden sequences. Thus, we return 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == differences.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>5</sup> &lt;= differences[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>5</sup> &lt;= lower &lt;= upper &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/2202-maximize-the-topmost-element-after-k-moves/NOTES.md b/2202-maximize-the-topmost-element-after-k-moves/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/2202-maximize-the-topmost-element-after-k-moves/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/2202-maximize-the-topmost-element-after-k-moves/README.md b/2202-maximize-the-topmost-element-after-k-moves/README.md
new file mode 100644
index 0000000..d268f84
--- /dev/null
+++ b/2202-maximize-the-topmost-element-after-k-moves/README.md
@@ -0,0 +1,44 @@
+<h2><a href="https://leetcode.com/problems/maximize-the-topmost-element-after-k-moves/">2202. Maximize the Topmost Element After K Moves</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> representing the contents of a <b>pile</b>, where <code>nums[0]</code> is the topmost element of the pile.</p>
+
+<p>In one move, you can perform <strong>either</strong> of the following:</p>
+
+<ul>
+	<li>If the pile is not empty, <strong>remove</strong> the topmost element of the pile.</li>
+	<li>If there are one or more removed elements, <strong>add</strong> any one of them back onto the pile. This element becomes the new topmost element.</li>
+</ul>
+
+<p>You are also given an integer <code>k</code>, which denotes the total number of moves to be made.</p>
+
+<p>Return <em>the <strong>maximum value</strong> of the topmost element of the pile possible after <strong>exactly</strong></em> <code>k</code> <em>moves</em>. In case it is not possible to obtain a non-empty pile after <code>k</code> moves, return <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [5,2,2,4,0,6], k = 4
+<strong>Output:</strong> 5
+<strong>Explanation:</strong>
+One of the ways we can end with 5 at the top of the pile after 4 moves is as follows:
+- Step 1: Remove the topmost element = 5. The pile becomes [2,2,4,0,6].
+- Step 2: Remove the topmost element = 2. The pile becomes [2,4,0,6].
+- Step 3: Remove the topmost element = 2. The pile becomes [4,0,6].
+- Step 4: Add 5 back onto the pile. The pile becomes [5,4,0,6].
+Note that this is not the only way to end with 5 at the top of the pile. It can be shown that 5 is the largest answer possible after 4 moves.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2], k = 1
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> 
+In the first move, our only option is to pop the topmost element of the pile.
+Since it is not possible to obtain a non-empty pile after one move, 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>0 &lt;= nums[i], k &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/2207-maximize-number-of-subsequences-in-a-string/2207-maximize-number-of-subsequences-in-a-string.cpp b/2207-maximize-number-of-subsequences-in-a-string/2207-maximize-number-of-subsequences-in-a-string.cpp
new file mode 100644
index 0000000..095e3cf
--- /dev/null
+++ b/2207-maximize-number-of-subsequences-in-a-string/2207-maximize-number-of-subsequences-in-a-string.cpp
@@ -0,0 +1,45 @@
+class Solution {
+public:
+    
+    long long maximumSubsequenceCount(string text, string pattern) {
+        long long ans = 0;
+        int a = 0;
+        int b = 0;
+        
+        for(int i=0;i<text.size();i++)
+        {
+            if(text[i] == pattern[0])
+            {
+                a++;
+            }
+            if(text[i] == pattern[1])
+            {
+                b++;
+            }
+        }
+        if(a>b)
+        {
+            b++;
+            text += pattern[1]; 
+        }  
+        else
+        {
+            a++;
+            text = pattern[0] + text;
+        }
+        
+        for(int i=0;i<text.size();i++)
+        {
+            if(text[i] == pattern[0])
+            {
+               ans += b; 
+            }
+            if(text[i] == pattern[1])
+            {
+                b--;
+            }
+        }
+        
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/2207-maximize-number-of-subsequences-in-a-string/NOTES.md b/2207-maximize-number-of-subsequences-in-a-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/2207-maximize-number-of-subsequences-in-a-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/2207-maximize-number-of-subsequences-in-a-string/README.md b/2207-maximize-number-of-subsequences-in-a-string/README.md
new file mode 100644
index 0000000..1cc3594
--- /dev/null
+++ b/2207-maximize-number-of-subsequences-in-a-string/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/maximize-number-of-subsequences-in-a-string/">2207. Maximize Number of Subsequences in a String</a></h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> string <code>text</code> and another <strong>0-indexed</strong> string <code>pattern</code> of length <code>2</code>, both of which consist of only lowercase English letters.</p>
+
+<p>You can add <strong>either</strong> <code>pattern[0]</code> <strong>or</strong> <code>pattern[1]</code> anywhere in <code>text</code> <strong>exactly once</strong>. Note that the character can be added even at the beginning or at the end of <code>text</code>.</p>
+
+<p>Return <em>the <strong>maximum</strong> number of times</em> <code>pattern</code> <em>can occur as a <strong>subsequence</strong> of the modified </em><code>text</code>.</p>
+
+<p>A <b>subsequence</b> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> text = "abdcdbc", pattern = "ac"
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+If we add pattern[0] = 'a' in between text[1] and text[2], we get "ab<u><strong>a</strong></u>dcdbc". Now, the number of times "ac" occurs as a subsequence is 4.
+Some other strings which have 4 subsequences "ac" after adding a character to text are "<u><strong>a</strong></u>abdcdbc" and "abd<u><strong>a</strong></u>cdbc".
+However, strings such as "abdc<u><strong>a</strong></u>dbc", "abd<u><strong>c</strong></u>cdbc", and "abdcdbc<u><strong>c</strong></u>", although obtainable, have only 3 subsequences "ac" and are thus suboptimal.
+It can be shown that it is not possible to get more than 4 subsequences "ac" by adding only one character.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> text = "aabb", pattern = "ab"
+<strong>Output:</strong> 6
+<strong>Explanation:</strong>
+Some of the strings which can be obtained from text and have 6 subsequences "ab" are "<u><strong>a</strong></u>aabb", "aa<u><strong>a</strong></u>bb", and "aab<u><strong>b</strong></u>b".
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= text.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>pattern.length == 2</code></li>
+	<li><code>text</code> and <code>pattern</code> consist only of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/221-maximal-square/NOTES.md b/221-maximal-square/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/221-maximal-square/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/221-maximal-square/README.md b/221-maximal-square/README.md
new file mode 100644
index 0000000..e221710
--- /dev/null
+++ b/221-maximal-square/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/maximal-square/">221. Maximal Square</a></h2><h3>Medium</h3><hr><div><p>Given an <code>m x n</code> binary <code>matrix</code> filled with <code>0</code>'s and <code>1</code>'s, <em>find the largest square containing only</em> <code>1</code>'s <em>and return its area</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/26/max1grid.jpg" style="width: 400px; height: 319px;">
+<pre><strong>Input:</strong> matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/26/max2grid.jpg" style="width: 165px; height: 165px;">
+<pre><strong>Input:</strong> matrix = [["0","1"],["1","0"]]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [["0"]]
+<strong>Output:</strong> 0
+</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;= 300</code></li>
+	<li><code>matrix[i][j]</code> is <code>'0'</code> or <code>'1'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/225-implement-stack-using-queues/225-implement-stack-using-queues.cpp b/225-implement-stack-using-queues/225-implement-stack-using-queues.cpp
new file mode 100644
index 0000000..e776d15
--- /dev/null
+++ b/225-implement-stack-using-queues/225-implement-stack-using-queues.cpp
@@ -0,0 +1,40 @@
+class MyStack {
+public:  queue<int> q;
+    MyStack() {
+      
+    }
+    
+    void push(int x) {
+        q.push(x);
+        int size = q.size();
+        for(int i=1;i<size;i++)
+        {
+            q.push(q.front());
+            q.pop();
+        }
+        
+    }
+    
+    int pop() {
+        int ans = q.front();
+        q.pop();
+        return ans;
+    }
+    
+    int top() {
+        return q.front();
+    }
+    
+    bool empty() {
+        return q.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();
+ * bool param_4 = obj->empty();
+ */
\ No newline at end of file
diff --git a/225-implement-stack-using-queues/NOTES.md b/225-implement-stack-using-queues/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/225-implement-stack-using-queues/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/225-implement-stack-using-queues/README.md b/225-implement-stack-using-queues/README.md
new file mode 100644
index 0000000..451a9a8
--- /dev/null
+++ b/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/229-majority-element-ii/229-majority-element-ii.cpp b/229-majority-element-ii/229-majority-element-ii.cpp
new file mode 100644
index 0000000..9a59502
--- /dev/null
+++ b/229-majority-element-ii/229-majority-element-ii.cpp
@@ -0,0 +1,47 @@
+class Solution {
+public:
+    vector<int> majorityElement(vector<int>& nums) {
+        int freq1 = 0;
+        int freq2 = 0;
+        int num1 = 0;
+        int num2 = 1;
+        
+        for(int i=0;i<nums.size();i++)
+        {
+            if(nums[i] == num1)
+                    freq1++;
+            else if(nums[i] == num2)
+                    freq2++;
+            else if(freq1 == 0)
+            {
+                num1 = nums[i];
+                freq1 =1 ;
+            }
+            else if(freq2 == 0)
+            {
+                num2 = nums[i];
+                freq2 = 1;
+            }
+            else
+            {
+             freq1--;
+             freq2--;
+            }
+            
+        }
+        int count1 = 0;
+        int count2 = 0;
+        for(int i=0;i<nums.size();i++)
+        {
+            if(nums[i] == num1)count1++;
+            else if(nums[i] == num2)count2++;
+        }
+        vector<int> ans;
+        if(count1 > nums.size()/3)
+            ans.push_back(num1);
+        if(count2> nums.size()/3)
+            ans.push_back(num2);
+        cout<<num1<<num2<<endl;
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/229-majority-element-ii/NOTES.md b/229-majority-element-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/229-majority-element-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/229-majority-element-ii/README.md b/229-majority-element-ii/README.md
new file mode 100644
index 0000000..19db2c6
--- /dev/null
+++ b/229-majority-element-ii/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/majority-element-ii/">229. Majority Element II</a></h2><h3>Medium</h3><hr><div><p>Given an integer array of size <code>n</code>, find all elements that appear more than <code>⌊ n/3 ⌋</code> times.</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 = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p><strong>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>
+</div>
\ No newline at end of file
diff --git a/23-merge-k-sorted-lists/23-merge-k-sorted-lists.cpp b/23-merge-k-sorted-lists/23-merge-k-sorted-lists.cpp
new file mode 100644
index 0000000..271d541
--- /dev/null
+++ b/23-merge-k-sorted-lists/23-merge-k-sorted-lists.cpp
@@ -0,0 +1,59 @@
+/**
+ * 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* 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;
+        
+        while(l2 != NULL && l1 != NULL)
+        {
+            ListNode * temp = NULL;
+            while(l1 != NULL && l2->val >= l1->val)
+            {
+                temp = l1;
+                l1 = l1->next;
+            }
+            temp -> next = l2;
+            
+            ListNode * tem = l1;
+            l1 = l2;
+            l2 = tem;
+            
+        }
+        return res;
+        
+    }
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        
+      if (lists.size() == 0) return NULL;
+        
+        ListNode* head = lists[0];
+        
+        for (int i = 1; i < lists.size(); i++)
+            head = mergeTwoLists(head, lists[i]);
+        
+        return head;
+    }
+};
\ No newline at end of file
diff --git a/23-merge-k-sorted-lists/NOTES.md b/23-merge-k-sorted-lists/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/23-merge-k-sorted-lists/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/23-merge-k-sorted-lists/README.md b/23-merge-k-sorted-lists/README.md
new file mode 100644
index 0000000..b6d6e1e
--- /dev/null
+++ b/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/231-power-of-two/231-power-of-two.cpp b/231-power-of-two/231-power-of-two.cpp
new file mode 100644
index 0000000..8a4c971
--- /dev/null
+++ b/231-power-of-two/231-power-of-two.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    bool isPowerOfTwo(int n) {
+        
+        if(n==1)return true;
+        if(n<=0)return false;   
+        
+        if(n % 2 == 0 && isPowerOfTwo(n/2))
+            return true;
+        else return false;
+            
+        
+    }
+};
\ No newline at end of file
diff --git a/231-power-of-two/NOTES.md b/231-power-of-two/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/231-power-of-two/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/231-power-of-two/README.md b/231-power-of-two/README.md
new file mode 100644
index 0000000..66e316d
--- /dev/null
+++ b/231-power-of-two/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/power-of-two/">231. Power of Two</a></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>&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/232-implement-queue-using-stacks/232-implement-queue-using-stacks.cpp b/232-implement-queue-using-stacks/232-implement-queue-using-stacks.cpp
new file mode 100644
index 0000000..cbb540a
--- /dev/null
+++ b/232-implement-queue-using-stacks/232-implement-queue-using-stacks.cpp
@@ -0,0 +1,44 @@
+class MyQueue {
+public:
+    MyQueue() {
+        
+    }
+    stack<int> s1;
+    stack<int> s2;
+    void push(int x) {
+        while(s1.size())
+        {
+            s2.push(s1.top());
+            s1.pop();
+        }
+        s1.push(x);
+        while(s2.size())
+        {
+            s1.push(s2.top());
+            s2.pop();
+        }
+    }
+    
+    int pop() {
+        int ans = s1.top();
+        s1.pop();
+        return ans;
+    }
+    
+    int peek() {
+        return s1.top();
+    }
+    
+    bool empty() {
+        return s1.size() == 0 ;
+    }
+};
+
+/**
+ * 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();
+ * bool param_4 = obj->empty();
+ */
\ No newline at end of file
diff --git a/232-implement-queue-using-stacks/NOTES.md b/232-implement-queue-using-stacks/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/232-implement-queue-using-stacks/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/232-implement-queue-using-stacks/README.md b/232-implement-queue-using-stacks/README.md
new file mode 100644
index 0000000..5268042
--- /dev/null
+++ b/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/234-palindrome-linked-list/234-palindrome-linked-list.cpp b/234-palindrome-linked-list/234-palindrome-linked-list.cpp
new file mode 100644
index 0000000..766188f
--- /dev/null
+++ b/234-palindrome-linked-list/234-palindrome-linked-list.cpp
@@ -0,0 +1,55 @@
+/**
+ * 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 * reverse(ListNode * head)
+    {
+        if(head == NULL || head->next == NULL)
+            return head;
+        ListNode * curr = head;
+        ListNode * pre = NULL;
+        ListNode * nex = NULL;
+        
+        while(curr != NULL)
+        {
+            nex = curr->next;
+            curr->next = pre;
+            pre = curr;
+            curr = nex;
+        }
+        
+        return pre;
+    }
+    bool isPalindrome(ListNode* head) {
+        
+        if(head == NULL || head->next == NULL)
+            return true;
+        ListNode * slow = head;
+        ListNode * fast = head;
+        while(fast->next != NULL && fast->next->next != NULL)
+        {
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+        slow->next = reverse(slow->next);
+        slow = slow->next;
+        ListNode * start = head;
+        while(slow != NULL)
+        {
+            if(slow->val != start->val)
+                return false;
+            
+            slow = slow->next;
+            start = start->next;
+        }
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/234-palindrome-linked-list/NOTES.md b/234-palindrome-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/234-palindrome-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/236-lowest-common-ancestor-of-a-binary-tree/236-lowest-common-ancestor-of-a-binary-tree.cpp b/236-lowest-common-ancestor-of-a-binary-tree/236-lowest-common-ancestor-of-a-binary-tree.cpp
new file mode 100644
index 0000000..af1466e
--- /dev/null
+++ b/236-lowest-common-ancestor-of-a-binary-tree/236-lowest-common-ancestor-of-a-binary-tree.cpp
@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        if(root == NULL || p == NULL || q == NULL)
+            return NULL;
+        
+        if(root == p || root == q)
+            return root;
+        
+        TreeNode * leftLCA = lowestCommonAncestor(root->left,p,q);
+        TreeNode * rightLCA = lowestCommonAncestor(root->right,p,q);
+        
+        if(leftLCA == NULL)return rightLCA;
+        else if(rightLCA == NULL)return leftLCA;
+        else
+            return root;
+    }
+};
\ No newline at end of file
diff --git a/236-lowest-common-ancestor-of-a-binary-tree/NOTES.md b/236-lowest-common-ancestor-of-a-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/236-lowest-common-ancestor-of-a-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/236-lowest-common-ancestor-of-a-binary-tree/README.md b/236-lowest-common-ancestor-of-a-binary-tree/README.md
new file mode 100644
index 0000000..3261cce
--- /dev/null
+++ b/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/237-delete-node-in-a-linked-list/237-delete-node-in-a-linked-list.cpp b/237-delete-node-in-a-linked-list/237-delete-node-in-a-linked-list.cpp
new file mode 100644
index 0000000..99361c5
--- /dev/null
+++ b/237-delete-node-in-a-linked-list/237-delete-node-in-a-linked-list.cpp
@@ -0,0 +1,17 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void deleteNode(ListNode* node) {
+        node->val = node->next->val;
+      ListNode * nextNode = node->next;
+      node->next = node->next->next ;
+       delete nextNode;
+    }
+};
\ No newline at end of file
diff --git a/237-delete-node-in-a-linked-list/NOTES.md b/237-delete-node-in-a-linked-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/237-delete-node-in-a-linked-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/237-delete-node-in-a-linked-list/README.md b/237-delete-node-in-a-linked-list/README.md
new file mode 100644
index 0000000..797f85a
--- /dev/null
+++ b/237-delete-node-in-a-linked-list/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/delete-node-in-a-linked-list/">237. Delete Node in a Linked List</a></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: 300px; height: 215px;">
+<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: 300px; height: 236px;">
+<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/238-product-of-array-except-self/238-product-of-array-except-self.cpp b/238-product-of-array-except-self/238-product-of-array-except-self.cpp
new file mode 100644
index 0000000..d35747c
--- /dev/null
+++ b/238-product-of-array-except-self/238-product-of-array-except-self.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+        int n=nums.size();
+        int fromBegin=1;
+        int fromLast=1;
+        vector<int> res(n,1);
+        
+        for(int i=0;i<n;i++){
+            res[i]*=fromBegin;
+            fromBegin*=nums[i];
+            res[n-1-i]*=fromLast;
+            fromLast*=nums[n-1-i];
+        }
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/238-product-of-array-except-self/NOTES.md b/238-product-of-array-except-self/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/238-product-of-array-except-self/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/238-product-of-array-except-self/README.md b/238-product-of-array-except-self/README.md
new file mode 100644
index 0000000..ef80e78
--- /dev/null
+++ b/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/239-sliding-window-maximum/NOTES.md b/239-sliding-window-maximum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/239-sliding-window-maximum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/239-sliding-window-maximum/README.md b/239-sliding-window-maximum/README.md
new file mode 100644
index 0000000..b5410d4
--- /dev/null
+++ b/239-sliding-window-maximum/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/sliding-window-maximum/">239. Sliding Window Maximum</a></h2><h3>Hard</h3><hr><div><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>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>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>
+</div>
\ No newline at end of file
diff --git a/24-swap-nodes-in-pairs/24-swap-nodes-in-pairs.cpp b/24-swap-nodes-in-pairs/24-swap-nodes-in-pairs.cpp
new file mode 100644
index 0000000..becf0ed
--- /dev/null
+++ b/24-swap-nodes-in-pairs/24-swap-nodes-in-pairs.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* swapPairs(ListNode* head) {
+        
+        if(head == NULL || head->next == NULL)
+            return head;
+        
+        ListNode * newNode = swapPairs(head->next->next);
+        
+        int temp = head->val;
+        head->val = head->next->val;
+        head->next->val = temp;
+        
+        head->next->next = newNode;
+        
+        return head;
+        
+    }
+};
\ No newline at end of file
diff --git a/24-swap-nodes-in-pairs/NOTES.md b/24-swap-nodes-in-pairs/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/24-swap-nodes-in-pairs/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/24-swap-nodes-in-pairs/README.md b/24-swap-nodes-in-pairs/README.md
new file mode 100644
index 0000000..562c353
--- /dev/null
+++ b/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/242-valid-anagram/242-valid-anagram.cpp b/242-valid-anagram/242-valid-anagram.cpp
new file mode 100644
index 0000000..8550839
--- /dev/null
+++ b/242-valid-anagram/242-valid-anagram.cpp
@@ -0,0 +1,8 @@
+class Solution {
+public:
+    bool isAnagram(string s, string t) {
+        sort(s.begin(), s.end());
+        sort(t.begin(), t.end());
+        return s == t; 
+    }
+};
\ No newline at end of file
diff --git a/242-valid-anagram/NOTES.md b/242-valid-anagram/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/242-valid-anagram/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/242-valid-anagram/README.md b/242-valid-anagram/README.md
new file mode 100644
index 0000000..d1bed75
--- /dev/null
+++ b/242-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>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "anagram", t = "nagaram"
+<strong>Output:</strong> true
+</pre><p><strong>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/25-reverse-nodes-in-k-group/NOTES.md b/25-reverse-nodes-in-k-group/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/25-reverse-nodes-in-k-group/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/25-reverse-nodes-in-k-group/README.md b/25-reverse-nodes-in-k-group/README.md
new file mode 100644
index 0000000..f173eb6
--- /dev/null
+++ b/25-reverse-nodes-in-k-group/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/reverse-nodes-in-k-group/">25. Reverse Nodes in k-Group</a></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/258-add-digits/258-add-digits.cpp b/258-add-digits/258-add-digits.cpp
new file mode 100644
index 0000000..a66bf59
--- /dev/null
+++ b/258-add-digits/258-add-digits.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int addDigits(int num) {
+        if(num ==0)return 0;
+        
+        if(num % 9)
+        {
+            return num % 9;
+        }
+        else
+        {
+            return 9;
+        }
+        
+    }
+};
\ No newline at end of file
diff --git a/258-add-digits/NOTES.md b/258-add-digits/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/258-add-digits/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/258-add-digits/README.md b/258-add-digits/README.md
new file mode 100644
index 0000000..4aba281
--- /dev/null
+++ b/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/26-remove-duplicates-from-sorted-array/NOTES.md b/26-remove-duplicates-from-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/26-remove-duplicates-from-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/26-remove-duplicates-from-sorted-array/README.md b/26-remove-duplicates-from-sorted-array/README.md
new file mode 100644
index 0000000..d22a6d4
--- /dev/null
+++ b/26-remove-duplicates-from-sorted-array/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/remove-duplicates-from-sorted-array/">26. Remove Duplicates from Sorted Array</a></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>1 &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/283-move-zeroes/283-move-zeroes.cpp b/283-move-zeroes/283-move-zeroes.cpp
new file mode 100644
index 0000000..213f6df
--- /dev/null
+++ b/283-move-zeroes/283-move-zeroes.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+        int i=0;
+        int j=0;
+        
+        while(j<nums.size())
+        {
+            if(nums[j] != 0)
+            {
+                swap(nums[i],nums[j]);
+                i++;
+                j++;
+            }
+            else
+            {
+                j++;
+            }
+        }
+        
+    }
+};
\ No newline at end of file
diff --git a/283-move-zeroes/NOTES.md b/283-move-zeroes/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/283-move-zeroes/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/283-move-zeroes/README.md b/283-move-zeroes/README.md
new file mode 100644
index 0000000..f4c2777
--- /dev/null
+++ b/283-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>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/287-find-the-duplicate-number/287-find-the-duplicate-number.cpp b/287-find-the-duplicate-number/287-find-the-duplicate-number.cpp
new file mode 100644
index 0000000..af87c52
--- /dev/null
+++ b/287-find-the-duplicate-number/287-find-the-duplicate-number.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int findDuplicate(vector<int>& nums) {
+      int slow = nums[0];
+      int fast = nums[0];
+      
+      do{
+        slow = nums[slow];
+        fast = nums[nums[fast]];
+      }while(slow != fast);
+        
+        fast = nums[0];
+      while(slow != fast)
+      {
+        slow = nums[slow];
+        fast = nums[fast];
+      }
+      
+      return fast;
+    }
+};
\ No newline at end of file
diff --git a/287-find-the-duplicate-number/NOTES.md b/287-find-the-duplicate-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/287-find-the-duplicate-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/287-find-the-duplicate-number/README.md b/287-find-the-duplicate-number/README.md
new file mode 100644
index 0000000..7e26c34
--- /dev/null
+++ b/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/30-substring-with-concatenation-of-all-words/30-substring-with-concatenation-of-all-words.cpp b/30-substring-with-concatenation-of-all-words/30-substring-with-concatenation-of-all-words.cpp
new file mode 100644
index 0000000..19c628a
--- /dev/null
+++ b/30-substring-with-concatenation-of-all-words/30-substring-with-concatenation-of-all-words.cpp
@@ -0,0 +1,39 @@
+class Solution {
+public:
+    vector<int> findSubstring(string s, vector<string>& words) {
+        int len = words[0].size(), n = words.size(), ssize = s.size(), left, found;
+        vector<int> res;
+        
+        unordered_map<string, int> freq, tmp;
+        for (auto word : words) freq[word]++;
+            
+        for (int i = 0; i < len; i++) {
+            tmp.clear();
+            left = i, found = 0;
+            
+            for (int j = i; j <= ssize - len; j += len) {
+                string curr = s.substr(j, len);
+                
+                if (freq.find(curr) != freq.end()) {
+                    tmp[curr]++;
+                    found++;
+
+                    while (freq[curr] < tmp[curr]) {
+                        tmp[s.substr(left, len)]--;
+                        found--;
+                        left += len;
+                    }
+
+                    if (found == n) res.push_back(left);
+                }
+                
+                else {
+                    tmp.clear();
+                    found = 0;
+                    left = j + len;
+                }
+            }
+        }
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/30-substring-with-concatenation-of-all-words/NOTES.md b/30-substring-with-concatenation-of-all-words/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/30-substring-with-concatenation-of-all-words/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/30-substring-with-concatenation-of-all-words/README.md b/30-substring-with-concatenation-of-all-words/README.md
new file mode 100644
index 0000000..8799313
--- /dev/null
+++ b/30-substring-with-concatenation-of-all-words/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/substring-with-concatenation-of-all-words/">30. Substring with Concatenation of All Words</a></h2><h3>Hard</h3><hr><div><p>You are given a string <code>s</code> and an array of strings <code>words</code> of <strong>the same length</strong>. Return&nbsp;all starting indices of substring(s) in <code>s</code>&nbsp;that is a concatenation of each word in <code>words</code> <strong>exactly once</strong>, <strong>in any order</strong>,&nbsp;and <strong>without any intervening characters</strong>.</p>
+
+<p>You can return the answer in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "barfoothefoobarman", words = ["foo","bar"]
+<strong>Output:</strong> [0,9]
+<strong>Explanation:</strong> Substrings starting at index 0 and 9 are "barfoo" and "foobar" respectively.
+The output order does not matter, returning [9,0] is fine too.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
+<strong>Output:</strong> [6,9,12]
+</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>1 &lt;= words.length &lt;= 5000</code></li>
+	<li><code>1 &lt;= words[i].length &lt;= 30</code></li>
+	<li><code>s</code> and <code>words[i]</code> consist of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/300-longest-increasing-subsequence/NOTES.md b/300-longest-increasing-subsequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/300-longest-increasing-subsequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/307-range-sum-query-mutable/NOTES.md b/307-range-sum-query-mutable/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/307-range-sum-query-mutable/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/307-range-sum-query-mutable/README.md b/307-range-sum-query-mutable/README.md
new file mode 100644
index 0000000..8a476a2
--- /dev/null
+++ b/307-range-sum-query-mutable/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/range-sum-query-mutable/">307. Range Sum Query - Mutable</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, handle multiple queries of the following types:</p>
+
+<ol>
+	<li><strong>Update</strong> the value of an element in <code>nums</code>.</li>
+	<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>void update(int index, int val)</code> <strong>Updates</strong> the value of <code>nums[index]</code> to be <code>val</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>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["NumArray", "sumRange", "update", "sumRange"]
+[[[1, 3, 5]], [0, 2], [1, 2], [0, 2]]
+<strong>Output</strong>
+[null, 9, null, 8]
+
+<strong>Explanation</strong>
+NumArray numArray = new NumArray([1, 3, 5]);
+numArray.sumRange(0, 2); // return 1 + 3 + 5 = 9
+numArray.update(1, 2);   // nums = [1, 2, 5]
+numArray.sumRange(0, 2); // return 1 + 2 + 5 = 8
+</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>-100 &lt;= nums[i] &lt;= 100</code></li>
+	<li><code>0 &lt;= index &lt; nums.length</code></li>
+	<li><code>-100 &lt;= val &lt;= 100</code></li>
+	<li><code>0 &lt;= left &lt;= right &lt; nums.length</code></li>
+	<li>At most <code>3 * 10<sup>4</sup></code> calls will be made to <code>update</code> and <code>sumRange</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/31-next-permutation/31-next-permutation.cpp b/31-next-permutation/31-next-permutation.cpp
new file mode 100644
index 0000000..248c0d7
--- /dev/null
+++ b/31-next-permutation/31-next-permutation.cpp
@@ -0,0 +1,37 @@
+class Solution {
+public:
+    void nextPermutation(vector<int>& nums) {
+        
+        int idx1;
+        int i;
+        for(i=nums.size()-2;i>=0;i--)
+        {
+            if(nums[i]<nums[i+1])
+            {
+                idx1 = i;
+                break;
+            }
+        }
+        
+        if(i == -1){
+            reverse(nums.begin(),nums.end());
+        }
+        else
+        {
+            int idx2 = 0;
+            for(int i=nums.size()-1;i>=idx1;i--)
+            {
+                if(nums[idx1] < nums[i])
+                {
+                    idx2 = i;
+                    break;
+                }
+            }
+            
+            swap(nums[idx1],nums[idx2]);
+            reverse(nums.begin()+idx1+1,nums.end());
+            
+            
+        }
+    }
+};
\ No newline at end of file
diff --git a/31-next-permutation/NOTES.md b/31-next-permutation/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/31-next-permutation/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/316-remove-duplicate-letters/316-remove-duplicate-letters.cpp b/316-remove-duplicate-letters/316-remove-duplicate-letters.cpp
new file mode 100644
index 0000000..2a0141b
--- /dev/null
+++ b/316-remove-duplicate-letters/316-remove-duplicate-letters.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    string removeDuplicateLetters(string s) {
+         vector<int> cand(256, 0);
+    vector<bool> visited(256, false);
+    for (char c : s)
+        cand[c]++;
+    string result = "0";
+    for (char c : s) {
+        cand[c]--;
+        if (visited[c]) continue;
+        while (c < result.back() && cand[result.back()]) {
+            visited[result.back()] = false;
+            result.pop_back();
+        }
+        result += c;
+        visited[c] = true;
+    }
+    return result.substr(1);
+    } 
+};
\ No newline at end of file
diff --git a/316-remove-duplicate-letters/NOTES.md b/316-remove-duplicate-letters/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/316-remove-duplicate-letters/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/316-remove-duplicate-letters/README.md b/316-remove-duplicate-letters/README.md
new file mode 100644
index 0000000..52507ca
--- /dev/null
+++ b/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/326-power-of-three/326-power-of-three.cpp b/326-power-of-three/326-power-of-three.cpp
new file mode 100644
index 0000000..8d18cec
--- /dev/null
+++ b/326-power-of-three/326-power-of-three.cpp
@@ -0,0 +1,11 @@
+class Solution {
+public:
+    bool isPowerOfThree(int n) {
+        
+        if(n==1)return true;
+        if(n<=0)return false;
+        
+        if(n % 3 == 0 && isPowerOfThree(n/3))return true;
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/326-power-of-three/NOTES.md b/326-power-of-three/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/326-power-of-three/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/326-power-of-three/README.md b/326-power-of-three/README.md
new file mode 100644
index 0000000..5d967bb
--- /dev/null
+++ b/326-power-of-three/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/power-of-three/">326. Power of Three</a></h2><h3>Easy</h3><hr><div><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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 27
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 0
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 9
+<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?</div>
\ No newline at end of file
diff --git a/33-search-in-rotated-sorted-array/33-search-in-rotated-sorted-array.cpp b/33-search-in-rotated-sorted-array/33-search-in-rotated-sorted-array.cpp
new file mode 100644
index 0000000..1145ebc
--- /dev/null
+++ b/33-search-in-rotated-sorted-array/33-search-in-rotated-sorted-array.cpp
@@ -0,0 +1,30 @@
+class Solution {
+public:
+    int search(vector<int>& nums, int x) {
+        int low = 0;
+        int high = nums.size()-1;
+        int ans = -1;
+        while(low<=high)
+        {
+            int mid = low + (high-low)/2;
+            
+            if(nums[mid] == x)
+                return mid;
+            else if(nums[low] <= nums[mid])
+            {
+                if(nums[low]<= x && x <= nums[mid])
+                    high = mid-1;
+                else
+                    low = mid+1;
+            }
+            else
+            {
+                if(nums[mid]<= x && x <= nums[high])
+                    low = mid+1;
+                else
+                    high = mid-1;
+            }
+        }
+        return -1;
+    }
+};
\ No newline at end of file
diff --git a/33-search-in-rotated-sorted-array/NOTES.md b/33-search-in-rotated-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/33-search-in-rotated-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/33-search-in-rotated-sorted-array/README.md b/33-search-in-rotated-sorted-array/README.md
new file mode 100644
index 0000000..2fc6903
--- /dev/null
+++ b/33-search-in-rotated-sorted-array/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/search-in-rotated-sorted-array/">33. Search in Rotated Sorted Array</a></h2><h3>Medium</h3><hr><div><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>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>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>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>
+</div>
\ No newline at end of file
diff --git a/34-find-first-and-last-position-of-element-in-sorted-array/34-find-first-and-last-position-of-element-in-sorted-array.cpp b/34-find-first-and-last-position-of-element-in-sorted-array/34-find-first-and-last-position-of-element-in-sorted-array.cpp
new file mode 100644
index 0000000..1ef48dd
--- /dev/null
+++ b/34-find-first-and-last-position-of-element-in-sorted-array/34-find-first-and-last-position-of-element-in-sorted-array.cpp
@@ -0,0 +1,60 @@
+class Solution {
+public:
+    
+    int lower(vector<int>& nums, int target) 
+    {
+        int low = 0;
+        int high = nums.size()-1;
+        int ans = -1;
+        
+        while(low<=high)
+        {
+            int mid = (low+high)>>1;
+            
+            if(nums[mid] == target)
+            {
+                ans = mid;
+                high = mid-1;
+            }
+            else if(nums[mid] > target)
+                high = mid - 1;
+            else
+                low = mid + 1;
+        }
+        return ans;
+    }
+    
+    int higher(vector<int>& nums, int target)
+    {
+        int low = 0;
+        int high = nums.size()-1;
+        int ans = -1;
+        
+        while(low<=high)
+        {
+            int mid = (low+high)>>1;
+            
+            if(nums[mid] == target)
+            {
+                ans = mid;
+                low = mid+1;
+            }
+            else if(nums[mid] > target)
+                high = mid-1;
+            else
+                low = mid + 1;
+        }
+        return ans;
+    }
+    
+    vector<int> searchRange(vector<int>& nums, int target) {
+        
+        vector<int> v(2);
+        
+        v[0] = lower(nums,target);
+        v[1] = higher(nums,target);
+        
+        return v;
+        
+    }
+};
\ No newline at end of file
diff --git a/34-find-first-and-last-position-of-element-in-sorted-array/README.md b/34-find-first-and-last-position-of-element-in-sorted-array/README.md
new file mode 100644
index 0000000..84af2cc
--- /dev/null
+++ b/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/342-power-of-four/342-power-of-four.cpp b/342-power-of-four/342-power-of-four.cpp
new file mode 100644
index 0000000..da9d55a
--- /dev/null
+++ b/342-power-of-four/342-power-of-four.cpp
@@ -0,0 +1,11 @@
+class Solution {
+public:
+    bool isPowerOfFour(int n) {
+        
+           if(n==1)return true;
+        if(n<=0)return false;
+        
+        if(n % 4 == 0 && isPowerOfFour(n/4))return true;
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/342-power-of-four/NOTES.md b/342-power-of-four/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/342-power-of-four/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/342-power-of-four/README.md b/342-power-of-four/README.md
new file mode 100644
index 0000000..c54783d
--- /dev/null
+++ b/342-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><div><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>Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 16
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> false
+</pre><p><strong>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?</div>
\ No newline at end of file
diff --git a/344-reverse-string/NOTES.md b/344-reverse-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/344-reverse-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/344-reverse-string/README.md b/344-reverse-string/README.md
new file mode 100644
index 0000000..15ad161
--- /dev/null
+++ b/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/345-reverse-vowels-of-a-string/345-reverse-vowels-of-a-string.cpp b/345-reverse-vowels-of-a-string/345-reverse-vowels-of-a-string.cpp
new file mode 100644
index 0000000..8b0f51e
--- /dev/null
+++ b/345-reverse-vowels-of-a-string/345-reverse-vowels-of-a-string.cpp
@@ -0,0 +1,25 @@
+class Solution {
+public:
+    
+    bool isvowel(char a)
+    {
+        if(a == 'a' || a=='A' || a == 'e'|| a == 'E'|| a == 'i' ||a == 'I'||a == 'O'  ||a == 'o' || a== 'u' || a== 'U')
+        return true;
+        return false;
+    }
+    string reverseVowels(string s) {
+        int i = 0;
+        int j = s.size()-1;
+        while(i<j)
+        {
+            while(!isvowel(s[i]) && i<j)
+                    i++;
+            while(!isvowel(s[j]) && i<j)
+                    j--;
+            
+            if(i<j)
+                swap(s[i++],s[j--]);
+        }
+        return s;
+    }
+};
\ No newline at end of file
diff --git a/345-reverse-vowels-of-a-string/NOTES.md b/345-reverse-vowels-of-a-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/345-reverse-vowels-of-a-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/345-reverse-vowels-of-a-string/README.md b/345-reverse-vowels-of-a-string/README.md
new file mode 100644
index 0000000..cd06742
--- /dev/null
+++ b/345-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 cases.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "hello"
+<strong>Output:</strong> "holle"
+</pre><p><strong>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/347-top-k-frequent-elements/347-top-k-frequent-elements.cpp b/347-top-k-frequent-elements/347-top-k-frequent-elements.cpp
new file mode 100644
index 0000000..620978a
--- /dev/null
+++ b/347-top-k-frequent-elements/347-top-k-frequent-elements.cpp
@@ -0,0 +1,25 @@
+class Solution {
+public:
+    vector<int> topKFrequent(vector<int>& nums, int k) {
+        unordered_map<int, int> counts;
+        for(auto i : nums) ++counts[i];
+        
+        // 1->3
+        // 2->2
+        // 3->1
+        
+        vector<vector<int>> buckets(nums.size() + 1);
+        for(auto  p : counts) 
+            buckets[p.second].push_back(p.first);
+        reverse(begin(buckets), end(buckets));
+        
+        vector<int> res;
+        for(auto & bucket: buckets) 
+            for(auto i : bucket) {
+                res.push_back(i);
+                if(res.size() == k) return res;
+            }
+        
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/347-top-k-frequent-elements/NOTES.md b/347-top-k-frequent-elements/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/347-top-k-frequent-elements/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/347-top-k-frequent-elements/README.md b/347-top-k-frequent-elements/README.md
new file mode 100644
index 0000000..8ae3d88
--- /dev/null
+++ b/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/35-search-insert-position/35-search-insert-position.cpp b/35-search-insert-position/35-search-insert-position.cpp
new file mode 100644
index 0000000..e6f9aa4
--- /dev/null
+++ b/35-search-insert-position/35-search-insert-position.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int searchInsert(vector<int>& nums, int x) {
+        
+        int low = 0;
+        int high = nums.size();
+        
+        while(low<high)
+        {
+            int mid = low + (high-low)/2;
+            
+            if(nums[mid]==x)
+                return mid;
+            else if(nums[mid]>x)
+            {
+                high = mid;
+            }
+            else 
+                low = mid+1;
+        }
+        return low;
+        
+    }
+};
\ No newline at end of file
diff --git a/35-search-insert-position/NOTES.md b/35-search-insert-position/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/35-search-insert-position/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/35-search-insert-position/README.md b/35-search-insert-position/README.md
new file mode 100644
index 0000000..2aebf3d
--- /dev/null
+++ b/35-search-insert-position/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/search-insert-position/">35. Search Insert Position</a></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/37-sudoku-solver/NOTES.md b/37-sudoku-solver/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/37-sudoku-solver/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/37-sudoku-solver/README.md b/37-sudoku-solver/README.md
new file mode 100644
index 0000000..93d9b28
--- /dev/null
+++ b/37-sudoku-solver/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/sudoku-solver/">37. Sudoku Solver</a></h2><h3>Hard</h3><hr><div><p>Write a program to solve a Sudoku puzzle by filling the empty cells.</p>
+
+<p>A sudoku solution must satisfy <strong>all of the following rules</strong>:</p>
+
+<ol>
+	<li>Each of the digits <code>1-9</code> must occur exactly once in each row.</li>
+	<li>Each of the digits <code>1-9</code> must occur exactly once in each column.</li>
+	<li>Each of the digits <code>1-9</code> must occur exactly once in each of the 9 <code>3x3</code> sub-boxes of the grid.</li>
+</ol>
+
+<p>The <code>'.'</code> character indicates empty cells.</p>
+
+<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> [["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]]
+<strong>Explanation:</strong>&nbsp;The input board is shown above and the only valid solution is shown below:
+
+<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/Sudoku-by-L2G-20050714_solution.svg/250px-Sudoku-by-L2G-20050714_solution.svg.png" style="height:250px; width:250px">
+</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 or <code>'.'</code>.</li>
+	<li>It is <strong>guaranteed</strong> that the input board has only one solution.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/38-count-and-say/38-count-and-say.cpp b/38-count-and-say/38-count-and-say.cpp
new file mode 100644
index 0000000..4b2b3d6
--- /dev/null
+++ b/38-count-and-say/38-count-and-say.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+   string countAndSay(int n) {
+    if (n == 0) return "";
+    string res = "1";
+    while (--n) {
+        string cur = "";
+        for (int i = 0; i < res.size(); i++) {
+            int count = 1;
+             while ((i + 1 < res.size()) && (res[i] == res[i + 1])){
+                count++;    
+                i++;
+            }
+            cur += to_string(count) + res[i];
+        }
+        res = cur;
+    }
+    return res;
+}
+};
\ No newline at end of file
diff --git a/38-count-and-say/NOTES.md b/38-count-and-say/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/38-count-and-say/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/38-count-and-say/README.md b/38-count-and-say/README.md
new file mode 100644
index 0000000..41f82ca
--- /dev/null
+++ b/38-count-and-say/README.md
@@ -0,0 +1,39 @@
+<h2><a href="https://leetcode.com/problems/count-and-say/">38. Count and Say</a></h2><h3>Medium</h3><hr><div><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) = "1"</code></li>
+	<li><code>countAndSay(n)</code> is the way you would "say" the digit string from <code>countAndSay(n-1)</code>, which is then converted into a different digit string.</li>
+</ul>
+
+<p>To determine how you "say" a digit string, split it into the <strong>minimal</strong> number of groups so that each group is a contiguous section all of the <strong>same character.</strong> Then for each group, say the number of characters, then say the character. To convert the saying into a digit string, replace the counts with a number and concatenate every saying.</p>
+
+<p>For example, the saying and conversion for digit string <code>"3322251"</code>:</p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/23/countandsay.jpg" style="width: 581px; height: 172px;">
+<p>Given a positive integer <code>n</code>, return <em>the </em><code>n<sup>th</sup></code><em> term of the <strong>count-and-say</strong> sequence</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> "1"
+<strong>Explanation:</strong> This is the base case.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> "1211"
+<strong>Explanation:</strong>
+countAndSay(1) = "1"
+countAndSay(2) = say "1" = one 1 = "11"
+countAndSay(3) = say "11" = two 1's = "21"
+countAndSay(4) = say "21" = one 2 + one 1 = "12" + "11" = "1211"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 30</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/382-linked-list-random-node/382-linked-list-random-node.cpp b/382-linked-list-random-node/382-linked-list-random-node.cpp
new file mode 100644
index 0000000..2937a60
--- /dev/null
+++ b/382-linked-list-random-node/382-linked-list-random-node.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+    map<int,ListNode*> mp;
+    Solution(ListNode* head) 
+    {
+        ListNode *temp = head;
+        int i=0;
+        while(temp)
+        {
+           mp[i++]=temp;
+           temp=temp->next;
+        }    
+    }
+
+    int getRandom() 
+    {
+        int n = mp.size();
+        return mp[rand()%n]->val;    
+    }
+};
\ No newline at end of file
diff --git a/382-linked-list-random-node/NOTES.md b/382-linked-list-random-node/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/382-linked-list-random-node/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/382-linked-list-random-node/README.md b/382-linked-list-random-node/README.md
new file mode 100644
index 0000000..c9cf37e
--- /dev/null
+++ b/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/389-find-the-difference/389-find-the-difference.cpp b/389-find-the-difference/389-find-the-difference.cpp
new file mode 100644
index 0000000..323cf4c
--- /dev/null
+++ b/389-find-the-difference/389-find-the-difference.cpp
@@ -0,0 +1,9 @@
+class Solution {
+public:
+    char findTheDifference(string s, string t) {
+        char r=0,g=8;
+        for(char c:s) r ^=c;
+        for(char c:t) r ^=c;
+        return r;
+    }
+};
\ No newline at end of file
diff --git a/389-find-the-difference/NOTES.md b/389-find-the-difference/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/389-find-the-difference/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/39-combination-sum/39-combination-sum.cpp b/39-combination-sum/39-combination-sum.cpp
new file mode 100644
index 0000000..5f366b7
--- /dev/null
+++ b/39-combination-sum/39-combination-sum.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    
+    void solve(vector<vector<int>> & ans, vector<int>& combi,vector<int>& candidates, int target,int idx)
+    {
+        if(idx == candidates.size())
+        {
+            if(target == 0)
+                ans.push_back(combi);
+            return ;
+        }
+        if(target >= candidates[idx])
+        {
+            combi.push_back(candidates[idx]);
+            solve(ans,combi,candidates,target-candidates[idx],idx);
+            combi.pop_back();
+        }
+        solve(ans,combi,candidates,target,idx+1);
+        return ;
+        
+    }
+    
+    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+        vector<vector<int>>  ans;
+        vector<int> combi;
+        solve(ans,combi,candidates,target,0);
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/39-combination-sum/NOTES.md b/39-combination-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/39-combination-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/39-combination-sum/README.md b/39-combination-sum/README.md
new file mode 100644
index 0000000..29193a3
--- /dev/null
+++ b/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/394-decode-string/NOTES.md b/394-decode-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/394-decode-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/394-decode-string/README.md b/394-decode-string/README.md
new file mode 100644
index 0000000..da6322f
--- /dev/null
+++ b/394-decode-string/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/decode-string/">394. Decode String</a></h2><h3>Medium</h3><hr><div><p>Given an encoded string, return its decoded string.</p>
+
+<p>The encoding rule is: <code>k[encoded_string]</code>, where the <code>encoded_string</code> inside the square brackets is being repeated exactly <code>k</code> times. Note that <code>k</code> is guaranteed to be a positive integer.</p>
+
+<p>You may assume that the input string is always valid; there are no extra white spaces, square brackets are well-formed, etc. Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, <code>k</code>. For example, there will not be input like <code>3a</code> or <code>2[4]</code>.</p>
+
+<p>The test cases are generated so that the length of the output will never exceed <code>10<sup>5</sup></code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "3[a]2[bc]"
+<strong>Output:</strong> "aaabcbc"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "3[a2[c]]"
+<strong>Output:</strong> "accaccacc"
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "2[abc]3[cd]ef"
+<strong>Output:</strong> "abcabccdcdcdef"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 30</code></li>
+	<li><code>s</code> consists of lowercase English letters, digits, and square brackets <code>'[]'</code>.</li>
+	<li><code>s</code> is guaranteed to be <strong>a valid</strong> input.</li>
+	<li>All the integers in <code>s</code> are in the range <code>[1, 300]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/397-integer-replacement/397-integer-replacement.cpp b/397-integer-replacement/397-integer-replacement.cpp
new file mode 100644
index 0000000..847936f
--- /dev/null
+++ b/397-integer-replacement/397-integer-replacement.cpp
@@ -0,0 +1,28 @@
+class Solution 
+{
+    int res = 0;
+public:
+    int integerReplacement(int n) 
+    {
+        if (n == 1)
+            return res;
+        if (n == 3)
+        {
+            res += 2;
+            return res;
+        }
+        if (n == INT_MAX)
+            return 32;
+        
+        res ++;
+        if (n & 1)
+            if ((n + 1) % 4 == 0)
+                integerReplacement(n + 1);
+            else
+                integerReplacement(n - 1);
+        else
+            integerReplacement(n / 2);
+            
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/397-integer-replacement/NOTES.md b/397-integer-replacement/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/397-integer-replacement/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/397-integer-replacement/README.md b/397-integer-replacement/README.md
new file mode 100644
index 0000000..a3b6f96
--- /dev/null
+++ b/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/3sum-closest/3sum-closest.cpp b/3sum-closest/3sum-closest.cpp
new file mode 100644
index 0000000..79ba3ab
--- /dev/null
+++ b/3sum-closest/3sum-closest.cpp
@@ -0,0 +1,31 @@
+class Solution {
+public:
+    
+    int threeSumClosest(vector<int>& nums, int target) {
+        
+        sort(nums.begin(), nums.end());
+        
+        int fix = 0 ;
+        int tmp = nums[0]+nums[1]+nums[2] ;
+        
+        while( fix < nums.size() - 2 ){
+            
+            int left = fix + 1;
+            int right = nums.size() - 1 ;
+            
+            while ( left < right ){
+                
+                int sum = nums[fix] + nums[left] + nums[right];
+                if ( abs(sum-target) < abs(tmp-target) ) tmp = sum;
+                if ( sum > target ) right -= 1;
+                else if ( sum < target ) left += 1;
+                else return target;
+                
+            }
+            
+            fix += 1;
+            
+        }
+        return tmp;
+    }
+};
\ No newline at end of file
diff --git a/3sum-closest/README.md b/3sum-closest/README.md
new file mode 100644
index 0000000..8508c79
--- /dev/null
+++ b/3sum-closest/README.md
@@ -0,0 +1,19 @@
+<h2>16. 3Sum Closest</h2><h3>Medium</h3><hr><div><p>Given an array <code>nums</code> of <em>n</em> integers and an integer <code>target</code>, find three integers in <code>nums</code>&nbsp;such that the sum is closest to&nbsp;<code>target</code>. Return the sum of the three integers. You may assume that each input would have exactly one solution.</p>
+
+<p>&nbsp;</p>
+<p><strong>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>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= nums.length &lt;= 10^3</code></li>
+	<li><code>-10^3&nbsp;&lt;= nums[i]&nbsp;&lt;= 10^3</code></li>
+	<li><code>-10^4&nbsp;&lt;= target&nbsp;&lt;= 10^4</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/3sum/3sum.cpp b/3sum/3sum.cpp
new file mode 100644
index 0000000..bbf3fe3
--- /dev/null
+++ b/3sum/3sum.cpp
@@ -0,0 +1,50 @@
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        
+         vector<vector<int>> ans;
+        if(nums.size() <=2)return ans;
+        
+        sort(nums.begin(),nums.end());
+        
+        for(int i=0;i<nums.size()-2;i++)
+        {
+            if(i == 0 || nums[i] != nums[i-1])
+            {
+                int low = i+1;
+                int high = nums.size()-1;
+                int sum = 0 - nums[i];
+                
+                while(low<high)
+                {
+                    int currsum = nums[low] + nums[high];
+                    if(currsum == sum)
+                    {
+                        vector <int> temp(3);
+                        temp[0] = nums[i];
+                        temp[1]= nums[low];
+                        temp[2]= nums[high];
+                        ans.push_back(temp); 
+                        
+                        
+                    while(high>low && nums[low] == nums[low+1])low++;
+                    while(high>low && nums[high] == nums[high-1])high--;
+                    
+                    low++;
+                    high--;
+                    }
+                    else if(currsum>sum)
+                    {
+                        high--;
+                    }
+                    else
+                    {
+                        low++;
+                    }
+                    
+                }  
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/3sum/README.md b/3sum/README.md
new file mode 100644
index 0000000..daa2f94
--- /dev/null
+++ b/3sum/README.md
@@ -0,0 +1,23 @@
+<h2>15. 3Sum</h2><h3>Medium</h3><hr><div><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>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [-1,0,1,2,-1,-4]
+<strong>Output:</strong> [[-1,-1,2],[-1,0,1]]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = []
+<strong>Output:</strong> []
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [0]
+<strong>Output:</strong> []
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= nums.length &lt;= 3000</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/4-median-of-two-sorted-arrays/4-median-of-two-sorted-arrays.cpp b/4-median-of-two-sorted-arrays/4-median-of-two-sorted-arrays.cpp
new file mode 100644
index 0000000..4395d47
--- /dev/null
+++ b/4-median-of-two-sorted-arrays/4-median-of-two-sorted-arrays.cpp
@@ -0,0 +1,47 @@
+class Solution {
+public:
+    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+        
+        if(nums1.size()>nums2.size())
+        {
+            return findMedianSortedArrays(nums2,nums1);
+        }
+          int n = nums1.size();
+        int m = nums2.size();
+        
+        int mid = (n+m+1)/2;
+        int low = 0;
+        int high = n;
+        
+      
+        
+        while(low<=high)
+        {
+            int cut1 = (low+high)/2;
+            int cut2 = (n+m+1)/2 - cut1;
+            
+            int l1 = cut1 == 0 ? INT_MIN : nums1[cut1-1];
+            int l2 = cut2 == 0 ? INT_MIN : nums2[cut2-1];
+            
+            int r1 = cut1 == n ? INT_MAX : nums1[cut1];
+            int r2 = cut2 == m ? INT_MAX : nums2[cut2];
+            
+            if(l1<=r2 && l2<=r1)
+            {
+                if((n + m) % 2 == 0)
+                    return (max(l1,l2) + min(r1,r2) )/ 2.0;
+                else
+                    return max(l1,l2);
+            }
+            else if(l1>r2)
+            {
+                high = cut1 - 1;
+            }
+            else
+                low = cut1 + 1;
+            
+        }
+        return 0.0;
+        
+    }
+};
\ No newline at end of file
diff --git a/4-median-of-two-sorted-arrays/NOTES.md b/4-median-of-two-sorted-arrays/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/4-median-of-two-sorted-arrays/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/4-median-of-two-sorted-arrays/README.md b/4-median-of-two-sorted-arrays/README.md
new file mode 100644
index 0000000..c5835f0
--- /dev/null
+++ b/4-median-of-two-sorted-arrays/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/median-of-two-sorted-arrays/">4. Median of Two Sorted Arrays</a></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>&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/40-combination-sum-ii/40-combination-sum-ii.cpp b/40-combination-sum-ii/40-combination-sum-ii.cpp
new file mode 100644
index 0000000..57c66ef
--- /dev/null
+++ b/40-combination-sum-ii/40-combination-sum-ii.cpp
@@ -0,0 +1,30 @@
+class Solution {
+public:
+    
+    void helper(vector<int>& candidates, int target,vector<vector<int>> & ans,vector<int> &temp,int i)
+    {
+        if(target == 0)
+        {
+         ans.push_back(temp);
+         return;  
+        }
+   
+        for(int j = i;j<candidates.size();j++)
+        {
+            if(j>i && candidates[j] == candidates[j-1])continue;
+            if(candidates[j]>target)break;
+            temp.push_back(candidates[j]);
+            helper(candidates,target-candidates[j],ans,temp,j+1);
+            temp.pop_back();
+        }
+    }
+    
+    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
+        sort(candidates.begin(),candidates.end());
+        vector<vector<int>> ans;
+        vector<int> temp;
+        helper(candidates,target,ans,temp,0);
+        return ans;
+        
+    }
+};
\ No newline at end of file
diff --git a/40-combination-sum-ii/NOTES.md b/40-combination-sum-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/40-combination-sum-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/40-combination-sum-ii/README.md b/40-combination-sum-ii/README.md
new file mode 100644
index 0000000..74334e9
--- /dev/null
+++ b/40-combination-sum-ii/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/combination-sum-ii/">40. Combination Sum II</a></h2><h3>Medium</h3><hr><div><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>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>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>
+</div>
\ No newline at end of file
diff --git a/402-remove-k-digits/402-remove-k-digits.cpp b/402-remove-k-digits/402-remove-k-digits.cpp
new file mode 100644
index 0000000..9acfdbb
--- /dev/null
+++ b/402-remove-k-digits/402-remove-k-digits.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    string removeKdigits(string num, int k) {
+       string ans = "";                                         // treat ans as a stack in below for loop
+       
+       for (char c : num) {
+           while (ans.length() && ans.back() > c && k) {
+               ans.pop_back();                                  // make sure digits in ans are in ascending order
+               k--;                                             // remove one char
+           }
+           
+           if (ans.length() || c != '0') { ans.push_back(c); }  // can't have leading '0'
+       }
+       
+       while (ans.length() && k--) { ans.pop_back(); }          // make sure remove k digits in total
+       
+       return ans.empty() ? "0" : ans;
+    }
+};
\ No newline at end of file
diff --git a/402-remove-k-digits/NOTES.md b/402-remove-k-digits/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/402-remove-k-digits/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/402-remove-k-digits/README.md b/402-remove-k-digits/README.md
new file mode 100644
index 0000000..e341214
--- /dev/null
+++ b/402-remove-k-digits/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/remove-k-digits/">402. Remove K Digits</a></h2><h3>Medium</h3><hr><div><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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = "1432219", k = 3
+<strong>Output:</strong> "1219"
+<strong>Explanation:</strong> Remove the three digits 4, 3, and 2 to form the new number 1219 which is the smallest.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = "10200", k = 1
+<strong>Output:</strong> "200"
+<strong>Explanation:</strong> Remove the leading 1 and the number is 200. Note that the output must not contain leading zeroes.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> num = "10", k = 2
+<strong>Output:</strong> "0"
+<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>
+</div>
\ No newline at end of file
diff --git a/410-split-array-largest-sum/410-split-array-largest-sum.cpp b/410-split-array-largest-sum/410-split-array-largest-sum.cpp
new file mode 100644
index 0000000..3aa6cda
--- /dev/null
+++ b/410-split-array-largest-sum/410-split-array-largest-sum.cpp
@@ -0,0 +1,53 @@
+class Solution {
+public:
+    int minimumSubarraysRequired(vector<int>& nums, int maxSumAllowed) {
+        int currentSum = 0;
+        int splitsRequired = 0;
+        
+        for (int element : nums) {
+            // Add element only if the sum doesn't exceed maxSumAllowed
+            if (currentSum + element <= maxSumAllowed) {
+                currentSum += element;
+            } else {
+                // If the element addition makes sum more than maxSumAllowed
+                // Increment the splits required and reset sum
+                currentSum = element;
+                splitsRequired++;
+            }
+        }
+        
+        // Return the number of subarrays, which is the number of splits + 1
+        return splitsRequired + 1;
+    }
+    
+    int splitArray(vector<int>& nums, int m) {
+        // Find the sum of all elements and the maximum element
+        int sum = 0;
+        int maxElement = INT_MIN;
+        for (int element : nums) {
+            sum += element;
+            maxElement = max(maxElement, element);
+        }
+        
+        // Define the left and right boundary of binary search
+        int left = maxElement;
+        int right = sum;
+        int minimumLargestSplitSum = 0;
+        while (left <= right) {
+            // Find the mid value
+            int maxSumAllowed = (left + right) / 2;
+            
+            // Find the minimum splits. If splitsRequired is less than
+            // or equal to m move towards left i.e., smaller values
+            if (minimumSubarraysRequired(nums, maxSumAllowed) <= m) {
+                right = maxSumAllowed - 1;
+                minimumLargestSplitSum = maxSumAllowed;
+            } else {
+                // Move towards right if splitsRequired is more than m
+                left = maxSumAllowed + 1;
+            }
+        }
+        
+        return minimumLargestSplitSum;
+    }
+};
\ No newline at end of file
diff --git a/410-split-array-largest-sum/NOTES.md b/410-split-array-largest-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/410-split-array-largest-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/410-split-array-largest-sum/README.md b/410-split-array-largest-sum/README.md
new file mode 100644
index 0000000..e7a820a
--- /dev/null
+++ b/410-split-array-largest-sum/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/split-array-largest-sum/">410. Split Array Largest Sum</a></h2><h3>Hard</h3><hr><div><p>Given an array <code>nums</code> which consists of non-negative integers and an integer <code>m</code>, you can split the array into <code>m</code> non-empty continuous subarrays.</p>
+
+<p>Write an algorithm to minimize the largest sum among these <code>m</code> subarrays.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [7,2,5,10,8], m = 2
+<strong>Output:</strong> 18
+<strong>Explanation:</strong>
+There are four ways to split nums into two subarrays.
+The best way is to split it into [7,2,5] and [10,8],
+where the largest sum among the two subarrays is only 18.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,5], m = 2
+<strong>Output:</strong> 9
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,4,4], m = 3
+<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;= 10<sup>6</sup></code></li>
+	<li><code>1 &lt;= m &lt;= min(50, nums.length)</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/415-add-strings/NOTES.md b/415-add-strings/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/415-add-strings/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/415-add-strings/README.md b/415-add-strings/README.md
new file mode 100644
index 0000000..19e7bff
--- /dev/null
+++ b/415-add-strings/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/add-strings/">415. Add Strings</a></h2><h3>Easy</h3><hr><div><p>Given two non-negative integers, <code>num1</code> and <code>num2</code> represented as string, return <em>the sum of</em> <code>num1</code> <em>and</em> <code>num2</code> <em>as a string</em>.</p>
+
+<p>You must solve the problem without using any built-in library for handling large integers (such as <code>BigInteger</code>). You must also not convert the inputs to integers directly.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num1 = "11", num2 = "123"
+<strong>Output:</strong> "134"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num1 = "456", num2 = "77"
+<strong>Output:</strong> "533"
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> num1 = "0", num2 = "0"
+<strong>Output:</strong> "0"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= num1.length, num2.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>num1</code> and <code>num2</code> consist of only digits.</li>
+	<li><code>num1</code> and <code>num2</code> don't have any leading zeros except for the zero itself.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/416-partition-equal-subset-sum/416-partition-equal-subset-sum.cpp b/416-partition-equal-subset-sum/416-partition-equal-subset-sum.cpp
new file mode 100644
index 0000000..ab23d9f
--- /dev/null
+++ b/416-partition-equal-subset-sum/416-partition-equal-subset-sum.cpp
@@ -0,0 +1,38 @@
+class Solution {
+public:
+    
+    bool canMakeSubset(vector<int>& nums,int target)
+    {
+        int n = nums.size();
+        vector<vector<int>> dp(n,vector<int> (target+1,0));
+        
+        for(int i=0;i<n;i++) dp[i][0] = 1;
+        if(target >= nums[0]) dp[0][nums[0]] = 1;
+        
+        for(int i=1;i<n;i++)
+        {
+            for(int j=1;j<=target;j++)
+            {
+                int take = 0;
+                if(nums[i]<= j)
+                    take = dp[i-1][j-nums[i]];
+                int nottake = dp[i-1][j];
+                
+                dp[i][j] = take|nottake;
+            }
+        }
+        return dp[n-1][target];
+        
+    }
+    
+    
+    bool canPartition(vector<int>& nums) {
+        int sum = 0;
+        for(auto a:nums) sum += a;
+        if(sum % 2 == 1 )return false;
+        
+        sum /= 2;
+        
+        return canMakeSubset(nums,sum);
+    }
+};
\ No newline at end of file
diff --git a/416-partition-equal-subset-sum/NOTES.md b/416-partition-equal-subset-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/416-partition-equal-subset-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/416-partition-equal-subset-sum/README.md b/416-partition-equal-subset-sum/README.md
new file mode 100644
index 0000000..4da8a6d
--- /dev/null
+++ b/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/42-trapping-rain-water/42-trapping-rain-water.cpp b/42-trapping-rain-water/42-trapping-rain-water.cpp
new file mode 100644
index 0000000..0a12e9b
--- /dev/null
+++ b/42-trapping-rain-water/42-trapping-rain-water.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int trap(vector<int>& nums) {
+        
+        int ans = 0;
+        int n = nums.size();
+        vector<int> left(n);
+        vector<int> right(n);
+        int lmaxi = 0;
+        int rmaxi = 0;
+        for(int i=0;i<nums.size();i++)
+        {
+            left[i] = lmaxi = max(lmaxi,nums[i]);
+            right[n-1-i]  = rmaxi = max(rmaxi,nums[n-i-1]);
+        }
+        
+        for(int i=0;i<nums.size();i++)
+        {
+            ans += min(left[i],right[i]) - nums[i];
+        }
+        return ans;
+      
+    }
+};
\ No newline at end of file
diff --git a/42-trapping-rain-water/NOTES.md b/42-trapping-rain-water/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/42-trapping-rain-water/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/421-maximum-xor-of-two-numbers-in-an-array/421-maximum-xor-of-two-numbers-in-an-array.cpp b/421-maximum-xor-of-two-numbers-in-an-array/421-maximum-xor-of-two-numbers-in-an-array.cpp
new file mode 100644
index 0000000..94db595
--- /dev/null
+++ b/421-maximum-xor-of-two-numbers-in-an-array/421-maximum-xor-of-two-numbers-in-an-array.cpp
@@ -0,0 +1,22 @@
+class Solution {
+private:
+    int helper(vector<int>& nums, int lb, int le, int rb, int re, int val, int bit){
+        if(lb==le || re==rb) return 0;
+        if(bit==-1) return val;
+        int mask = 1 << bit, j = lb, k = rb;
+        // quicksort-like partition according to current bit
+        for(int i=lb; i<le; i++)
+            if(nums[i]&mask) swap(nums[i], nums[j++]);
+        for(int i=rb; i<re; i++)
+            if(nums[i]&mask) swap(nums[i], nums[k++]);
+        // if there is valid xor between the left half and right half, current bit = 1
+        int ret = max(helper(nums, j, le, rb, k, (val<<1)+1, bit-1), 
+                      helper(nums, lb, j, k, re, (val<<1)+1, bit-1));
+        // else current bit = 0
+        return ret>0? ret: helper(nums, lb, le, rb, re, val<<1, bit-1);
+    }
+public:
+    int findMaximumXOR(vector<int>& nums) {
+        return helper(nums, 0, nums.size(), 0, nums.size(), 0, 30);
+    }
+};
\ No newline at end of file
diff --git a/421-maximum-xor-of-two-numbers-in-an-array/NOTES.md b/421-maximum-xor-of-two-numbers-in-an-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/421-maximum-xor-of-two-numbers-in-an-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/438-find-all-anagrams-in-a-string/438-find-all-anagrams-in-a-string.cpp b/438-find-all-anagrams-in-a-string/438-find-all-anagrams-in-a-string.cpp
new file mode 100644
index 0000000..d0cc24f
--- /dev/null
+++ b/438-find-all-anagrams-in-a-string/438-find-all-anagrams-in-a-string.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    vector<int> findAnagrams(string s, string p) {
+        int s_len = s.length();
+        int p_len = p.length();
+        
+        if(s.size() < p.size()) return {};
+        
+        vector<int> freq_p(26,0);
+        vector<int> window(26,0);
+        
+        //first window
+        for(int i=0;i<p_len;i++){
+            freq_p[p[i]-'a']++;
+            window[s[i]-'a']++;
+        }
+        
+        vector<int> ans;
+        if(freq_p == window) ans.push_back(0);
+        
+        for(int i=p_len;i<s_len;i++){
+            window[s[i-p_len] - 'a']--;
+            window[s[i] - 'a']++;
+            
+            if(freq_p == window) ans.push_back(i-p_len+1);
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/438-find-all-anagrams-in-a-string/NOTES.md b/438-find-all-anagrams-in-a-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/438-find-all-anagrams-in-a-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/438-find-all-anagrams-in-a-string/README.md b/438-find-all-anagrams-in-a-string/README.md
new file mode 100644
index 0000000..b599121
--- /dev/null
+++ b/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/442-find-all-duplicates-in-an-array/442-find-all-duplicates-in-an-array.cpp b/442-find-all-duplicates-in-an-array/442-find-all-duplicates-in-an-array.cpp
new file mode 100644
index 0000000..1670e74
--- /dev/null
+++ b/442-find-all-duplicates-in-an-array/442-find-all-duplicates-in-an-array.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    vector<int> findDuplicates(vector<int>& nums) {
+        vector<int> ans;
+        
+        for(int i=0;i<nums.size();i++)
+        {
+            if(nums[abs(nums[i])-1] < 0 )
+            {
+                ans.push_back(abs(nums[i]));
+            }
+            nums[abs(nums[i])-1]  *= -1;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/442-find-all-duplicates-in-an-array/NOTES.md b/442-find-all-duplicates-in-an-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/442-find-all-duplicates-in-an-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/442-find-all-duplicates-in-an-array/README.md b/442-find-all-duplicates-in-an-array/README.md
new file mode 100644
index 0000000..7509708
--- /dev/null
+++ b/442-find-all-duplicates-in-an-array/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/find-all-duplicates-in-an-array/">442. Find All Duplicates in an Array</a></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/45-jump-game-ii/45-jump-game-ii.cpp b/45-jump-game-ii/45-jump-game-ii.cpp
new file mode 100644
index 0000000..754547a
--- /dev/null
+++ b/45-jump-game-ii/45-jump-game-ii.cpp
@@ -0,0 +1,25 @@
+class Solution {
+public:
+    long long int solve(vector<int>& nums,int i,vector<int>& dp)
+    {
+        if(i >= (nums.size()-1))
+        {  
+            return dp[i] = 0;
+        }
+            
+        if(dp[i] != -1)return dp[i];
+                
+        long long int ans = INT_MAX;
+        for(int j=1;j<=nums[i];j++)
+            if(i+j<nums.size())
+                ans = min(ans, 1 + solve(nums,i+j,dp));
+        return dp[i] = ans;
+    }
+    
+    int jump(vector<int>& nums) {
+        
+        vector<int> dp(nums.size(),-1);
+        long long int ans = solve(nums,0.,dp);
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/45-jump-game-ii/NOTES.md b/45-jump-game-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/45-jump-game-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/45-jump-game-ii/README.md b/45-jump-game-ii/README.md
new file mode 100644
index 0000000..6bfdc0c
--- /dev/null
+++ b/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/454-4sum-ii/454-4sum-ii.cpp b/454-4sum-ii/454-4sum-ii.cpp
new file mode 100644
index 0000000..b86a1eb
--- /dev/null
+++ b/454-4sum-ii/454-4sum-ii.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
+        
+        unordered_map<int,int> ump;
+        int count=0;
+        
+        for(auto &x : nums1){
+            for(auto &y: nums2){
+                ump[x+y]++;
+            }
+        }
+        
+        for(auto &x : nums3){
+            for(auto &y: nums4){
+                int sum = (x+y)*-1;
+                if(ump.find(sum) != ump.end()) count+=ump[sum];
+            }
+        }
+        
+       return count;
+    }
+};
\ No newline at end of file
diff --git a/454-4sum-ii/NOTES.md b/454-4sum-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/454-4sum-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/454-4sum-ii/README.md b/454-4sum-ii/README.md
new file mode 100644
index 0000000..2ad6c2c
--- /dev/null
+++ b/454-4sum-ii/README.md
@@ -0,0 +1,36 @@
+<h2><a href="https://leetcode.com/problems/4sum-ii/">454. 4Sum II</a></h2><h3>Medium</h3><hr><div><p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
+
+<ul>
+	<li><code>0 &lt;= i, j, k, l &lt; n</code></li>
+	<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+The two tuples are:
+1. (0, 0, 0, 1) -&gt; nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
+2. (1, 1, 0, 0) -&gt; nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums1.length</code></li>
+	<li><code>n == nums2.length</code></li>
+	<li><code>n == nums3.length</code></li>
+	<li><code>n == nums4.length</code></li>
+	<li><code>1 &lt;= n &lt;= 200</code></li>
+	<li><code>-2<sup>28</sup> &lt;= nums1[i], nums2[i], nums3[i], nums4[i] &lt;= 2<sup>28</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/458-poor-pigs/NOTES.md b/458-poor-pigs/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/458-poor-pigs/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/458-poor-pigs/README.md b/458-poor-pigs/README.md
new file mode 100644
index 0000000..4f1782e
--- /dev/null
+++ b/458-poor-pigs/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/poor-pigs/">458. Poor Pigs</a></h2><h3>Hard</h3><hr><div><p>There are <code>buckets</code> buckets of liquid, where <strong>exactly one</strong> of the buckets is poisonous. To figure out which one is poisonous, you feed some number of (poor) pigs the liquid to see whether they will die or not. Unfortunately, you only have <code>minutesToTest</code> minutes to determine which bucket is poisonous.</p>
+
+<p>You can feed the pigs according to these steps:</p>
+
+<ol>
+	<li>Choose some live pigs to feed.</li>
+	<li>For each pig, choose which buckets to feed it. The pig will consume all the chosen buckets simultaneously and will take no time.</li>
+	<li>Wait for <code>minutesToDie</code> minutes. You may <strong>not</strong> feed any other pigs during this time.</li>
+	<li>After <code>minutesToDie</code> minutes have passed, any pigs that have been fed the poisonous bucket will die, and all others will survive.</li>
+	<li>Repeat this process until you run out of time.</li>
+</ol>
+
+<p>Given <code>buckets</code>, <code>minutesToDie</code>, and <code>minutesToTest</code>, return <em>the <strong>minimum</strong> number of pigs needed to figure out which bucket is poisonous within the allotted time</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> buckets = 1000, minutesToDie = 15, minutesToTest = 60
+<strong>Output:</strong> 5
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> buckets = 4, minutesToDie = 15, minutesToTest = 15
+<strong>Output:</strong> 2
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> buckets = 4, minutesToDie = 15, minutesToTest = 30
+<strong>Output:</strong> 2
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= buckets &lt;= 1000</code></li>
+	<li><code>1 &lt;=&nbsp;minutesToDie &lt;=&nbsp;minutesToTest &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/46-permutations/46-permutations.cpp b/46-permutations/46-permutations.cpp
new file mode 100644
index 0000000..0ecac8e
--- /dev/null
+++ b/46-permutations/46-permutations.cpp
@@ -0,0 +1,27 @@
+class Solution {
+public:
+    
+    
+    void helper(vector<vector<int>> & ans,vector<int>& nums,int index)
+    {
+        if(index == nums.size())
+        {
+            ans.push_back(nums);
+            return ;
+        }
+        
+        for(int i=index;i<nums.size();i++)
+        {
+            swap(nums[index],nums[i]);
+            helper(ans,nums,index+1);
+            swap(nums[index],nums[i]);
+        }
+        
+    }
+    
+    vector<vector<int>> permute(vector<int>& nums) {
+        vector<vector<int>> ans;
+        helper(ans,nums,0);
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/46-permutations/NOTES.md b/46-permutations/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/46-permutations/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/46-permutations/README.md b/46-permutations/README.md
new file mode 100644
index 0000000..975206f
--- /dev/null
+++ b/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/472-concatenated-words/472-concatenated-words.cpp b/472-concatenated-words/472-concatenated-words.cpp
new file mode 100644
index 0000000..f495697
--- /dev/null
+++ b/472-concatenated-words/472-concatenated-words.cpp
@@ -0,0 +1,32 @@
+class Solution {
+public:
+    
+    bool canform(string s,unordered_map<string,int> & mp)
+    {
+        for(int i=1;i<s.size();i++)
+        {
+            string left = s.substr(0,i);
+            string right = s.substr(i);
+            
+            if(mp.count(left))
+                if((mp.count(right) || canform(right,mp)))
+                    return true;
+        }
+        return false;
+    }
+    
+    vector<string> findAllConcatenatedWordsInADict(vector<string>& words) {
+        vector<string> ans;
+        unordered_map<string,int> mp;
+        
+        for(int i=0;i<words.size();i++)
+            mp[words[i]]++;
+        
+        for(int i=0;i<words.size();i++)
+        {
+            if(canform(words[i],mp))
+                ans.push_back(words[i]);
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/472-concatenated-words/NOTES.md b/472-concatenated-words/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/472-concatenated-words/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/472-concatenated-words/README.md b/472-concatenated-words/README.md
new file mode 100644
index 0000000..ee73fb3
--- /dev/null
+++ b/472-concatenated-words/README.md
@@ -0,0 +1,30 @@
+<h2><a href="https://leetcode.com/problems/concatenated-words/">472. Concatenated Words</a></h2><h3>Hard</h3><hr><div><p>Given an array of strings <code>words</code> (<strong>without duplicates</strong>), return <em>all the <strong>concatenated words</strong> in the given list of</em> <code>words</code>.</p>
+
+<p>A <strong>concatenated word</strong> is defined as a string that is comprised entirely of at least two shorter words in the given array.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> words = ["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamuses","rat","ratcatdogcat"]
+<strong>Output:</strong> ["catsdogcats","dogcatsdog","ratcatdogcat"]
+<strong>Explanation:</strong> "catsdogcats" can be concatenated by "cats", "dog" and "cats"; 
+"dogcatsdog" can be concatenated by "dog", "cats" and "dog"; 
+"ratcatdogcat" can be concatenated by "rat", "cat", "dog" and "cat".</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words = ["cat","dog","catdog"]
+<strong>Output:</strong> ["catdog"]
+</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;= words[i].length &lt;= 30</code></li>
+	<li><code>words[i]</code> consists of only lowercase English letters.</li>
+	<li>All the strings of <code>words</code> are <strong>unique</strong>.</li>
+	<li><code>1 &lt;= sum(words[i].length) &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/48-rotate-image/48-rotate-image.cpp b/48-rotate-image/48-rotate-image.cpp
new file mode 100644
index 0000000..59a87f7
--- /dev/null
+++ b/48-rotate-image/48-rotate-image.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    void rotate(vector<vector<int>>& matrix) {
+        
+        for(int i=0;i<matrix.size();i++)
+        {
+            for(int j=i;j<matrix[0].size();j++)
+            {
+                swap(matrix[i][j],matrix[j][i]);
+            }
+        }
+        
+        for(int i=0;i<matrix.size();i++)
+        {
+            reverse(matrix[i].begin(),matrix[i].end());
+        }
+        
+    }
+};
\ No newline at end of file
diff --git a/48-rotate-image/NOTES.md b/48-rotate-image/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/48-rotate-image/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/48-rotate-image/README.md b/48-rotate-image/README.md
new file mode 100644
index 0000000..3781a8d
--- /dev/null
+++ b/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/485-max-consecutive-ones/485-max-consecutive-ones.cpp b/485-max-consecutive-ones/485-max-consecutive-ones.cpp
new file mode 100644
index 0000000..90f735c
--- /dev/null
+++ b/485-max-consecutive-ones/485-max-consecutive-ones.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int findMaxConsecutiveOnes(vector<int>& nums) {
+        int maxi = 0;
+        int curr_max = 0;
+        
+        for(int i=0;i<nums.size();i++)
+        {
+          if(nums[i] == 1)
+          {
+              curr_max++;
+              maxi = max(maxi,curr_max);
+          }
+          else
+          {
+              curr_max = 0;
+          }
+        }
+        return maxi;
+    }
+};
\ No newline at end of file
diff --git a/485-max-consecutive-ones/README.md b/485-max-consecutive-ones/README.md
new file mode 100644
index 0000000..d539eb5
--- /dev/null
+++ b/485-max-consecutive-ones/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/max-consecutive-ones/">485. Max Consecutive Ones</a></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/49-group-anagrams/49-group-anagrams.cpp b/49-group-anagrams/49-group-anagrams.cpp
new file mode 100644
index 0000000..c08308c
--- /dev/null
+++ b/49-group-anagrams/49-group-anagrams.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+    vector<vector<string>> groupAnagrams(vector<string>& strs) {
+        unordered_map<string, vector<string>> m;
+        string tmp_sorted;
+        
+        for (auto word : strs) {
+            tmp_sorted = word;
+            sort(tmp_sorted.begin(), tmp_sorted.end());
+            m[tmp_sorted].push_back(word);
+        }
+        
+        vector<vector<string>> res;
+        for (auto [word, list] : m) {
+            res.push_back(list);
+        }
+        
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/49-group-anagrams/NOTES.md b/49-group-anagrams/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/49-group-anagrams/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/49-group-anagrams/README.md b/49-group-anagrams/README.md
new file mode 100644
index 0000000..63e431b
--- /dev/null
+++ b/49-group-anagrams/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/group-anagrams/">49. Group Anagrams</a></h2><h3>Medium</h3><hr><div><p>Given an array of strings <code>strs</code>, group <strong>the anagrams</strong> together. You can 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> strs = ["eat","tea","tan","ate","nat","bat"]
+<strong>Output:</strong> [["bat"],["nat","tan"],["ate","eat","tea"]]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> strs = [""]
+<strong>Output:</strong> [[""]]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> strs = ["a"]
+<strong>Output:</strong> [["a"]]
+</pre>
+<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>
+</div>
\ No newline at end of file
diff --git a/494-target-sum/494-target-sum.cpp b/494-target-sum/494-target-sum.cpp
new file mode 100644
index 0000000..300089f
--- /dev/null
+++ b/494-target-sum/494-target-sum.cpp
@@ -0,0 +1,79 @@
+class Solution {
+public:
+//      int solve(vector<int>& nums,int target)
+//     {
+//         int n = nums.size();
+//         vector<vector<int>> dp(n,vector<int> (target+1,0));
+        
+//        for(int i=0;i<n;i++){
+//             if(nums[0]==0)
+//                 dp[i][0] = 2;
+//             if(target == arr[0])
+//                 return 1;
+//             return 0;
+//         }
+//         if(target >= nums[0]) dp[0][nums[0]] = 1;
+        
+         
+//         for(int i=1;i<n;i++)
+//         {
+//             for(int j=1;j<=target;j++)
+//             {
+//                 int take = 0;
+//                 if(nums[i]<= j)
+//                     take = dp[i-1][j-nums[i]];
+//                 int nottake = dp[i-1][j];
+                
+//                 dp[i][j] = take+nottake;
+//             }
+//         }
+//        for(int i=0;i<n;i++)
+//         {
+//             for(int j=0;j<=target;j++)
+//             {
+//                 cout<<dp[i][j]<<" ";
+//             }
+//            cout<<endl;
+//        }
+// //          int ans =0;
+// //          for(int i=0;i<=target;i++)
+// //              if(dp[n-1][i] > 1)
+// //                  ans++;
+// //         return ans;
+//          return dp[n-1][target];
+//     }
+    int findWays(vector<int> &num, int tar){
+     int n = num.size();
+
+    vector<vector<int>> dp(n,vector<int>(tar+1,0));
+    
+    if(num[0] == 0) dp[0][0] =2;  // 2 cases -pick and not pick
+    else dp[0][0] = 1;  // 1 case - not pick
+    
+    if(num[0]!=0 && num[0]<=tar) dp[0][num[0]] = 1;  // 1 case -pick
+    
+    for(int ind = 1; ind<n; ind++){
+        for(int target= 0; target<=tar; target++){
+            
+            int notTaken = dp[ind-1][target];
+    
+            int taken = 0;
+                if(num[ind]<=target)
+                    taken = dp[ind-1][target-num[ind]];
+        
+            dp[ind][target]= (notTaken + taken);
+        }
+    }
+    return dp[n-1][tar];
+}
+    int findTargetSumWays(vector<int>& nums, int target) {
+        int sum = 0;
+        for(auto a:nums)sum += a;
+        
+        int tar = (sum - target) /2 ;
+        
+        if((sum - target) % 2 == 1 || sum - target < 0 )return 0;
+        sort(nums.begin(),nums.end());
+        return findWays(nums,tar);
+    }
+};
\ No newline at end of file
diff --git a/494-target-sum/NOTES.md b/494-target-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/494-target-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/494-target-sum/README.md b/494-target-sum/README.md
new file mode 100644
index 0000000..db8dbd4
--- /dev/null
+++ b/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/496-next-greater-element-i/496-next-greater-element-i.cpp b/496-next-greater-element-i/496-next-greater-element-i.cpp
new file mode 100644
index 0000000..5de3181
--- /dev/null
+++ b/496-next-greater-element-i/496-next-greater-element-i.cpp
@@ -0,0 +1,39 @@
+class Solution {
+public:
+    vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {
+        
+        unordered_map<int,int> m;
+        stack<int> s;
+        
+        for(int i=nums.size()-1;i>=0 ;i--)
+        {
+            while(!s.empty() && s.top() <= nums[i])
+                s.pop();
+            if(!s.empty())
+                m[nums[i]] = s.top();
+            else
+                m[nums[i]] = -1;
+            
+            s.push(nums[i]);
+        }
+        vector<int> ans;
+        for(int i=0;i<findNums.size();i++)
+        {
+            ans.push_back(m[findNums[i]]) ; 
+        }
+        
+        return ans;
+    }
+};
+
+        // stack<int> s;
+        // unordered_map<int, int> m;
+        // for (int n : nums) {
+        //     while (s.size() && s.top() < n) {
+        //         m[s.top()] = n;
+        //         s.pop();
+        //     }
+        //     s.push(n);
+        // }
+        // vector<int> ans;
+        // for (int n : findNums) ans.push_back(m.count(n) ? m[n] : -1);
\ No newline at end of file
diff --git a/496-next-greater-element-i/NOTES.md b/496-next-greater-element-i/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/496-next-greater-element-i/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/496-next-greater-element-i/README.md b/496-next-greater-element-i/README.md
new file mode 100644
index 0000000..a947674
--- /dev/null
+++ b/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/4sum-ii/4sum-ii.cpp b/4sum-ii/4sum-ii.cpp
new file mode 100644
index 0000000..b86a1eb
--- /dev/null
+++ b/4sum-ii/4sum-ii.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
+        
+        unordered_map<int,int> ump;
+        int count=0;
+        
+        for(auto &x : nums1){
+            for(auto &y: nums2){
+                ump[x+y]++;
+            }
+        }
+        
+        for(auto &x : nums3){
+            for(auto &y: nums4){
+                int sum = (x+y)*-1;
+                if(ump.find(sum) != ump.end()) count+=ump[sum];
+            }
+        }
+        
+       return count;
+    }
+};
\ No newline at end of file
diff --git a/4sum-ii/README.md b/4sum-ii/README.md
new file mode 100644
index 0000000..dbc11c9
--- /dev/null
+++ b/4sum-ii/README.md
@@ -0,0 +1,36 @@
+<h2>454. 4Sum II</h2><h3>Medium</h3><hr><div><p>Given four integer arrays <code>nums1</code>, <code>nums2</code>, <code>nums3</code>, and <code>nums4</code> all of length <code>n</code>, return the number of tuples <code>(i, j, k, l)</code> such that:</p>
+
+<ul>
+	<li><code>0 &lt;= i, j, k, l &lt; n</code></li>
+	<li><code>nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+The two tuples are:
+1. (0, 0, 0, 1) -&gt; nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
+2. (1, 1, 0, 0) -&gt; nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums1.length</code></li>
+	<li><code>n == nums2.length</code></li>
+	<li><code>n == nums3.length</code></li>
+	<li><code>n == nums4.length</code></li>
+	<li><code>1 &lt;= n &lt;= 200</code></li>
+	<li><code>-2<sup>28</sup> &lt;= nums1[i], nums2[i], nums3[i], nums4[i] &lt;= 2<sup>28</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/4sum/4sum.cpp b/4sum/4sum.cpp
new file mode 100644
index 0000000..355061e
--- /dev/null
+++ b/4sum/4sum.cpp
@@ -0,0 +1,54 @@
+class Solution {
+public:
+    vector<vector<int>> fourSum(vector<int>& nums, int target) {
+        vector<vector<int>> ans;
+        if(nums.size() == 0)
+            return ans;
+        
+        sort(nums.begin(),nums.end());
+        int n = nums.size();
+        
+        for(int i=0;i<n;i++)
+        {
+            for(int j=i+1;j<n;j++)
+            {
+                int rem = target -nums[i] - nums[j];
+                
+                int low = j+1;
+                int high = n-1;
+                
+                while(high>low)
+                {
+                 int two_sum = nums[low]+nums[high];
+                    if(two_sum == rem)
+                    {
+                        vector<int> temp(4,0);
+                        temp[0] = nums[i];
+                        temp[1] = nums[j];
+                        temp[2] = nums[low];
+                        temp[3] = nums[high];
+                        ans.push_back(temp);
+                        
+                        while(high>low && nums[low] == nums[low+1])
+                            low++;
+                        while(high>low && nums[high] == nums[high-1])
+                            high--;
+                        
+                        low++;
+                        high--;
+                    }
+                    else if(two_sum < rem)
+                    {
+                        low++;
+                    }
+                    else
+                        high--;
+                        
+                }
+                 while(j + 1 < n && nums[j + 1] == nums[j]) ++j;
+            }
+             while (i + 1 < n && nums[i + 1] == nums[i]) ++i;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/4sum/README.md b/4sum/README.md
new file mode 100644
index 0000000..71e69fa
--- /dev/null
+++ b/4sum/README.md
@@ -0,0 +1,32 @@
+<h2>18. 4Sum</h2><h3>Medium</h3><hr><div><p>Given an array <code>nums</code> of <code>n</code> integers, return <em>an array of all the <strong>unique</strong> quadruplets</em> <code>[nums[a], nums[b], nums[c], nums[d]]</code> such that:</p>
+
+<ul>
+	<li><code>0 &lt;= a, b, c, d&nbsp;&lt; n</code></li>
+	<li><code>a</code>, <code>b</code>, <code>c</code>, and <code>d</code> are <strong>distinct</strong>.</li>
+	<li><code>nums[a] + nums[b] + nums[c] + nums[d] == target</code></li>
+</ul>
+
+<p>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,0,-1,0,-2,2], target = 0
+<strong>Output:</strong> [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,2,2,2,2], target = 8
+<strong>Output:</strong> [[2,2,2,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>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>
+</ul>
+</div>
\ No newline at end of file
diff --git a/50-powx-n/50-powx-n.cpp b/50-powx-n/50-powx-n.cpp
new file mode 100644
index 0000000..6c31fe4
--- /dev/null
+++ b/50-powx-n/50-powx-n.cpp
@@ -0,0 +1,28 @@
+class Solution {
+public:
+    double myPow(double x, int n) {
+        if(n==0)
+            return 1;
+        if(n>0)
+        {
+            if(n%2 == 0)
+            {
+                double sub = pow(x,n/2);
+                return sub*sub;
+            }
+            else
+                return x*pow(x,n-1);
+        }
+        else
+        {
+            if(n%2 == 0)
+            {
+                double sub = pow(x,abs(n/2));
+                return 1/(sub*sub);
+            }
+            else
+                return (x*pow(x,n-1));
+        }
+        return 1;
+    }
+};
\ No newline at end of file
diff --git a/50-powx-n/NOTES.md b/50-powx-n/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/50-powx-n/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/50-powx-n/README.md b/50-powx-n/README.md
new file mode 100644
index 0000000..9790866
--- /dev/null
+++ b/50-powx-n/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/powx-n/">50. Pow(x, n)</a></h2><h3>Medium</h3><hr><div><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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> x = 2.00000, n = 10
+<strong>Output:</strong> 1024.00000
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> x = 2.10000, n = 3
+<strong>Output:</strong> 9.26100
+</pre>
+
+<p><strong>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>-10<sup>4</sup> &lt;= x<sup>n</sup> &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/503-next-greater-element-ii/503-next-greater-element-ii.cpp b/503-next-greater-element-ii/503-next-greater-element-ii.cpp
new file mode 100644
index 0000000..3871eb0
--- /dev/null
+++ b/503-next-greater-element-ii/503-next-greater-element-ii.cpp
@@ -0,0 +1,27 @@
+class Solution {
+public:
+    vector<int> nextGreaterElements(vector<int>& nums) {
+        vector<int> ans(nums.size());
+        stack<int> s;
+        for(int i=2*nums.size()-1; i>=0;i--)
+        {
+            while(!s.empty() && s.top()<=nums[i%nums.size()] )
+                s.pop();
+            
+            if(i<nums.size())
+            {
+            if(s.empty())
+                ans[i%nums.size()] = -1;
+            else
+                ans[i%nums.size()] = s.top();
+             
+            }
+           
+            s.push(nums[i%nums.size()]);
+        }
+        
+        return ans;
+        
+        
+    }
+};
\ No newline at end of file
diff --git a/503-next-greater-element-ii/NOTES.md b/503-next-greater-element-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/503-next-greater-element-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/503-next-greater-element-ii/README.md b/503-next-greater-element-ii/README.md
new file mode 100644
index 0000000..3fc5b0a
--- /dev/null
+++ b/503-next-greater-element-ii/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/next-greater-element-ii/">503. Next Greater Element II</a></h2><h3>Medium</h3><hr><div><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't exist, return <code>-1</code> for this number.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,1]
+<strong>Output:</strong> [2,-1,2]
+Explanation: The first 1's next greater number is 2; 
+The number 2 can't find next greater number. 
+The second 1's next greater number needs to search circularly, which is also 2.
+</pre>
+
+<p><strong>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>
+</div>
\ No newline at end of file
diff --git a/509-fibonacci-number/509-fibonacci-number.cpp b/509-fibonacci-number/509-fibonacci-number.cpp
new file mode 100644
index 0000000..f325e14
--- /dev/null
+++ b/509-fibonacci-number/509-fibonacci-number.cpp
@@ -0,0 +1,8 @@
+class Solution {
+public:
+    int fib(int n) {
+        if(n == 0 || n==1)return n;
+        
+        return fib(n-1)+fib(n-2); 
+    }
+};
\ No newline at end of file
diff --git a/509-fibonacci-number/NOTES.md b/509-fibonacci-number/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/509-fibonacci-number/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/509-fibonacci-number/README.md b/509-fibonacci-number/README.md
new file mode 100644
index 0000000..5c4b5ad
--- /dev/null
+++ b/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/51-n-queens/51-n-queens.cpp b/51-n-queens/51-n-queens.cpp
new file mode 100644
index 0000000..3d58028
--- /dev/null
+++ b/51-n-queens/51-n-queens.cpp
@@ -0,0 +1,70 @@
+class Solution {
+public:
+//     bool isSafe(int row,int col,vector<string> & board,int n)
+//     {
+        
+//         for(int i=0;i<col;i++)
+//         {
+//             if(board[row][i] == 'Q')return false;
+//         }
+//         int tempr = row;
+//         int tempc = col;
+        
+//         while(tempr>=0 && tempc>=0)
+//         {
+//             if(board[tempr--][tempc--] == 'Q')
+//                 return false;
+//         }
+        
+//         tempr = row;
+//         tempc = col;
+//         while(tempr < n && tempc < n && tempr>=0 && tempc>=0)
+//         {
+//             if(board[tempr++][tempc--] == 'Q')
+//                 return false;
+//         }
+//         return true;
+//     }
+    
+    
+    void solve(int col,vector<vector<string>> & ans,vector<string> & board,int n,vector<int>& rowHash,vector<int>&upper,vector<int> & down)
+    {
+        if(col == n)
+        {
+            ans.push_back(board);
+            return ;
+        }
+        
+        for(int row = 0;row<n;row++)
+        {
+            if(rowHash[row] == 0 && upper[(n-1) + row-col ] == 0 && down[row+col] == 0)
+            {
+                rowHash[row] = 1;
+                upper[(n-1)+ row-col] = 1;
+                down[row+col] =1;
+                board[row][col] = 'Q';
+                solve(col+1,ans,board,n,rowHash,upper,down);
+                board[row][col] = '.';
+                rowHash[row] = 0;
+                upper[(n-1)+ row-col] = 0;
+                down[row+col] =0;
+            }
+        }
+        return;
+    }
+    
+    vector<vector<string>> solveNQueens(int n) {
+        vector<vector<string>> ans;
+        vector<string> board(n);
+        string s(n,'.');
+        for(int i=0;i<n;i++)
+            board[i] = s;
+        
+        vector<int> rowHash(n);
+        vector<int> upper(2*n - 1,0);
+        vector<int> down(2*n - 1,0);
+        solve(0,ans,board,n,rowHash,upper,down);
+        return ans;
+        
+    }
+};
\ No newline at end of file
diff --git a/51-n-queens/NOTES.md b/51-n-queens/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/51-n-queens/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/51-n-queens/README.md b/51-n-queens/README.md
new file mode 100644
index 0000000..e2bebec
--- /dev/null
+++ b/51-n-queens/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/n-queens/">51. N-Queens</a></h2><h3>Hard</h3><hr><div><p>The <strong>n-queens</strong> puzzle is the problem of placing <code>n</code> queens on an <code>n x n</code> chessboard such that no two queens attack each other.</p>
+
+<p>Given an integer <code>n</code>, return <em>all distinct solutions to the <strong>n-queens puzzle</strong></em>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>Each solution contains a distinct board configuration of the n-queens' placement, where <code>'Q'</code> and <code>'.'</code> both indicate a queen and an empty space, respectively.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;">
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> [[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
+<strong>Explanation:</strong> There exist two distinct solutions to the 4-queens puzzle as shown above
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> [["Q"]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 9</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/52-n-queens-ii/52-n-queens-ii.cpp b/52-n-queens-ii/52-n-queens-ii.cpp
new file mode 100644
index 0000000..142f8ed
--- /dev/null
+++ b/52-n-queens-ii/52-n-queens-ii.cpp
@@ -0,0 +1,46 @@
+class Solution {
+public:
+    
+       int solve(int col,vector<vector<string>>& ans,vector<string> &board,int n,vector<int> &right, vector<int>& upper,vector<int> &down)
+    {
+        if(n == col)
+        {
+            ans.push_back(board);
+            return 1;
+        }
+        int k = 0;
+        for(int row = 0;row<n;row++)
+        {
+            if(right[row] == 0 && upper[row+col] == 0 && down[(n-1) + col-row] == 0)
+            {
+                right[row] = 1;
+                upper[row+col] = 1;
+                down[(n-1) + col-row] = 1;
+                board[row][col] = 'Q';
+                k += solve(col+1,ans,board,n,right,upper,down);
+                board[row][col] = '.';
+                down[(n-1) + col-row] = 0;
+                upper[row+col] = 0;
+                right[row] = 0;
+            }
+        }
+        return k;
+    }
+    
+    
+    int totalNQueens(int n) {
+        vector<vector<string>> ans;
+        vector<string> board(n);
+        string s(n,'.');
+        for(int i=0;i<n;i++)
+        {
+            board[i] = s;
+        }
+        vector<int> right(n,0);
+        vector<int> upper(2*n-1,0);
+        vector<int> down(2*n-1,0);
+        
+        int a = solve(0,ans,board,n,right,upper,down);
+        return a;
+    }
+};
\ No newline at end of file
diff --git a/52-n-queens-ii/NOTES.md b/52-n-queens-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/52-n-queens-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/52-n-queens-ii/README.md b/52-n-queens-ii/README.md
new file mode 100644
index 0000000..6ab4a13
--- /dev/null
+++ b/52-n-queens-ii/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/n-queens-ii/">52. N-Queens II</a></h2><h3>Hard</h3><hr><div><p>The <strong>n-queens</strong> puzzle is the problem of placing <code>n</code> queens on an <code>n x n</code> chessboard such that no two queens attack each other.</p>
+
+<p>Given an integer <code>n</code>, return <em>the number of distinct solutions to the&nbsp;<strong>n-queens puzzle</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/13/queens.jpg" style="width: 600px; height: 268px;">
+<pre><strong>Input:</strong> n = 4
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> There are two distinct solutions to the 4-queens puzzle as shown.
+</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;= 9</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/520-detect-capital/520-detect-capital.cpp b/520-detect-capital/520-detect-capital.cpp
new file mode 100644
index 0000000..4f5e07c
--- /dev/null
+++ b/520-detect-capital/520-detect-capital.cpp
@@ -0,0 +1,10 @@
+class Solution {
+public:
+    bool detectCapitalUse(string word) {
+    for(int i = 1; i < word.size(); i++){
+        if(isupper(word[1]) != isupper(word[i]) || 
+           islower(word[0]) && isupper(word[i])) return false;
+    }        
+    return true;
+}
+};
\ No newline at end of file
diff --git a/520-detect-capital/NOTES.md b/520-detect-capital/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/520-detect-capital/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/520-detect-capital/README.md b/520-detect-capital/README.md
new file mode 100644
index 0000000..29b46a9
--- /dev/null
+++ b/520-detect-capital/README.md
@@ -0,0 +1,26 @@
+<h2><a href="https://leetcode.com/problems/detect-capital/">520. Detect Capital</a></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/525-contiguous-array/525-contiguous-array.cpp b/525-contiguous-array/525-contiguous-array.cpp
new file mode 100644
index 0000000..93629b2
--- /dev/null
+++ b/525-contiguous-array/525-contiguous-array.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int findMaxLength(vector<int>& nums) {
+        int sum=0, maxLen=0;
+        unordered_map<int, int> seen{{0, -1}};
+        
+        for(int i=0; i<nums.size(); i++){
+            sum += nums[i]==1 ? 1 : -1;
+            if(seen.count(sum)) maxLen = max(maxLen, i-seen[sum]);
+            else seen[sum] = i;
+        }
+        return maxLen;
+    }
+};
\ No newline at end of file
diff --git a/525-contiguous-array/NOTES.md b/525-contiguous-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/525-contiguous-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/525-contiguous-array/README.md b/525-contiguous-array/README.md
new file mode 100644
index 0000000..a59cfe7
--- /dev/null
+++ b/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/53-maximum-subarray/53-maximum-subarray.cpp b/53-maximum-subarray/53-maximum-subarray.cpp
new file mode 100644
index 0000000..4ce0f0e
--- /dev/null
+++ b/53-maximum-subarray/53-maximum-subarray.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        
+        int sum = 0;
+        int maxi = INT_MIN;
+        
+        for(int i=0;i<nums.size();i++)
+        {
+            sum += nums[i];
+            maxi = max(sum,maxi);
+            sum = max(0,sum);
+        }
+        return maxi;
+    }
+};
\ No newline at end of file
diff --git a/53-maximum-subarray/NOTES.md b/53-maximum-subarray/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/53-maximum-subarray/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/53-maximum-subarray/README.md b/53-maximum-subarray/README.md
new file mode 100644
index 0000000..dd2fd20
--- /dev/null
+++ b/53-maximum-subarray/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/maximum-subarray/">53. Maximum Subarray</a></h2><h3>Medium</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/532-k-diff-pairs-in-an-array/532-k-diff-pairs-in-an-array.cpp b/532-k-diff-pairs-in-an-array/532-k-diff-pairs-in-an-array.cpp
new file mode 100644
index 0000000..7da4c87
--- /dev/null
+++ b/532-k-diff-pairs-in-an-array/532-k-diff-pairs-in-an-array.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int findPairs(vector<int>& nums, int k) {
+        map<int,int> m;
+        for(auto a:nums)
+            m[a]++;
+        int ans = 0;
+        for(auto it = m.begin();it != m.end();it++)
+        {
+            if(k == 0)
+            {
+                if(it->second > 1)
+                    ans ++;
+            }
+            else
+            {
+                if(m.find(it->first + k) != m.end())
+                ans++;
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/532-k-diff-pairs-in-an-array/NOTES.md b/532-k-diff-pairs-in-an-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/532-k-diff-pairs-in-an-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/532-k-diff-pairs-in-an-array/README.md b/532-k-diff-pairs-in-an-array/README.md
new file mode 100644
index 0000000..a153108
--- /dev/null
+++ b/532-k-diff-pairs-in-an-array/README.md
@@ -0,0 +1,43 @@
+<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 &lt; j &lt; nums.length</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/54-spiral-matrix/54-spiral-matrix.cpp b/54-spiral-matrix/54-spiral-matrix.cpp
new file mode 100644
index 0000000..b48b0ab
--- /dev/null
+++ b/54-spiral-matrix/54-spiral-matrix.cpp
@@ -0,0 +1,37 @@
+class Solution {
+public:
+    vector<int> spiralOrder(vector<vector<int>>& matrix) {
+        int m = matrix.size();
+        int n = matrix[0].size();
+        int u = 0, d = m - 1, l = 0, r = n - 1, p = 0;
+        vector<int> order(m * n);
+        while (u <= d && l <= r) {
+            for (int col = l; col <= r; col++) {
+                order[p++] = matrix[u][col];
+            }
+            if (++u > d) {
+                break;
+            }
+            for (int row = u; row <= d; row++) {
+                order[p++] = matrix[row][r];
+            }
+            if (--r < l) {
+                break;
+            }
+            for (int col = r; col >= l; col--) {
+                order[p++] = matrix[d][col];
+            }
+            if (--d < u) {
+                break;
+            }
+            for (int row = d; row >= u; row--) {
+                order[p++] = matrix[row][l];
+            }
+            if (l++ > r) {
+                break;
+            }
+        }
+         //order.push_back(1);
+        return order;
+    }
+};
\ No newline at end of file
diff --git a/54-spiral-matrix/NOTES.md b/54-spiral-matrix/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/54-spiral-matrix/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/54-spiral-matrix/README.md b/54-spiral-matrix/README.md
new file mode 100644
index 0000000..0390c03
--- /dev/null
+++ b/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/540-single-element-in-a-sorted-array/540-single-element-in-a-sorted-array.cpp b/540-single-element-in-a-sorted-array/540-single-element-in-a-sorted-array.cpp
new file mode 100644
index 0000000..346ca4c
--- /dev/null
+++ b/540-single-element-in-a-sorted-array/540-single-element-in-a-sorted-array.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int singleNonDuplicate(vector<int>& nums) {
+        int low = 0, high = nums.size() - 2; 
+        while(low <= high) {
+            int mid = (low + high) >> 1; 
+            if(nums[mid] == nums[mid^1]) {
+                low = mid + 1; 
+            } 
+            else {
+                high = mid - 1; 
+            }
+        }
+        return nums[low]; 
+    }
+};
\ No newline at end of file
diff --git a/540-single-element-in-a-sorted-array/NOTES.md b/540-single-element-in-a-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/540-single-element-in-a-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/540-single-element-in-a-sorted-array/README.md b/540-single-element-in-a-sorted-array/README.md
new file mode 100644
index 0000000..a25a5f4
--- /dev/null
+++ b/540-single-element-in-a-sorted-array/README.md
@@ -0,0 +1,22 @@
+<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><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 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>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<sup>5</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/543-diameter-of-binary-tree/NOTES.md b/543-diameter-of-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/543-diameter-of-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/543-diameter-of-binary-tree/README.md b/543-diameter-of-binary-tree/README.md
new file mode 100644
index 0000000..b16809e
--- /dev/null
+++ b/543-diameter-of-binary-tree/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/diameter-of-binary-tree/">543. Diameter of Binary Tree</a></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/55-jump-game/55-jump-game.cpp b/55-jump-game/55-jump-game.cpp
new file mode 100644
index 0000000..148d404
--- /dev/null
+++ b/55-jump-game/55-jump-game.cpp
@@ -0,0 +1,42 @@
+class Solution {
+public:
+    
+//     bool solve(vector<int> & nums,int i,vector<int>& dp)
+//     {
+//         if(i==nums.size()-1)
+//         {
+//             return dp[i] = true;
+//         }
+//         if(dp[i]!= -1)return dp[i];
+        
+//         for(int j=1;j<=nums[i];j++)
+//         {
+//             if(i+j<nums.size())
+//              if(solve(nums,i+j,dp))
+//               return dp[i] = true;
+//         }
+//         return dp[i] = false;
+//     }
+        
+    bool canJump(vector<int>& nums) {
+        
+        if(nums.size()<2)return true;
+        
+        vector<int> dp(nums.size(),false);
+        dp[nums.size()-1] = true;
+        for(int i=nums.size()-2;i>=0;i--)
+        {
+            bool flag = false;
+            for(int j = 1;j<=nums[i];j++)
+            {
+                if(i+j >= nums.size() || dp[i+j] == true)
+                {
+                    flag = true;
+                    break;
+                }  
+            }
+            dp[i] = flag;
+        }
+        return dp[0];
+    }
+};
\ No newline at end of file
diff --git a/55-jump-game/NOTES.md b/55-jump-game/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/55-jump-game/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/55-jump-game/README.md b/55-jump-game/README.md
new file mode 100644
index 0000000..2789ae3
--- /dev/null
+++ b/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/556-next-greater-element-iii/556-next-greater-element-iii.cpp b/556-next-greater-element-iii/556-next-greater-element-iii.cpp
new file mode 100644
index 0000000..a455642
--- /dev/null
+++ b/556-next-greater-element-iii/556-next-greater-element-iii.cpp
@@ -0,0 +1,9 @@
+class Solution {
+public:
+   int nextGreaterElement(int n) {
+    auto digits = to_string(n);
+    next_permutation(begin(digits), end(digits));
+    auto res = stoll(digits);
+    return (res > INT_MAX || res <= n) ?  -1 : res;
+}
+};
\ No newline at end of file
diff --git a/556-next-greater-element-iii/NOTES.md b/556-next-greater-element-iii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/556-next-greater-element-iii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/556-next-greater-element-iii/README.md b/556-next-greater-element-iii/README.md
new file mode 100644
index 0000000..7d36bf4
--- /dev/null
+++ b/556-next-greater-element-iii/README.md
@@ -0,0 +1,19 @@
+<h2><a href="https://leetcode.com/problems/next-greater-element-iii/">556. Next Greater Element III</a></h2><h3>Medium</h3><hr><div><p>Given a positive integer <code>n</code>, find <em>the smallest integer which has exactly the same digits existing in the integer</em> <code>n</code> <em>and is greater in value than</em> <code>n</code>. If no such positive integer exists, return <code>-1</code>.</p>
+
+<p><strong>Note</strong> that the returned integer should fit in <strong>32-bit integer</strong>, if there is a valid answer but it does not fit in <strong>32-bit integer</strong>, return <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 12
+<strong>Output:</strong> 21
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 21
+<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>
+</ul>
+</div>
\ No newline at end of file
diff --git a/560-subarray-sum-equals-k/560-subarray-sum-equals-k.cpp b/560-subarray-sum-equals-k/560-subarray-sum-equals-k.cpp
new file mode 100644
index 0000000..7b32586
--- /dev/null
+++ b/560-subarray-sum-equals-k/560-subarray-sum-equals-k.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int subarraySum(vector<int>& nums, int k) {
+        int cum=0; // cumulated sum
+        map<int,int> rec; // prefix sum recorder
+        int cnt = 0; // number of found subarray
+        rec[0]++; // to take into account those subarrays that begin with index 0
+        for(int i=0;i<nums.size();i++){
+            cum += nums[i];
+            cnt += rec[cum-k];
+            rec[cum]++;
+        }
+        return cnt;
+    }
+};
\ No newline at end of file
diff --git a/567-permutation-in-string/NOTES.md b/567-permutation-in-string/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/567-permutation-in-string/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/567-permutation-in-string/README.md b/567-permutation-in-string/README.md
new file mode 100644
index 0000000..e4a1dab
--- /dev/null
+++ b/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/576-out-of-boundary-paths/576-out-of-boundary-paths.cpp b/576-out-of-boundary-paths/576-out-of-boundary-paths.cpp
new file mode 100644
index 0000000..321a7e6
--- /dev/null
+++ b/576-out-of-boundary-paths/576-out-of-boundary-paths.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int mod = 1e9+7;
+    int solve(int n,int m,int move,int i,int j, vector<vector<vector<int>>>& dp)
+    {
+        
+    
+        if(i<0 || j<0 || i>=n || j>=m)return 1;
+        
+        if(move == 0)return 0;
+        
+        if(dp[i][j][move] != -1)return dp[i][j][move];
+        
+        int up = solve(n,m,move-1,i-1,j,dp) % mod;
+        
+        int down = solve(n,m,move-1,i+1,j,dp) % mod;
+        
+        int left = solve(n,m,move-1,i,j-1,dp) % mod;
+       
+        int right = solve(n,m,move-1,i,j+1,dp) % mod;
+        
+        return dp[i][j][move] = ((up+down) % mod+(right+left) % mod) % mod;
+    }
+    
+    int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
+        vector<vector<vector<int>>> dp(m,vector<vector<int>> (n,vector<int> (maxMove+1,-1)));
+        return solve(m,n,maxMove,startRow,startColumn,dp) % mod;
+    }
+};
\ No newline at end of file
diff --git a/576-out-of-boundary-paths/README.md b/576-out-of-boundary-paths/README.md
new file mode 100644
index 0000000..1174d49
--- /dev/null
+++ b/576-out-of-boundary-paths/README.md
@@ -0,0 +1,27 @@
+<h2><a href="https://leetcode.com/problems/out-of-boundary-paths/">576. Out of Boundary Paths</a></h2><h3>Medium</h3><hr><div><p>There is an <code>m x n</code> grid with a ball. The ball is initially at the position <code>[startRow, startColumn]</code>. You are allowed to move the ball to one of the four adjacent cells in the grid (possibly out of the grid crossing the grid boundary). You can apply <strong>at most</strong> <code>maxMove</code> moves to the ball.</p>
+
+<p>Given the five integers <code>m</code>, <code>n</code>, <code>maxMove</code>, <code>startRow</code>, <code>startColumn</code>, return the number of paths to move the ball out of the grid boundary. Since the answer can be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/04/28/out_of_boundary_paths_1.png" style="width: 500px; height: 296px;">
+<pre><strong>Input:</strong> m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0
+<strong>Output:</strong> 6
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/04/28/out_of_boundary_paths_2.png" style="width: 500px; height: 293px;">
+<pre><strong>Input:</strong> m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1
+<strong>Output:</strong> 12
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= m, n &lt;= 50</code></li>
+	<li><code>0 &lt;= maxMove &lt;= 50</code></li>
+	<li><code>0 &lt;= startRow &lt; m</code></li>
+	<li><code>0 &lt;= startColumn &lt; n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/60-permutation-sequence/60-permutation-sequence.cpp b/60-permutation-sequence/60-permutation-sequence.cpp
new file mode 100644
index 0000000..8942aba
--- /dev/null
+++ b/60-permutation-sequence/60-permutation-sequence.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    string getPermutation(int n, int k) {
+        string s;
+        for(int i=1;i<=n;i++)
+            s += to_string(i);
+        int i=1;
+        do {
+       i++;
+         } while (next_permutation(s.begin(),s.end()) && i !=k);
+        
+        return s;
+        
+        
+        
+    }
+};
\ No newline at end of file
diff --git a/60-permutation-sequence/NOTES.md b/60-permutation-sequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/60-permutation-sequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/60-permutation-sequence/README.md b/60-permutation-sequence/README.md
new file mode 100644
index 0000000..e8a233f
--- /dev/null
+++ b/60-permutation-sequence/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/permutation-sequence/">60. Permutation Sequence</a></h2><h3>Hard</h3><hr><div><p>The set <code>[1, 2, 3, ...,&nbsp;n]</code> contains a total of <code>n!</code> unique permutations.</p>
+
+<p>By listing and labeling all of the permutations in order, we get the following sequence for <code>n = 3</code>:</p>
+
+<ol>
+	<li><code>"123"</code></li>
+	<li><code>"132"</code></li>
+	<li><code>"213"</code></li>
+	<li><code>"231"</code></li>
+	<li><code>"312"</code></li>
+	<li><code>"321"</code></li>
+</ol>
+
+<p>Given <code>n</code> and <code>k</code>, return the <code>k<sup>th</sup></code> permutation sequence.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 3, k = 3
+<strong>Output:</strong> "213"
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 4, k = 9
+<strong>Output:</strong> "2314"
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> n = 3, k = 1
+<strong>Output:</strong> "123"
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 9</code></li>
+	<li><code>1 &lt;= k &lt;= n!</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/605-can-place-flowers/605-can-place-flowers.cpp b/605-can-place-flowers/605-can-place-flowers.cpp
new file mode 100644
index 0000000..e5ec623
--- /dev/null
+++ b/605-can-place-flowers/605-can-place-flowers.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    bool canPlaceFlowers(vector<int>& flowerbed, int n) {
+        if (n == 0) return true;
+        for (int i = 0; i < flowerbed.size(); i ++) {
+            if (flowerbed[i] == 0 && (i == 0 || flowerbed[i - 1] == 0) && (i == flowerbed.size() - 1 || flowerbed[i + 1] == 0)) { // can place?
+                -- n;
+                if (n == 0) return true;
+                flowerbed[i] = 1; // place!
+            }
+        }
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/605-can-place-flowers/NOTES.md b/605-can-place-flowers/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/605-can-place-flowers/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/605-can-place-flowers/README.md b/605-can-place-flowers/README.md
new file mode 100644
index 0000000..b98f56a
--- /dev/null
+++ b/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/61-rotate-list/NOTES.md b/61-rotate-list/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/61-rotate-list/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/61-rotate-list/README.md b/61-rotate-list/README.md
new file mode 100644
index 0000000..4f45cb2
--- /dev/null
+++ b/61-rotate-list/README.md
@@ -0,0 +1,24 @@
+<h2><a href="https://leetcode.com/problems/rotate-list/">61. Rotate List</a></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/62-unique-paths/NOTES.md b/62-unique-paths/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/62-unique-paths/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/62-unique-paths/README.md b/62-unique-paths/README.md
new file mode 100644
index 0000000..f5816d6
--- /dev/null
+++ b/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/63-unique-paths-ii/NOTES.md b/63-unique-paths-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/63-unique-paths-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/63-unique-paths-ii/README.md b/63-unique-paths-ii/README.md
new file mode 100644
index 0000000..7fce5c7
--- /dev/null
+++ b/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/64-minimum-path-sum/64-minimum-path-sum.cpp b/64-minimum-path-sum/64-minimum-path-sum.cpp
new file mode 100644
index 0000000..7c79716
--- /dev/null
+++ b/64-minimum-path-sum/64-minimum-path-sum.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int minPathSum(vector<vector<int>>& grid) {
+        int n = grid.size();
+        int m = grid[0].size();
+        vector<vector<int>> dp(n,vector<int> (m,0));
+        
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<m;j++)
+            {
+                if(i==0 && j == 0)
+                    dp[i][j] = grid[i][j];
+                else if(i==0)
+                    dp[i][j] = dp[i][j-1] + grid[i][j];
+                else if(j==0)
+                    dp[i][j] = dp[i-1][j] + grid[i][j];
+                else
+                    dp[i][j] = min(dp[i-1][j],dp[i][j-1]) + grid[i][j];        
+            }
+        }
+        return dp[n-1][m-1];
+    }
+};
\ No newline at end of file
diff --git a/64-minimum-path-sum/NOTES.md b/64-minimum-path-sum/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/64-minimum-path-sum/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/64-minimum-path-sum/README.md b/64-minimum-path-sum/README.md
new file mode 100644
index 0000000..18b4fcd
--- /dev/null
+++ b/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/650-2-keys-keyboard/650-2-keys-keyboard.cpp b/650-2-keys-keyboard/650-2-keys-keyboard.cpp
new file mode 100644
index 0000000..72aa60b
--- /dev/null
+++ b/650-2-keys-keyboard/650-2-keys-keyboard.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    
+    int f(int curr,int total ,int paste_len,vector<vector<int>>& dp)
+    {
+        if(curr>total)return 1e9;
+        
+        if(curr == total)return 0;
+        
+        if(dp[curr][paste_len] != -1)return dp[curr][paste_len];
+        
+        int copy = 2 + f(curr*2,total,curr,dp);
+        
+        int paste = 1 + f(curr + paste_len , total , paste_len,dp);
+        
+        return dp[curr][paste_len] = min(copy,paste);
+    }
+    
+    int minSteps(int n) {
+        if(n==1)return 0;
+        vector<vector<int>> dp(n,vector<int> (n,-1));
+        return 1 + f(1,n,1,dp);
+    }
+};
\ No newline at end of file
diff --git a/650-2-keys-keyboard/NOTES.md b/650-2-keys-keyboard/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/650-2-keys-keyboard/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/650-2-keys-keyboard/README.md b/650-2-keys-keyboard/README.md
new file mode 100644
index 0000000..3918e4f
--- /dev/null
+++ b/650-2-keys-keyboard/README.md
@@ -0,0 +1,33 @@
+<h2><a href="https://leetcode.com/problems/2-keys-keyboard/">650. 2 Keys Keyboard</a></h2><h3>Medium</h3><hr><div><p>There is only one character <code>'A'</code> on the screen of a notepad. You can perform two operations on this notepad for each step:</p>
+
+<ul>
+	<li>Copy All: You can copy all the characters present on the screen (a partial copy is not allowed).</li>
+	<li>Paste: You can paste the characters which are copied last time.</li>
+</ul>
+
+<p>Given an integer <code>n</code>, return <em>the minimum number of operations to get the character</em> <code>'A'</code> <em>exactly</em> <code>n</code> <em>times on the screen</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Intitally, we have one character 'A'.
+In step 1, we use Copy All operation.
+In step 2, we use Paste operation to get 'AA'.
+In step 3, we use Paste operation to get 'AAA'.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> 0
+</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/66-plus-one/NOTES.md b/66-plus-one/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/66-plus-one/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/662-maximum-width-of-binary-tree/662-maximum-width-of-binary-tree.cpp b/662-maximum-width-of-binary-tree/662-maximum-width-of-binary-tree.cpp
new file mode 100644
index 0000000..3d1a992
--- /dev/null
+++ b/662-maximum-width-of-binary-tree/662-maximum-width-of-binary-tree.cpp
@@ -0,0 +1,40 @@
+/**
+ * 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:
+    int widthOfBinaryTree(TreeNode* root) {
+        if(root == NULL)return 0;
+        int ans = 0;
+        queue<pair<TreeNode*,int>> pd;
+        pd.push({root,0});
+        
+        while(!pd.empty())
+        {
+            int size = pd.size();
+            int low,high;
+            int min = pd.front().second;
+            for(int i=0;i<size;i++)
+            {
+                pair<TreeNode*,int> k = pd.front();
+                TreeNode * front = k.first;
+                pd.pop();
+                long long int num = k.second - min;
+                if(i==0)low = num;
+                if(i == size-1) high = num;
+                if(front->left)pd.push({front->left,2*num*1LL + 1});
+                if(front->right)pd.push({front->right,2*num*1LL+2});
+            }
+            ans = max(ans,(int)high-low+1);
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/662-maximum-width-of-binary-tree/NOTES.md b/662-maximum-width-of-binary-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/662-maximum-width-of-binary-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/662-maximum-width-of-binary-tree/README.md b/662-maximum-width-of-binary-tree/README.md
new file mode 100644
index 0000000..6b09e1d
--- /dev/null
+++ b/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/67-add-binary/NOTES.md b/67-add-binary/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/67-add-binary/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/67-add-binary/README.md b/67-add-binary/README.md
new file mode 100644
index 0000000..fc85c32
--- /dev/null
+++ b/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/673-number-of-longest-increasing-subsequence/NOTES.md b/673-number-of-longest-increasing-subsequence/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/673-number-of-longest-increasing-subsequence/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/673-number-of-longest-increasing-subsequence/README.md b/673-number-of-longest-increasing-subsequence/README.md
new file mode 100644
index 0000000..439471d
--- /dev/null
+++ b/673-number-of-longest-increasing-subsequence/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/number-of-longest-increasing-subsequence/">673. Number of Longest Increasing Subsequence</a></h2><h3>Medium</h3><hr><div><p>Given an integer array&nbsp;<code>nums</code>, return <em>the number of longest increasing subsequences.</em></p>
+
+<p><strong>Notice</strong> that the sequence has to be <strong>strictly</strong> increasing.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3,5,4,7]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The two longest increasing subsequences are [1, 3, 4, 7] and [1, 3, 5, 7].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [2,2,2,2,2]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The length of longest continuous increasing subsequence is 1, and there are 5 subsequences' length is 1, so output 5.
+
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 2000</code></li>
+	<li><code>-10<sup>6</sup> &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/7 Segment Display - GFG/7-segment-display.cpp b/7 Segment Display - GFG/7-segment-display.cpp
new file mode 100644
index 0000000..786560c
--- /dev/null
+++ b/7 Segment Display - GFG/7-segment-display.cpp	
@@ -0,0 +1,71 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+
+class Solution {
+ public:
+   string sevenSegments(string S, int N) {
+       string str="";
+       unordered_map <char,int> umap;
+       S=S.substr(0,N);
+       umap['0']=6;
+       umap['1']=2;
+       umap['2']=5;
+       umap['3']=5;
+       umap['4']=4;
+       umap['5']=5;
+       umap['6']=6;
+       umap['7']=3;
+       umap['8']=7;
+       umap['9']=5;
+       int count=0,k;
+       for(auto c:S)
+        count+=umap[c];
+       int n=S.length();
+       char c;
+       while(n>0)
+       {
+         c='0';
+         while(c<='8')
+         {
+          if(n==1)
+          {
+             if(umap[c]==count)
+             {str+=c;n--;count=0;break;}
+          }
+          else
+          {
+          k=count-umap[c];
+          if(k/(n-1)>1)
+          {
+              str+=c;
+              n--;
+              count-=umap[c];
+              break;
+          }
+          }
+          c++;
+          }
+       }
+       return str;
+   }
+};
+
+// { Driver Code Starts.
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int N;
+        
+        cin>>N;
+        string S;
+        cin>>S;
+
+        Solution ob;
+        cout << ob.sevenSegments(S,N) << endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/7 Segment Display - GFG/README.md b/7 Segment Display - GFG/README.md
new file mode 100644
index 0000000..510742f
--- /dev/null
+++ b/7 Segment Display - GFG/README.md	
@@ -0,0 +1,51 @@
+# 7 Segment Display
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Using <a href="https://www.electronics-tutorials.ws/blog/7-segment-display-tutorial.html" target="_blank">seven segment display</a>, you can write down any digit from 0 to 9 using at most seven segments. Given a positive number <strong>N</strong> and then a string <strong>S</strong> representing a number of<strong> </strong>N digits. You have to rearrange the segments in this N digit number to get the smallest possible N digit number. This number can have leading zeros. You can not waste any segment or add any segment from your own. You have to use all of the segments of the given N digits. </span></p>
+
+<p><span style="font-size:18px"><strong>Note:</strong> You can refer this diagram for more details</span></p>
+
+<p><span style="font-size:18px"><img alt="" src="https://media.geeksforgeeks.org/img-practice/ScreenShot2022-02-17at11-1646053217.png" style="height:104px; width:500px" class="img-responsive"></span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong></span><strong>:</strong>
+<span style="font-size:18px"><strong>N = </strong>6</span>
+<span style="font-size:18px"><strong>S = </strong>"234567"</span>
+<span style="font-size:18px"><strong>Output:</strong></span>
+<span style="font-size:18px">000011</span>
+<span style="font-size:18px"><strong>Explanation:</strong></span>
+<span style="font-size:18px">234567 has a total of 28 segments and
+we can rearrange them to form 000011
+which has 28 segments too. 000011 is the
+smallest possible number which can be
+formed on rearrangement.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong></span><strong>:</strong>
+<span style="font-size:18px"><strong>N = </strong>3</span>
+<span style="font-size:18px"><strong>S = </strong>"011"</span>
+<span style="font-size:18px"><strong>Output:</strong></span>
+<span style="font-size:18px">011</span>
+<span style="font-size:18px"><strong>Explanation:</strong></span>
+<span style="font-size:18px">011 has a total of 10 segments and this
+is the smallest number with 10 segments.
+</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 <strong>sevenSegments()</strong> which takes an Integer N and a String S of length N as input and returns the smallest possible N digit number which can be made using all of the segments given.</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></span><br>
+<span style="font-size:18px">1 &lt;= N &lt;= 10<sup>4</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/70-climbing-stairs/NOTES.md b/70-climbing-stairs/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/70-climbing-stairs/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/700-search-in-a-binary-search-tree/700-search-in-a-binary-search-tree.cpp b/700-search-in-a-binary-search-tree/700-search-in-a-binary-search-tree.cpp
new file mode 100644
index 0000000..daf492b
--- /dev/null
+++ b/700-search-in-a-binary-search-tree/700-search-in-a-binary-search-tree.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    TreeNode* searchBST(TreeNode* root, int val) {
+        
+        if(root == NULL || (root->val == val))
+            return root;
+        
+        if(root->val > val)
+            return searchBST(root->left,val);
+        
+        return searchBST(root->right,val);
+        
+    }
+};
+
+
+
diff --git a/700-search-in-a-binary-search-tree/NOTES.md b/700-search-in-a-binary-search-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/700-search-in-a-binary-search-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/700-search-in-a-binary-search-tree/README.md b/700-search-in-a-binary-search-tree/README.md
new file mode 100644
index 0000000..08be87e
--- /dev/null
+++ b/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/701-insert-into-a-binary-search-tree/701-insert-into-a-binary-search-tree.cpp b/701-insert-into-a-binary-search-tree/701-insert-into-a-binary-search-tree.cpp
new file mode 100644
index 0000000..49e8df4
--- /dev/null
+++ b/701-insert-into-a-binary-search-tree/701-insert-into-a-binary-search-tree.cpp
@@ -0,0 +1,33 @@
+/**
+ * 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:
+    TreeNode* insertIntoBST(TreeNode* root, int val) {
+      if(root == NULL)
+      {
+        TreeNode* newNode = new TreeNode(val);
+        return newNode;
+        
+      }
+      if(root->val > val)
+      {
+        root->left = insertIntoBST(root->left,val);
+        return root;
+      }
+      if(root->val < val)
+      {
+        root->right = insertIntoBST(root->right,val);
+        return root;
+      }
+      return root;
+    }
+};
\ No newline at end of file
diff --git a/701-insert-into-a-binary-search-tree/NOTES.md b/701-insert-into-a-binary-search-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/701-insert-into-a-binary-search-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/701-insert-into-a-binary-search-tree/README.md b/701-insert-into-a-binary-search-tree/README.md
new file mode 100644
index 0000000..a5872f9
--- /dev/null
+++ b/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/704-binary-search/704-binary-search.cpp b/704-binary-search/704-binary-search.cpp
new file mode 100644
index 0000000..a84c443
--- /dev/null
+++ b/704-binary-search/704-binary-search.cpp
@@ -0,0 +1,28 @@
+class Solution {
+public:
+    
+    
+    int binary_search(int start,int end,int target,vector<int>& nums)
+    {
+        if(start<=end)
+        {
+            int mid = start + (end-start)/2;
+            
+            if(nums[mid] == target)return mid;
+            
+            if(nums[mid]>target)
+            {
+                return binary_search(start,mid-1,target,nums);
+            }
+            else
+            {
+                return binary_search(mid+1,end,target,nums);
+            }
+        }
+        return -1;
+    }
+    
+    int search(vector<int>& nums, int target) {
+        return binary_search(0,nums.size()-1,target,nums);
+    }
+};
\ No newline at end of file
diff --git a/704-binary-search/NOTES.md b/704-binary-search/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/704-binary-search/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/704-binary-search/README.md b/704-binary-search/README.md
new file mode 100644
index 0000000..4ecd7d9
--- /dev/null
+++ b/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/71-simplify-path/71-simplify-path.cpp b/71-simplify-path/71-simplify-path.cpp
new file mode 100644
index 0000000..4c357b5
--- /dev/null
+++ b/71-simplify-path/71-simplify-path.cpp
@@ -0,0 +1,40 @@
+class Solution {
+public:
+    string simplifyPath(string path) {
+        
+        stack<string> st;
+        string res;
+        
+        for(int i = 0;  i<path.size(); ++i)
+        {
+            if(path[i] == '/')    
+                continue;
+            string temp;
+            while(i < path.size() && path[i] != '/')
+            {
+                temp += path[i];
+                ++i;
+            }
+            if(temp == ".")
+                continue;
+            else if(temp == "..")
+            {
+                if(!st.empty())
+                    st.pop();
+            }
+            else
+                st.push(temp);
+        }
+        
+        while(!st.empty())
+        {
+            res = "/" + st.top() + res;
+            st.pop();
+        }
+        
+        if(res.size() == 0)
+            return "/";
+        
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/71-simplify-path/NOTES.md b/71-simplify-path/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/71-simplify-path/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/71-simplify-path/README.md b/71-simplify-path/README.md
new file mode 100644
index 0000000..743871b
--- /dev/null
+++ b/71-simplify-path/README.md
@@ -0,0 +1,46 @@
+<h2><a href="https://leetcode.com/problems/simplify-path/">71. Simplify Path</a></h2><h3>Medium</h3><hr><div><p>Given a string <code>path</code>, which is an <strong>absolute path</strong> (starting with a slash <code>'/'</code>) to a file or directory in a Unix-style file system, convert it to the simplified <strong>canonical path</strong>.</p>
+
+<p>In a Unix-style file system, a period <code>'.'</code> refers to the current directory, a double period <code>'..'</code> refers to the directory up a level, and any multiple consecutive slashes (i.e. <code>'//'</code>) are treated as a single slash <code>'/'</code>. For this problem, any other format of periods such as <code>'...'</code> are treated as file/directory names.</p>
+
+<p>The <strong>canonical path</strong> should have the following format:</p>
+
+<ul>
+	<li>The path starts with a single slash <code>'/'</code>.</li>
+	<li>Any two directories are separated by a single slash <code>'/'</code>.</li>
+	<li>The path does not end with a trailing <code>'/'</code>.</li>
+	<li>The path only contains the directories on the path from the root directory to the target file or directory (i.e., no period <code>'.'</code> or double period <code>'..'</code>)</li>
+</ul>
+
+<p>Return <em>the simplified <strong>canonical path</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> path = "/home/"
+<strong>Output:</strong> "/home"
+<strong>Explanation:</strong> Note that there is no trailing slash after the last directory name.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> path = "/../"
+<strong>Output:</strong> "/"
+<strong>Explanation:</strong> Going one level up from the root directory is a no-op, as the root level is the highest level you can go.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> path = "/home//foo/"
+<strong>Output:</strong> "/home/foo"
+<strong>Explanation:</strong> In the canonical path, multiple consecutive slashes are replaced by a single one.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= path.length &lt;= 3000</code></li>
+	<li><code>path</code> consists of English letters, digits, period <code>'.'</code>, slash <code>'/'</code> or <code>'_'</code>.</li>
+	<li><code>path</code> is a valid absolute Unix path.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/724-find-pivot-index/724-find-pivot-index.cpp b/724-find-pivot-index/724-find-pivot-index.cpp
new file mode 100644
index 0000000..8c20b83
--- /dev/null
+++ b/724-find-pivot-index/724-find-pivot-index.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int pivotIndex(vector<int>& nums) {
+        int sum = 0;
+        for(int i=0;i<nums.size();i++)
+            sum+=nums[i];
+        
+        int curr = 0;
+        for(int i=0;i<nums.size();i++)
+        {
+            sum -= nums[i];
+            if(curr == sum)
+                return i;
+            curr+= nums[i];
+        }
+        return -1;
+    }
+};
\ No newline at end of file
diff --git a/724-find-pivot-index/NOTES.md b/724-find-pivot-index/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/724-find-pivot-index/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/724-find-pivot-index/README.md b/724-find-pivot-index/README.md
new file mode 100644
index 0000000..0f9c0a4
--- /dev/null
+++ b/724-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 -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/74-search-a-2d-matrix/74-search-a-2d-matrix.cpp b/74-search-a-2d-matrix/74-search-a-2d-matrix.cpp
new file mode 100644
index 0000000..e853dd7
--- /dev/null
+++ b/74-search-a-2d-matrix/74-search-a-2d-matrix.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    bool searchMatrix(vector<vector<int>>& matrix, int target) {
+        
+        int n = matrix.size();
+        int m = matrix[0].size();
+        int i = 0;
+        int j = (m*n) - 1;
+        
+        while(i<=j)
+        {
+            int mid = i + (j-i)/2;
+            
+            int num = matrix[mid / m][mid % m];
+            if(num == target)
+                return true;
+            else if(num > target)
+                j = mid - 1;
+            else
+                i = mid + 1;
+        }
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/74-search-a-2d-matrix/NOTES.md b/74-search-a-2d-matrix/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/74-search-a-2d-matrix/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/74-search-a-2d-matrix/README.md b/74-search-a-2d-matrix/README.md
new file mode 100644
index 0000000..da1b358
--- /dev/null
+++ b/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 <code>target</code> in an <code>m x n</code> integer matrix <code>matrix</code>. 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/740-delete-and-earn/740-delete-and-earn.cpp b/740-delete-and-earn/740-delete-and-earn.cpp
new file mode 100644
index 0000000..82a73ac
--- /dev/null
+++ b/740-delete-and-earn/740-delete-and-earn.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int deleteAndEarn(vector<int>& nums) {
+        int n = 10001;
+        vector<int> values(n, 0);
+        for (int num : nums)
+            values[num] += num;
+
+        int take = 0, skip = 0;
+        for (int i = 0; i < n; i++) {
+            int takei = skip + values[i];
+            int skipi = max(skip, take);
+            take = takei;
+            skip = skipi;
+        }
+        return max(take, skip);
+    }
+};
\ No newline at end of file
diff --git a/740-delete-and-earn/NOTES.md b/740-delete-and-earn/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/740-delete-and-earn/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/740-delete-and-earn/README.md b/740-delete-and-earn/README.md
new file mode 100644
index 0000000..8cab44f
--- /dev/null
+++ b/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/746-min-cost-climbing-stairs/746-min-cost-climbing-stairs.cpp b/746-min-cost-climbing-stairs/746-min-cost-climbing-stairs.cpp
new file mode 100644
index 0000000..d20cb68
--- /dev/null
+++ b/746-min-cost-climbing-stairs/746-min-cost-climbing-stairs.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int minCostClimbingStairs(vector<int>& cost) {
+        vector<int> dp(cost.size());
+        int n = cost.size();
+        dp[n-1] = cost[n-1];
+        dp[n-2] = cost[n-2];
+        
+        if(n == 2)return min(dp[n-1],dp[n-2]);
+        
+        for(int i=n-3;i>=0;i--)
+        {
+            dp[i] = min(dp[i+1],dp[i+2])+cost[i];
+        }
+        return min(dp[1],dp[0]);
+    }
+};
\ No newline at end of file
diff --git a/75-sort-colors/75-sort-colors.cpp b/75-sort-colors/75-sort-colors.cpp
new file mode 100644
index 0000000..cb8a529
--- /dev/null
+++ b/75-sort-colors/75-sort-colors.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    void sortColors(vector<int>& nums) {
+        
+        int zero = 0;
+        int one = 0;
+        int two = 0;
+        
+        for(int i=0;i<nums.size();i++)
+        {
+            if(nums[i]==0)zero++;
+            else if(nums[i]==1)one++;
+            else two++;
+        }
+        int i = 0;
+        while(zero--)
+            nums[i++] = 0;
+         while(one--)
+            nums[i++] = 1;
+         while(two--)
+            nums[i++] = 2;
+        
+    }
+};
\ No newline at end of file
diff --git a/75-sort-colors/NOTES.md b/75-sort-colors/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/75-sort-colors/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/75-sort-colors/README.md b/75-sort-colors/README.md
new file mode 100644
index 0000000..2505728
--- /dev/null
+++ b/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/763-partition-labels/763-partition-labels.cpp b/763-partition-labels/763-partition-labels.cpp
new file mode 100644
index 0000000..b023fe5
--- /dev/null
+++ b/763-partition-labels/763-partition-labels.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    vector<int> partitionLabels(string s) {
+        vector<int> ans;
+        unordered_map<char,int> m;
+        for(int i=0;i<s.size();i++)
+            m[s[i]] = i;
+        
+        int start = 0;
+        int end = 0;
+        for(int i=0;i<s.size();i++)
+        {
+            end = max(end,m[s[i]]);
+            
+            if(i == end)
+            {
+                ans.push_back(end-start+1);
+                start = i+1;
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/763-partition-labels/NOTES.md b/763-partition-labels/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/763-partition-labels/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/763-partition-labels/README.md b/763-partition-labels/README.md
new file mode 100644
index 0000000..d2397f9
--- /dev/null
+++ b/763-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>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>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/78-subsets/78-subsets.cpp b/78-subsets/78-subsets.cpp
new file mode 100644
index 0000000..5c3cf6a
--- /dev/null
+++ b/78-subsets/78-subsets.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    vector<vector<int>> subsets(vector<int>& nums) {
+        vector<vector<int>> ans;
+        for(int num=0; num<(1<<nums.size()) ;num++  )
+        {
+            vector<int> subset;
+            for(int bit=0;bit<nums.size();bit++)
+            {
+                if(num & (1<<bit))
+                {
+                    subset.push_back(nums[bit]);
+                }
+            }
+            ans.push_back(subset);
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/78-subsets/NOTES.md b/78-subsets/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/78-subsets/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/78-subsets/README.md b/78-subsets/README.md
new file mode 100644
index 0000000..9a28b51
--- /dev/null
+++ b/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/79-word-search/79-word-search.cpp b/79-word-search/79-word-search.cpp
new file mode 100644
index 0000000..d8efd7d
--- /dev/null
+++ b/79-word-search/79-word-search.cpp
@@ -0,0 +1,38 @@
+class Solution {
+public:
+    
+    bool doesExist(vector<vector<char>>& board, string word,int i,int j,int m,int n)
+    {
+        if(word.size() == 0)
+            return true;
+        
+        if(i>=n || i<0 || j>=m || j< 0 || word[0] != board[i][j])
+            return false;
+        
+        char c = board[i][j];
+        board[i][j] = '*';
+        string s = word.substr(1);
+        bool top = doesExist(board,s,i,j+1,m,n);
+        bool bottom = doesExist(board,s,i,j-1,m,n);
+        bool left = doesExist(board,s,i-1,j,m,n);
+        bool right = doesExist(board,s,i+1,j,m,n);
+        board[i][j] = c;
+        return top || bottom || left || right;
+    }
+    
+    bool exist(vector<vector<char>>& board, string word) {
+        
+        int n = board.size();
+        int m = board[0].size();
+        
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<m;j++)
+            {
+                if(doesExist(board,word,i,j,m,n))
+                    return true;
+            }
+        }
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/79-word-search/NOTES.md b/79-word-search/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/79-word-search/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/79-word-search/README.md b/79-word-search/README.md
new file mode 100644
index 0000000..d9c5c62
--- /dev/null
+++ b/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/8-string-to-integer-atoi/8-string-to-integer-atoi.cpp b/8-string-to-integer-atoi/8-string-to-integer-atoi.cpp
new file mode 100644
index 0000000..3c01e82
--- /dev/null
+++ b/8-string-to-integer-atoi/8-string-to-integer-atoi.cpp
@@ -0,0 +1,34 @@
+class Solution {
+public:
+    int myAtoi(string input) {
+        int sign = 1; 
+        int result = 0; 
+        int index = 0;
+        int n = input.size();
+        
+        while (index < n && input[index] == ' ') { 
+            index++; 
+        }
+        
+        if (index < n && input[index] == '+') {
+            sign = 1;
+            index++;
+        } else if (index < n && input[index] == '-') {
+            sign = -1;
+            index++;
+        }
+        
+        while (index < n && isdigit(input[index])) {
+            int digit = input[index] - '0';
+
+            if ((result > INT_MAX / 10) || (result == INT_MAX / 10 && digit > INT_MAX % 10)) { 
+                  
+                return sign == 1 ? INT_MAX : INT_MIN;
+            }
+            result = 10 * result + digit;
+            index++;
+        }
+        
+        return sign * result;
+    }
+};
\ No newline at end of file
diff --git a/8-string-to-integer-atoi/NOTES.md b/8-string-to-integer-atoi/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/8-string-to-integer-atoi/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/8-string-to-integer-atoi/README.md b/8-string-to-integer-atoi/README.md
new file mode 100644
index 0000000..3866ace
--- /dev/null
+++ b/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/80-remove-duplicates-from-sorted-array-ii/80-remove-duplicates-from-sorted-array-ii.cpp b/80-remove-duplicates-from-sorted-array-ii/80-remove-duplicates-from-sorted-array-ii.cpp
new file mode 100644
index 0000000..4695f55
--- /dev/null
+++ b/80-remove-duplicates-from-sorted-array-ii/80-remove-duplicates-from-sorted-array-ii.cpp
@@ -0,0 +1,10 @@
+class Solution {
+public:
+  int removeDuplicates(vector<int>& nums) {
+    int n = nums.size(), count = 0;
+    for (int i = 2; i < n; i++)
+        if (nums[i] == nums[i - 2 - count]) count++;
+        else nums[i - count] = nums[i];
+    return n - count;
+}
+};
\ No newline at end of file
diff --git a/80-remove-duplicates-from-sorted-array-ii/NOTES.md b/80-remove-duplicates-from-sorted-array-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/80-remove-duplicates-from-sorted-array-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/80-remove-duplicates-from-sorted-array-ii/README.md b/80-remove-duplicates-from-sorted-array-ii/README.md
new file mode 100644
index 0000000..a22298a
--- /dev/null
+++ b/80-remove-duplicates-from-sorted-array-ii/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/">80. Remove Duplicates from Sorted Array II</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> sorted in <strong>non-decreasing order</strong>, remove some duplicates <a href="https://en.wikipedia.org/wiki/In-place_algorithm" target="_blank"><strong>in-place</strong></a> such that each unique element appears <strong>at most twice</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,1,2,2,3]
+<strong>Output:</strong> 5, nums = [1,1,2,2,3,_]
+<strong>Explanation:</strong> Your function should return k = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 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,1,2,3,3]
+<strong>Output:</strong> 7, nums = [0,0,1,1,2,3,3,_,_]
+<strong>Explanation:</strong> Your function should return k = 7, with the first seven elements of nums being 0, 0, 1, 1, 2, 3 and 3 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>1 &lt;= nums.length &lt;= 3 * 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 <strong>non-decreasing</strong> order.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/804-unique-morse-code-words/NOTES.md b/804-unique-morse-code-words/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/804-unique-morse-code-words/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/804-unique-morse-code-words/README.md b/804-unique-morse-code-words/README.md
new file mode 100644
index 0000000..7999f9d
--- /dev/null
+++ b/804-unique-morse-code-words/README.md
@@ -0,0 +1,48 @@
+<h2><a href="https://leetcode.com/problems/unique-morse-code-words/">804. Unique Morse Code Words</a></h2><h3>Easy</h3><hr><div><p>International Morse Code defines a standard encoding where each letter is mapped to a series of dots and dashes, as follows:</p>
+
+<ul>
+	<li><code>'a'</code> maps to <code>".-"</code>,</li>
+	<li><code>'b'</code> maps to <code>"-..."</code>,</li>
+	<li><code>'c'</code> maps to <code>"-.-."</code>, and so on.</li>
+</ul>
+
+<p>For convenience, the full table for the <code>26</code> letters of the English alphabet is given below:</p>
+
+<pre>[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]</pre>
+
+<p>Given an array of strings <code>words</code> where each word can be written as a concatenation of the Morse code of each letter.</p>
+
+<ul>
+	<li>For example, <code>"cab"</code> can be written as <code>"-.-..--..."</code>, which is the concatenation of <code>"-.-."</code>, <code>".-"</code>, and <code>"-..."</code>. We will call such a concatenation the <strong>transformation</strong> of a word.</li>
+</ul>
+
+<p>Return <em>the number of different <strong>transformations</strong> among all words we have</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> words = ["gin","zen","gig","msg"]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The transformation of each word is:
+"gin" -&gt; "--...-."
+"zen" -&gt; "--...-."
+"gig" -&gt; "--...--."
+"msg" -&gt; "--...--."
+There are 2 different transformations: "--...-." and "--...--.".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words = ["a"]
+<strong>Output:</strong> 1
+</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;= 12</code></li>
+	<li><code>words[i]</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/82-remove-duplicates-from-sorted-list-ii/82-remove-duplicates-from-sorted-list-ii.cpp b/82-remove-duplicates-from-sorted-list-ii/82-remove-duplicates-from-sorted-list-ii.cpp
new file mode 100644
index 0000000..fb70afb
--- /dev/null
+++ b/82-remove-duplicates-from-sorted-list-ii/82-remove-duplicates-from-sorted-list-ii.cpp
@@ -0,0 +1,42 @@
+/**
+ * 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 == NULL || head->next == NULL)return head;
+        ListNode *  ans = new ListNode();
+        ListNode * temp = ans;
+        
+        if(head->next->val != head->val)
+        {
+            ans->next = head;
+            head = head->next;
+            ans = ans->next;
+            ans->next = deleteDuplicates(head);
+            return temp->next;
+        }
+        else
+        {
+            while(head->next != NULL && head->val == head->next->val)
+                head = head->next;
+            
+            if(head->next == NULL)
+            {
+                return temp->next;
+            }
+            else
+            {
+                head = head->next;
+                return deleteDuplicates(head);
+            }
+        }
+    }
+};
\ No newline at end of file
diff --git a/82-remove-duplicates-from-sorted-list-ii/NOTES.md b/82-remove-duplicates-from-sorted-list-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/82-remove-duplicates-from-sorted-list-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/82-remove-duplicates-from-sorted-list-ii/README.md b/82-remove-duplicates-from-sorted-list-ii/README.md
new file mode 100644
index 0000000..f981c5f
--- /dev/null
+++ b/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/823-binary-trees-with-factors/NOTES.md b/823-binary-trees-with-factors/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/823-binary-trees-with-factors/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/823-binary-trees-with-factors/README.md b/823-binary-trees-with-factors/README.md
new file mode 100644
index 0000000..64dd47c
--- /dev/null
+++ b/823-binary-trees-with-factors/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/binary-trees-with-factors/">823. Binary Trees With Factors</a></h2><h3>Medium</h3><hr><div><p>Given an array of unique integers, <code>arr</code>, where each integer <code>arr[i]</code> is strictly greater than <code>1</code>.</p>
+
+<p>We make a binary tree using these integers, and each number may be used for any number of times. Each non-leaf node's value should be equal to the product of the values of its children.</p>
+
+<p>Return <em>the number of binary trees we can make</em>. The answer may be too large so return the answer <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [2,4]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> We can make these trees: <code>[2], [4], [4, 2, 2]</code></pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [2,4,5,10]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> We can make these trees: <code>[2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2]</code>.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 1000</code></li>
+	<li><code>2 &lt;= arr[i] &lt;= 10<sup>9</sup></code></li>
+	<li>All the values of <code>arr</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/84-largest-rectangle-in-histogram/84-largest-rectangle-in-histogram.cpp b/84-largest-rectangle-in-histogram/84-largest-rectangle-in-histogram.cpp
new file mode 100644
index 0000000..df44f3b
--- /dev/null
+++ b/84-largest-rectangle-in-histogram/84-largest-rectangle-in-histogram.cpp
@@ -0,0 +1,72 @@
+class Solution {
+public:
+    int largestRectangleArea(vector<int>& heights) {
+         int n = heights.size();
+         stack<int> s;
+        int maxi = 0;
+        
+        for(int i=0;i<=n;i++)
+        {
+            while(!s.empty() && (i == n || heights[s.top()] >= heights[i]))
+            {
+                int height = heights[s.top()];
+                s.pop();
+                int w;
+                if(s.empty()) w = i;
+                else
+                {
+                    w = i - s.top() - 1;
+                }
+                maxi = max(maxi,height*w);
+            }
+            s.push(i);
+        }
+        return maxi;
+        
+//           int n = heights.size();
+//          stack<int> s;
+//         vector<int> left(n);
+//         vector<int> right(n);
+        
+//         for(int i=0;i<n;i++)
+//         {
+//             while(!s.empty() && heights[s.top()] >= heights[i] )
+//             {
+//                 s.pop();
+//             }
+//             if(s.empty())
+//                 left[i] = 0;
+//             else
+//                 left[i] = s.top()+1;
+            
+//             s.push(i);
+//         }
+//         while(!s.empty()) s.pop();
+//         for(int i=n-1;i>=0;i--)
+//         {
+//             while(!s.empty() && heights[s.top()] >= heights[i])
+//             {
+//                 s.pop();
+//             }
+//             if(s.empty())
+//             {
+//                 right[i] = n-1;
+//             }
+//             else
+//             {
+//                 right[i] = s.top()-1;
+//             }
+            
+//             s.push(i);
+//         }
+//         int maxi = INT_MIN;
+//         for(int i=0;i<n;i++)
+//         {
+//           maxi = max(maxi, (right[i] - left[i] + 1) * heights[i]);  
+//         }
+        
+//         return maxi == INT_MIN ? 0 : maxi;
+        
+        
+    }
+};
\ No newline at end of file
diff --git a/84-largest-rectangle-in-histogram/NOTES.md b/84-largest-rectangle-in-histogram/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/84-largest-rectangle-in-histogram/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/84-largest-rectangle-in-histogram/README.md b/84-largest-rectangle-in-histogram/README.md
new file mode 100644
index 0000000..ab28361
--- /dev/null
+++ b/84-largest-rectangle-in-histogram/README.md
@@ -0,0 +1,25 @@
+<h2><a href="https://leetcode.com/problems/largest-rectangle-in-histogram/">84. Largest Rectangle in Histogram</a></h2><h3>Hard</h3><hr><div><p>Given an array of integers <code>heights</code> representing the histogram's bar height where the width of each bar is <code>1</code>, return <em>the area of the largest rectangle in the histogram</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/histogram.jpg" style="width: 522px; height: 242px;">
+<pre><strong>Input:</strong> heights = [2,1,5,6,2,3]
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> The above is a histogram where width of each bar is 1.
+The largest rectangle is shown in the red area, which has an area = 10 units.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/histogram-1.jpg" style="width: 202px; height: 362px;">
+<pre><strong>Input:</strong> heights = [2,4]
+<strong>Output:</strong> 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= heights.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= heights[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/847-shortest-path-visiting-all-nodes/NOTES.md b/847-shortest-path-visiting-all-nodes/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/847-shortest-path-visiting-all-nodes/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/847-shortest-path-visiting-all-nodes/README.md b/847-shortest-path-visiting-all-nodes/README.md
new file mode 100644
index 0000000..6b6a4b1
--- /dev/null
+++ b/847-shortest-path-visiting-all-nodes/README.md
@@ -0,0 +1,31 @@
+<h2><a href="https://leetcode.com/problems/shortest-path-visiting-all-nodes/">847. Shortest Path Visiting All Nodes</a></h2><h3>Hard</h3><hr><div><p>You have an undirected, connected graph of <code>n</code> nodes labeled from <code>0</code> to <code>n - 1</code>. You are given an array <code>graph</code> where <code>graph[i]</code> is a list of all the nodes connected with node <code>i</code> by an edge.</p>
+
+<p>Return <em>the length of the shortest path that visits every node</em>. You may start and stop at any node, you may revisit nodes multiple times, and you may reuse edges.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/05/12/shortest1-graph.jpg" style="width: 222px; height: 183px;">
+<pre><strong>Input:</strong> graph = [[1,2,3],[0],[0],[0]]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> One possible path is [1,0,2,0,3]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/05/12/shortest2-graph.jpg" style="width: 382px; height: 222px;">
+<pre><strong>Input:</strong> graph = [[1],[0,2,4],[1,3,4],[2],[1,2]]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> One possible path is [0,1,4,2,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == graph.length</code></li>
+	<li><code>1 &lt;= n &lt;= 12</code></li>
+	<li><code>0 &lt;= graph[i].length &lt;&nbsp;n</code></li>
+	<li><code>graph[i]</code> does not contain <code>i</code>.</li>
+	<li>If <code>graph[a]</code> contains <code>b</code>, then <code>graph[b]</code> contains <code>a</code>.</li>
+	<li>The input graph is always connected.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/856-score-of-parentheses/856-score-of-parentheses.cpp b/856-score-of-parentheses/856-score-of-parentheses.cpp
new file mode 100644
index 0000000..51744e5
--- /dev/null
+++ b/856-score-of-parentheses/856-score-of-parentheses.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int scoreOfParentheses(string s) {
+        int depth = 0, res = 0;
+        char prev = '(';
+        
+        for (const char &ch: s) {
+            if (ch == '(')
+                depth++;
+            else {
+                depth--;
+                if (prev == '(')
+                    res += pow(2, depth);
+            }
+            
+            prev = ch;
+        }
+        
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/856-score-of-parentheses/NOTES.md b/856-score-of-parentheses/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/856-score-of-parentheses/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/856-score-of-parentheses/README.md b/856-score-of-parentheses/README.md
new file mode 100644
index 0000000..365c40c
--- /dev/null
+++ b/856-score-of-parentheses/README.md
@@ -0,0 +1,38 @@
+<h2><a href="https://leetcode.com/problems/score-of-parentheses/">856. Score of Parentheses</a></h2><h3>Medium</h3><hr><div><p>Given a balanced parentheses string <code>s</code>, return <em>the <strong>score</strong> of the string</em>.</p>
+
+<p>The <strong>score</strong> of a balanced parentheses string is based on the following rule:</p>
+
+<ul>
+	<li><code>"()"</code> has score <code>1</code>.</li>
+	<li><code>AB</code> has score <code>A + B</code>, where <code>A</code> and <code>B</code> are balanced parentheses strings.</li>
+	<li><code>(A)</code> has score <code>2 * A</code>, where <code>A</code> is a balanced parentheses string.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "()"
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "(())"
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "()()"
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= s.length &lt;= 50</code></li>
+	<li><code>s</code> consists of only <code>'('</code> and <code>')'</code>.</li>
+	<li><code>s</code> is a balanced parentheses string.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/858-mirror-reflection/NOTES.md b/858-mirror-reflection/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/858-mirror-reflection/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/858-mirror-reflection/README.md b/858-mirror-reflection/README.md
new file mode 100644
index 0000000..4d94fe5
--- /dev/null
+++ b/858-mirror-reflection/README.md
@@ -0,0 +1,29 @@
+<h2><a href="https://leetcode.com/problems/mirror-reflection/">858. Mirror Reflection</a></h2><h3>Medium</h3><hr><div><p>There is a special square room with mirrors on each of the four walls. Except for the southwest corner, there are receptors on each of the remaining corners, numbered <code>0</code>, <code>1</code>, and <code>2</code>.</p>
+
+<p>The square room has walls of length <code>p</code>&nbsp;and a laser ray from the southwest corner first meets the east wall at a distance <code>q</code> from the <code>0<sup>th</sup></code> receptor.</p>
+
+<p>Given the two integers <code>p</code> and <code>q</code>, return <em>the number of the receptor that the ray meets first</em>.</p>
+
+<p>The test cases are guaranteed so that the ray will meet a receptor eventually.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/06/18/reflection.png" style="width: 218px; height: 217px;">
+<pre><strong>Input:</strong> p = 2, q = 1
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The ray meets receptor 2 the first time it gets reflected back to the left wall.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> p = 3, q = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= q &lt;= p &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/875-koko-eating-bananas/875-koko-eating-bananas.cpp b/875-koko-eating-bananas/875-koko-eating-bananas.cpp
new file mode 100644
index 0000000..bf8c68d
--- /dev/null
+++ b/875-koko-eating-bananas/875-koko-eating-bananas.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int minEatingSpeed(vector<int>& piles, int h) {     
+        int left = 1, right = *max_element(piles.begin(), piles.end());
+
+        while (left < right) {
+            int middle = (left + right) / 2;
+            int hourSpent = 0;
+
+            for (int pile : piles) {
+                hourSpent += pile / middle + (pile % middle != 0);
+            }
+            if (hourSpent <= h) {
+                right = middle;
+            } else {
+                left = middle + 1;
+            }
+        }
+
+        return right;
+    }
+};
diff --git a/876-middle-of-the-linked-list/876-middle-of-the-linked-list.cpp b/876-middle-of-the-linked-list/876-middle-of-the-linked-list.cpp
new file mode 100644
index 0000000..a0dac35
--- /dev/null
+++ b/876-middle-of-the-linked-list/876-middle-of-the-linked-list.cpp
@@ -0,0 +1,26 @@
+/**
+ * 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* middleNode(ListNode* head) {
+        if(head == NULL || head->next == NULL)return 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/881-boats-to-save-people/881-boats-to-save-people.cpp b/881-boats-to-save-people/881-boats-to-save-people.cpp
new file mode 100644
index 0000000..1ebdae6
--- /dev/null
+++ b/881-boats-to-save-people/881-boats-to-save-people.cpp
@@ -0,0 +1,27 @@
+class Solution {
+public:
+    int numRescueBoats(vector<int>& people, int limit) {
+        sort(people.begin(),people.end());
+        int i=0;
+        int j=people.size()-1;
+        int ans = 0;
+        while(i<j)
+        {
+            if(people[i]+people[j]>limit)
+            {
+                ans+=1;
+                j--;
+            }
+            else
+            {
+                ans+=1;
+                i++;
+                j--;
+            }
+        }
+        
+        if(i==j)ans++;
+        
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/881-boats-to-save-people/NOTES.md b/881-boats-to-save-people/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/881-boats-to-save-people/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/881-boats-to-save-people/README.md b/881-boats-to-save-people/README.md
new file mode 100644
index 0000000..919904d
--- /dev/null
+++ b/881-boats-to-save-people/README.md
@@ -0,0 +1,34 @@
+<h2><a href="https://leetcode.com/problems/boats-to-save-people/">881. Boats to Save People</a></h2><h3>Medium</h3><hr><div><p>You are given an array <code>people</code> where <code>people[i]</code> is the weight of the <code>i<sup>th</sup></code> person, and an <strong>infinite number of boats</strong> where each boat can carry a maximum weight of <code>limit</code>. Each boat carries at most two people at the same time, provided the sum of the weight of those people is at most <code>limit</code>.</p>
+
+<p>Return <em>the minimum number of boats to carry every given person</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> people = [1,2], limit = 3
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> 1 boat (1, 2)
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> people = [3,2,2,1], limit = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 3 boats (1, 2), (2) and (3)
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> people = [3,5,3,4], limit = 5
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> 4 boats (3), (3), (4), (5)
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= people.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= people[i] &lt;= limit &lt;= 3 * 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/890-find-and-replace-pattern/890-find-and-replace-pattern.cpp b/890-find-and-replace-pattern/890-find-and-replace-pattern.cpp
new file mode 100644
index 0000000..0d59f4f
--- /dev/null
+++ b/890-find-and-replace-pattern/890-find-and-replace-pattern.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+  vector<string> findAndReplacePattern(vector<string>& words, string& pattern) {        
+	vector<string> ans;
+	string p = normalise(pattern);
+	for(auto& w : words) 
+		if(p == normalise(w)) ans.push_back(w);
+	return ans;
+}
+string normalise(string w) {
+	unordered_map<char, char> mp;
+	char c = 'a';
+	for(auto ch : w) 
+		if(!mp.count(ch)) mp[ch] = c++;
+	for(auto& ch : w) ch = mp[ch];
+	return w;
+}
+};
\ No newline at end of file
diff --git a/890-find-and-replace-pattern/NOTES.md b/890-find-and-replace-pattern/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/890-find-and-replace-pattern/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/890-find-and-replace-pattern/README.md b/890-find-and-replace-pattern/README.md
new file mode 100644
index 0000000..0866cb1
--- /dev/null
+++ b/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/895-maximum-frequency-stack/895-maximum-frequency-stack.cpp b/895-maximum-frequency-stack/895-maximum-frequency-stack.cpp
new file mode 100644
index 0000000..c25895f
--- /dev/null
+++ b/895-maximum-frequency-stack/895-maximum-frequency-stack.cpp
@@ -0,0 +1,23 @@
+class FreqStack {
+   priority_queue<pair<int, pair<int, int>>> q;
+    unordered_map<int, int> freq;
+    int pos = 0;
+public:
+    void push(int x) {
+        q.emplace(++freq[x], make_pair(++pos, x));
+    }
+    
+    int pop() {
+        auto val = q.top();
+        q.pop();
+        int x = val.second.second;
+        freq[x]--;
+        return x;
+    }
+};
+/**
+ * Your FreqStack object will be instantiated and called as such:
+ * FreqStack* obj = new FreqStack();
+ * obj->push(val);
+ * int param_2 = obj->pop();
+ */
\ No newline at end of file
diff --git a/895-maximum-frequency-stack/NOTES.md b/895-maximum-frequency-stack/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/895-maximum-frequency-stack/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/895-maximum-frequency-stack/README.md b/895-maximum-frequency-stack/README.md
new file mode 100644
index 0000000..00870ce
--- /dev/null
+++ b/895-maximum-frequency-stack/README.md
@@ -0,0 +1,46 @@
+<h2><a href="https://leetcode.com/problems/maximum-frequency-stack/">895. Maximum Frequency Stack</a></h2><h3>Hard</h3><hr><div><p>Design a stack-like data structure to push elements to the stack and pop the most frequent element from the stack.</p>
+
+<p>Implement the <code>FreqStack</code> class:</p>
+
+<ul>
+	<li><code>FreqStack()</code> constructs an empty frequency stack.</li>
+	<li><code>void push(int val)</code> pushes an integer <code>val</code> onto the top of the stack.</li>
+	<li><code>int pop()</code> removes and returns the most frequent element in the stack.
+	<ul>
+		<li>If there is a tie for the most frequent element, the element closest to the stack's top is removed and returned.</li>
+	</ul>
+	</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["FreqStack", "push", "push", "push", "push", "push", "push", "pop", "pop", "pop", "pop"]
+[[], [5], [7], [5], [7], [4], [5], [], [], [], []]
+<strong>Output</strong>
+[null, null, null, null, null, null, null, 5, 7, 5, 4]
+
+<strong>Explanation</strong>
+FreqStack freqStack = new FreqStack();
+freqStack.push(5); // The stack is [5]
+freqStack.push(7); // The stack is [5,7]
+freqStack.push(5); // The stack is [5,7,5]
+freqStack.push(7); // The stack is [5,7,5,7]
+freqStack.push(4); // The stack is [5,7,5,7,4]
+freqStack.push(5); // The stack is [5,7,5,7,4,5]
+freqStack.pop();   // return 5, as 5 is the most frequent. The stack becomes [5,7,5,7,4].
+freqStack.pop();   // return 7, as 5 and 7 is the most frequent, but 7 is closest to the top. The stack becomes [5,7,5,4].
+freqStack.pop();   // return 5, as 5 is the most frequent. The stack becomes [5,7,4].
+freqStack.pop();   // return 4, as 4, 5 and 7 is the most frequent, but 4 is closest to the top. The stack becomes [5,7].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= val &lt;= 10<sup>9</sup></code></li>
+	<li>At most <code>2 * 10<sup>4</sup></code> calls will be made to <code>push</code> and <code>pop</code>.</li>
+	<li>It is guaranteed that there will be at least one element in the stack before calling <code>pop</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/90-subsets-ii/90-subsets-ii.cpp b/90-subsets-ii/90-subsets-ii.cpp
new file mode 100644
index 0000000..68ad33e
--- /dev/null
+++ b/90-subsets-ii/90-subsets-ii.cpp
@@ -0,0 +1,28 @@
+class Solution {
+public:
+    void helper(vector<int>& nums,vector<vector<int>>& ans,vector<int>& temp,int ind)
+    {
+            ans.push_back(temp);
+    
+        for(int i=ind;i !=nums.size();i++)
+        {
+            if(i == ind || nums[i]!=nums[i-1])
+            {
+            temp.push_back(nums[i]);
+            helper(nums,ans,temp,i+1);
+            temp.pop_back();
+            }
+           
+        }
+        
+    }
+    
+    
+    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
+        sort(nums.begin(),nums.end());
+        vector<vector<int>> ans;
+        vector<int> temp;
+        helper(nums,ans,temp,0);
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/90-subsets-ii/NOTES.md b/90-subsets-ii/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/90-subsets-ii/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/90-subsets-ii/README.md b/90-subsets-ii/README.md
new file mode 100644
index 0000000..975b739
--- /dev/null
+++ b/90-subsets-ii/README.md
@@ -0,0 +1,20 @@
+<h2><a href="https://leetcode.com/problems/subsets-ii/">90. Subsets II</a></h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code> that may contain duplicates, 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,2]
+<strong>Output:</strong> [[],[1],[1,2],[1,2,2],[2],[2,2]]
+</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>
+</ul>
+</div>
\ No newline at end of file
diff --git a/916-word-subsets/NOTES.md b/916-word-subsets/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/916-word-subsets/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/916-word-subsets/README.md b/916-word-subsets/README.md
new file mode 100644
index 0000000..e09ef82
--- /dev/null
+++ b/916-word-subsets/README.md
@@ -0,0 +1,35 @@
+<h2><a href="https://leetcode.com/problems/word-subsets/">916. Word Subsets</a></h2><h3>Medium</h3><hr><div><p>You are given two string arrays <code>words1</code> and <code>words2</code>.</p>
+
+<p>A string <code>b</code> is a <strong>subset</strong> of string <code>a</code> if every letter in <code>b</code> occurs in <code>a</code> including multiplicity.</p>
+
+<ul>
+	<li>For example, <code>"wrr"</code> is a subset of <code>"warrior"</code> but is not a subset of <code>"world"</code>.</li>
+</ul>
+
+<p>A string <code>a</code> from <code>words1</code> is <strong>universal</strong> if for every string <code>b</code> in <code>words2</code>, <code>b</code> is a subset of <code>a</code>.</p>
+
+<p>Return an array of all the <strong>universal</strong> strings in <code>words1</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> words1 = ["amazon","apple","facebook","google","leetcode"], words2 = ["e","o"]
+<strong>Output:</strong> ["facebook","google","leetcode"]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words1 = ["amazon","apple","facebook","google","leetcode"], words2 = ["l","e"]
+<strong>Output:</strong> ["apple","google","leetcode"]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= words1.length, words2.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= words1[i].length, words2[i].length &lt;= 10</code></li>
+	<li><code>words1[i]</code> and <code>words2[i]</code> consist only of lowercase English letters.</li>
+	<li>All the strings of <code>words1</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/921-minimum-add-to-make-parentheses-valid/NOTES.md b/921-minimum-add-to-make-parentheses-valid/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/921-minimum-add-to-make-parentheses-valid/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/921-minimum-add-to-make-parentheses-valid/README.md b/921-minimum-add-to-make-parentheses-valid/README.md
new file mode 100644
index 0000000..45c6664
--- /dev/null
+++ b/921-minimum-add-to-make-parentheses-valid/README.md
@@ -0,0 +1,37 @@
+<h2><a href="https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/">921. Minimum Add to Make Parentheses Valid</a></h2><h3>Medium</h3><hr><div><p>A parentheses string is valid if and only if:</p>
+
+<ul>
+	<li>It is the empty string,</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>You are given a parentheses string <code>s</code>. In one move, you can insert a parenthesis at any position of the string.</p>
+
+<ul>
+	<li>For example, if <code>s = "()))"</code>, you can insert an opening parenthesis to be <code>"(<strong>(</strong>)))"</code> or a closing parenthesis to be <code>"())<strong>)</strong>)"</code>.</li>
+</ul>
+
+<p>Return <em>the minimum number of moves required to make </em><code>s</code><em> valid</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "())"
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "((("
+<strong>Output:</strong> 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 1000</code></li>
+	<li><code>s[i]</code> is either <code>'('</code> or <code>')'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/946-validate-stack-sequences/946-validate-stack-sequences.cpp b/946-validate-stack-sequences/946-validate-stack-sequences.cpp
new file mode 100644
index 0000000..56343be
--- /dev/null
+++ b/946-validate-stack-sequences/946-validate-stack-sequences.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+   bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
+        stack<int> stack;
+        int i = 0;
+        for (int x : pushed) {
+            stack.push(x);
+            while (stack.size() && stack.top() == popped[i]) {
+                stack.pop();
+                i++;
+            }
+        }
+        return stack.size() ==0 ;
+   }
+};
\ No newline at end of file
diff --git a/946-validate-stack-sequences/NOTES.md b/946-validate-stack-sequences/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/946-validate-stack-sequences/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/946-validate-stack-sequences/README.md b/946-validate-stack-sequences/README.md
new file mode 100644
index 0000000..7f03a3a
--- /dev/null
+++ b/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/977-squares-of-a-sorted-array/977-squares-of-a-sorted-array.cpp b/977-squares-of-a-sorted-array/977-squares-of-a-sorted-array.cpp
new file mode 100644
index 0000000..9a60d78
--- /dev/null
+++ b/977-squares-of-a-sorted-array/977-squares-of-a-sorted-array.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    vector<int> sortedSquares(vector<int>& nums) {
+        
+        
+        int i = 0;
+        int j = nums.size()-1;
+        int k = nums.size()-1;
+        vector<int> ans(nums.size());
+        while(j>=i)
+        {
+            if(nums[j]*nums[j] < nums[i]*nums[i])
+            {
+                ans[k--] = pow(nums[i++],2);
+            }
+            else
+            {
+                ans[k--] = pow(nums[j--],2);
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/977-squares-of-a-sorted-array/NOTES.md b/977-squares-of-a-sorted-array/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/977-squares-of-a-sorted-array/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/977-squares-of-a-sorted-array/README.md b/977-squares-of-a-sorted-array/README.md
new file mode 100644
index 0000000..60339c0
--- /dev/null
+++ b/977-squares-of-a-sorted-array/README.md
@@ -0,0 +1,28 @@
+<h2><a href="https://leetcode.com/problems/squares-of-a-sorted-array/">977. Squares of a Sorted Array</a></h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> sorted in <strong>non-decreasing</strong> order, return <em>an array of <strong>the squares of each number</strong> sorted in non-decreasing order</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-4,-1,0,3,10]
+<strong>Output:</strong> [0,1,9,16,100]
+<strong>Explanation:</strong> After squaring, the array becomes [16,1,0,9,100].
+After sorting, it becomes [0,1,9,16,100].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-7,-3,2,3,11]
+<strong>Output:</strong> [4,9,9,49,121]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code><span>1 &lt;= nums.length &lt;= </span>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 <strong>non-decreasing</strong> order.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Squaring each element and sorting the new array is very trivial, could you find an <code>O(n)</code> solution using a different approach?</div>
\ No newline at end of file
diff --git a/98-validate-binary-search-tree/98-validate-binary-search-tree.cpp b/98-validate-binary-search-tree/98-validate-binary-search-tree.cpp
new file mode 100644
index 0000000..8a1081d
--- /dev/null
+++ b/98-validate-binary-search-tree/98-validate-binary-search-tree.cpp
@@ -0,0 +1,31 @@
+/**
+ * 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:
+  
+    bool helper(TreeNode* root,TreeNode * min,TreeNode * max)
+    {
+      if(root == NULL)
+        return true;
+      
+      if(min && root->val <= min->val || max && root->val >= max->val )
+        return false;
+      return helper(root->left,min,root) && helper(root->right,root,max);
+    }
+  
+    bool isValidBST(TreeNode* root) {
+      if(root == NULL)
+        return true;
+      
+      return helper(root,NULL,NULL);
+    }
+};
\ No newline at end of file
diff --git a/98-validate-binary-search-tree/NOTES.md b/98-validate-binary-search-tree/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/98-validate-binary-search-tree/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/98-validate-binary-search-tree/README.md b/98-validate-binary-search-tree/README.md
new file mode 100644
index 0000000..cf6bca1
--- /dev/null
+++ b/98-validate-binary-search-tree/README.md
@@ -0,0 +1,32 @@
+<h2><a href="https://leetcode.com/problems/validate-binary-search-tree/">98. Validate Binary Search Tree</a></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/981-time-based-key-value-store/981-time-based-key-value-store.cpp b/981-time-based-key-value-store/981-time-based-key-value-store.cpp
new file mode 100644
index 0000000..5d8024b
--- /dev/null
+++ b/981-time-based-key-value-store/981-time-based-key-value-store.cpp
@@ -0,0 +1,37 @@
+class TimeMap {
+public:
+    map<string,vector<pair<int,string>>> m; 
+    TimeMap() {
+        
+    }
+    
+    void set(string key, string value, int timestamp) {
+        m[key].push_back({timestamp,value});
+    }
+    
+    string get(string key, int timestamp) {
+        if(!m[key].size())
+            return "";
+        int low = 0;
+        int high = m[key].size()-1;
+        while(low<=high)
+        {
+            int mid = low + (high-low)/2;
+            if(m[key][mid].first == timestamp)
+                return m[key][mid].second;
+            else if(m[key][mid].first > timestamp)
+                high = mid-1;
+            else
+                low = mid + 1;
+        }
+        
+        return high >= 0 ? m[key][high].second : "";
+    }
+};
+
+/**
+ * Your TimeMap object will be instantiated and called as such:
+ * TimeMap* obj = new TimeMap();
+ * obj->set(key,value,timestamp);
+ * string param_2 = obj->get(key,timestamp);
+ */
\ No newline at end of file
diff --git a/983-minimum-cost-for-tickets/NOTES.md b/983-minimum-cost-for-tickets/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/983-minimum-cost-for-tickets/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/983-minimum-cost-for-tickets/README.md b/983-minimum-cost-for-tickets/README.md
new file mode 100644
index 0000000..9812fcc
--- /dev/null
+++ b/983-minimum-cost-for-tickets/README.md
@@ -0,0 +1,51 @@
+<h2><a href="https://leetcode.com/problems/minimum-cost-for-tickets/">983. Minimum Cost For Tickets</a></h2><h3>Medium</h3><hr><div><p>You have planned some train traveling one year in advance. The days of the year in which you will travel are given as an integer array <code>days</code>. Each day is an integer from <code>1</code> to <code>365</code>.</p>
+
+<p>Train tickets are sold in <strong>three different ways</strong>:</p>
+
+<ul>
+	<li>a <strong>1-day</strong> pass is sold for <code>costs[0]</code> dollars,</li>
+	<li>a <strong>7-day</strong> pass is sold for <code>costs[1]</code> dollars, and</li>
+	<li>a <strong>30-day</strong> pass is sold for <code>costs[2]</code> dollars.</li>
+</ul>
+
+<p>The passes allow that many days of consecutive travel.</p>
+
+<ul>
+	<li>For example, if we get a <strong>7-day</strong> pass on day <code>2</code>, then we can travel for <code>7</code> days: <code>2</code>, <code>3</code>, <code>4</code>, <code>5</code>, <code>6</code>, <code>7</code>, and <code>8</code>.</li>
+</ul>
+
+<p>Return <em>the minimum number of dollars you need to travel every day in the given list of days</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> days = [1,4,6,7,8,20], costs = [2,7,15]
+<strong>Output:</strong> 11
+<strong>Explanation:</strong> For example, here is one way to buy passes that lets you travel your travel plan:
+On day 1, you bought a 1-day pass for costs[0] = $2, which covered day 1.
+On day 3, you bought a 7-day pass for costs[1] = $7, which covered days 3, 4, ..., 9.
+On day 20, you bought a 1-day pass for costs[0] = $2, which covered day 20.
+In total, you spent $11 and covered all the days of your travel.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> days = [1,2,3,4,5,6,7,8,9,10,30,31], costs = [2,7,15]
+<strong>Output:</strong> 17
+<strong>Explanation:</strong> For example, here is one way to buy passes that lets you travel your travel plan:
+On day 1, you bought a 30-day pass for costs[2] = $15 which covered days 1, 2, ..., 30.
+On day 31, you bought a 1-day pass for costs[0] = $2 which covered day 31.
+In total, you spent $17 and covered all the days of your travel.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= days.length &lt;= 365</code></li>
+	<li><code>1 &lt;= days[i] &lt;= 365</code></li>
+	<li><code>days</code> is in strictly increasing order.</li>
+	<li><code>costs.length == 3</code></li>
+	<li><code>1 &lt;= costs[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/991-broken-calculator/991-broken-calculator.cpp b/991-broken-calculator/991-broken-calculator.cpp
new file mode 100644
index 0000000..ec7ed73
--- /dev/null
+++ b/991-broken-calculator/991-broken-calculator.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int brokenCalc(int startValue, int target) {
+        long long ans = 0;
+        long long tar = target;
+        while(startValue != tar){
+            if(tar%2 == 0 and startValue < tar){
+                tar /= 2;
+            }
+            else if(tar > startValue){
+                tar +=1;
+            }
+            else{
+                ans += abs(tar-startValue)-1;
+                tar = startValue;
+            }
+            ans++;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/991-broken-calculator/NOTES.md b/991-broken-calculator/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/991-broken-calculator/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/991-broken-calculator/README.md b/991-broken-calculator/README.md
new file mode 100644
index 0000000..c8f5264
--- /dev/null
+++ b/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/994-rotting-oranges/994-rotting-oranges.cpp b/994-rotting-oranges/994-rotting-oranges.cpp
new file mode 100644
index 0000000..a01fbd8
--- /dev/null
+++ b/994-rotting-oranges/994-rotting-oranges.cpp
@@ -0,0 +1,48 @@
+class Solution {
+public:
+    int orangesRotting(vector<vector<int>>& grid) {
+        
+        int fresh = 0;
+        queue<pair<int,int>> q;
+        int dir[] = {-1,0,1,0,-1};
+        int n = grid.size();
+        int m = grid[0].size();
+        for(int i=0;i<n;i++)
+        {
+            for(int j=0;j<m;j++)
+            {
+                if(grid[i][j] == 1)
+                    fresh++;
+                if(grid[i][j] == 2)
+                    q.push({i,j});
+            }
+        }
+        
+        int ans = -1;
+        while(!q.empty())
+        {
+            int sz = q.size();
+            while(sz--)
+            {
+                pair<int,int> p = q.front();
+                q.pop();
+                for(int i=0;i<4;i++)
+                {
+                    int r = p.first+dir[i];
+                    int c = p.second+dir[i+1];
+                    
+                    if(r>=0 && r<n && c>=0 && c<m && grid[r][c] == 1)
+                    {
+                        grid[r][c] = 2;
+                        fresh--;
+                        q.push({r,c});
+                    }
+                }
+            }
+            ans++;
+        }
+        if(fresh>0)return -1;
+        if(ans == -1)return 0;
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/994-rotting-oranges/NOTES.md b/994-rotting-oranges/NOTES.md
new file mode 100644
index 0000000..38c1374
--- /dev/null
+++ b/994-rotting-oranges/NOTES.md
@@ -0,0 +1 @@
+​
\ No newline at end of file
diff --git a/994-rotting-oranges/README.md b/994-rotting-oranges/README.md
new file mode 100644
index 0000000..75b7ad2
--- /dev/null
+++ b/994-rotting-oranges/README.md
@@ -0,0 +1,43 @@
+<h2><a href="https://leetcode.com/problems/rotting-oranges/">994. Rotting Oranges</a></h2><h3>Medium</h3><hr><div><p>You are given an <code>m x n</code> <code>grid</code> where each cell can have one of three values:</p>
+
+<ul>
+	<li><code>0</code> representing an empty cell,</li>
+	<li><code>1</code> representing a fresh orange, or</li>
+	<li><code>2</code> representing a rotten orange.</li>
+</ul>
+
+<p>Every minute, any fresh orange that is <strong>4-directionally adjacent</strong> to a rotten orange becomes rotten.</p>
+
+<p>Return <em>the minimum number of minutes that must elapse until no cell has a fresh orange</em>. If <em>this is impossible, return</em> <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/02/16/oranges.png" style="width: 650px; height: 137px;">
+<pre><strong>Input:</strong> grid = [[2,1,1],[1,1,0],[0,1,1]]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[2,1,1],[0,1,1],[1,0,1]]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> The orange in the bottom left corner (row 2, column 0) is never rotten, because rotting only happens 4-directionally.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[0,2]]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> Since there are already no fresh oranges at minute 0, the answer is just 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;= 10</code></li>
+	<li><code>grid[i][j]</code> is <code>0</code>, <code>1</code>, or <code>2</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/Add 1 to a number represented as linked list - GFG/README.md b/Add 1 to a number represented as linked list - GFG/README.md
new file mode 100644
index 0000000..fe492ba
--- /dev/null
+++ b/Add 1 to a number represented as linked list - GFG/README.md	
@@ -0,0 +1,29 @@
+# Add 1 to a number represented as linked list
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">A number&nbsp;<strong>N</strong>&nbsp;is represented in Linked List such that each digit corresponds to a node in linked list. You need to add 1 to it.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>LinkedList: 4-&gt;5-&gt;6
+<strong>Output: </strong>457&nbsp;</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
+<strong>Output: </strong>124&nbsp;</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+Your task is to complete the function addOne() which takes the head of the linked list as the only argument and returns the head of the modified linked list. The driver code prints the number.<br>
+<strong>Note:&nbsp;</strong>The head represents the left-most digit of the number.</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>1000</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Add 1 to a number represented as linked list - GFG/add-1-to-a-number-represented-as-linked-list.cpp b/Add 1 to a number represented as linked list - GFG/add-1-to-a-number-represented-as-linked-list.cpp
new file mode 100644
index 0000000..9c29053
--- /dev/null
+++ b/Add 1 to a number represented as linked list - GFG/add-1-to-a-number-represented-as-linked-list.cpp	
@@ -0,0 +1,119 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include <bits/stdc++.h> 
+using namespace std; 
+
+struct Node
+{
+    int data;
+    struct Node* next;
+    
+    Node(int x){
+        data = x;
+        next = NULL;
+    }
+};
+
+void printList(Node* node) 
+{ 
+    while (node != NULL) { 
+        cout << node->data; 
+        node = node->next; 
+    }  
+    cout<<"\n";
+} 
+
+
+ // } Driver Code Ends
+//User function template for C++
+
+/* 
+
+struct Node
+{
+    int data;
+    struct Node* next;
+    
+    Node(int x){
+        data = x;
+        next = NULL;
+    }
+};
+
+*/
+
+class Solution
+{
+    public:
+    Node* reverse(Node *head)
+{
+       Node *p = NULL, 
+       *c = head, 
+       *n = head->next;
+       while(c!=NULL){
+            c->next = p;
+            p = c;
+            c = n;
+            if(n!=NULL) n = n->next;
+       }
+       return p;
+}
+Node* addOne(Node *head) 
+{
+       head = reverse(head);
+       Node *temp = head;
+
+       while(temp!=NULL){
+            //99999..... case
+            if(temp->next==NULL and 
+            temp->data==9)
+            {
+                temp->data = 1;
+                Node * zeroNode = new Node(0);
+                zeroNode->next = head;
+                head = zeroNode;
+                temp = temp->next;
+            }
+            else if(temp->data==9){
+                //9 case
+                temp->data = 0;
+                temp = temp->next;
+            }
+            else{
+                //other all cases
+                temp->data++;
+                temp = temp->next;
+                break;
+            }
+        }
+        head = reverse(head);
+        return head;
+    }
+};
+
+// { Driver Code Starts.
+
+int main() 
+{ 
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        string s;
+        cin>>s;
+        
+        Node* head = new Node( s[0]-'0' );
+        Node* tail = head;
+        for(int i=1; i<s.size(); i++)
+        {
+            tail->next = new Node( s[i]-'0' );
+            tail = tail->next;
+        }
+        Solution ob;
+        head = ob.addOne(head);
+        printList(head); 
+    }
+    return 0; 
+} 
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Allocate minimum number of pages - GFG/README.md b/Allocate minimum number of pages - GFG/README.md
new file mode 100644
index 0000000..1dd3c40
--- /dev/null
+++ b/Allocate minimum number of pages - GFG/README.md	
@@ -0,0 +1,55 @@
+# Allocate minimum number of pages
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">You are given <strong>N </strong>number of books. Every <strong>ith</strong> book has<strong> Ai</strong> number of pages and are arranged in <strong>sorted order</strong>.<br>
+<br>
+You have to allocate contagious books to <strong>M </strong>number of students. There can be many ways or permutations to do so. In each permutation, one of the M students will be allocated the maximum number of pages. Out of all these permutations, the task is to find that particular permutation in which the maximum number of pages allocated to a student is minimum of those in all the other permutations and print this minimum value.</span></p>
+
+<p><span style="font-size:18px">Each book will be allocated to exactly one student. Each student has to be allocated at least one book.</span></p>
+
+<p><span style="font-size:18px">Note: Return <strong>-1</strong> if a valid assignment is not possible, and allotment should be in contiguous order (see the explanation for better understanding).</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 = 4
+A[] = {12,34,67,90}
+M = 2
+<strong>Output:</strong>113
+<strong>Explanation:</strong>Allocation can be done in 
+following ways:{12} and {34, 67, 90} 
+Maximum Pages = 191{12, 34} and {67, 90} 
+Maximum Pages = 157{12, 34, 67} and {90} 
+Maximum Pages =113. Therefore, the minimum 
+of these cases is 113, which is selected 
+as the output.</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 = 3
+A[] = {15,17,20}
+M = 2
+<strong>Output:</strong>32
+<strong>Explanation: </strong>Allocation is done as
+{15,17} and {20}</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 findPages() which takes 2 Integers <strong>N</strong>, and m and an array <strong>A[]</strong> of length <strong>N</strong> as input and returns the expected answer.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity</strong>: O(NlogN)<br>
+<strong>Expected Auxilliary Space:</strong> O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 10<sup>5</sup><br>
+1 &lt;= A [ i ] &lt;= 10<sup>6</sup><br>
+1 &lt;= M &lt;= 10<sup>5</sup></span></p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Allocate minimum number of pages - GFG/allocate-minimum-number-of-pages.cpp b/Allocate minimum number of pages - GFG/allocate-minimum-number-of-pages.cpp
new file mode 100644
index 0000000..3f8c676
--- /dev/null
+++ b/Allocate minimum number of pages - GFG/allocate-minimum-number-of-pages.cpp	
@@ -0,0 +1,89 @@
+// { Driver Code Starts
+// Initial template for C++
+
+#include<bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+//User function template in C++
+
+class Solution 
+{
+    public:
+    bool CanMaxCanAllot(int mid,int A[], int N,int M)
+    {
+        int student=1;
+        int sum=0;
+        for(int i=0;i<N;i++)
+        {
+            sum+=A[i];
+            if(sum>mid)
+            {
+                student++;
+                sum=A[i];
+            }
+            if(student>M)
+                return false;
+        }
+        return true;
+    }
+    //Function to find minimum number of pages.
+    int findPages(int A[], int N, int M) 
+    {
+        //code here
+        int low = 0;
+        int high = 0;
+        for(int i=0;i<N;i++)
+        low = max(low,A[i]);
+        int k = N-M+1;
+        for(int i=0;i<k;i++)
+        {
+            high += A[i];
+        }
+        
+        for(int i=k ;i<N;i++)
+        {
+            high = max(high,high+A[i]-A[i-k]);
+        }
+    //    cout<<low<<" "<<high<<endl;
+    int ans = INT_MAX;
+    while(low<=high)
+    {
+        int mid = (low+high)/2;
+        if(CanMaxCanAllot(mid,A,N,M) == true)
+        {
+            ans = min(ans,mid);
+            high = mid-1;
+        }
+        else
+        {
+            low = mid+1;
+        }
+    }
+    return ans;
+    
+    
+    }
+};
+
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        int A[n];
+        for(int i=0;i<n;i++){
+            cin>>A[i];
+        }
+        int m;
+        cin>>m;
+        Solution ob;
+        cout << ob.findPages(A, n, m) << endl;
+    }
+    return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Anagram of String - GFG/README.md b/Anagram of String - GFG/README.md
new file mode 100644
index 0000000..32b6e62
--- /dev/null
+++ b/Anagram of String - GFG/README.md	
@@ -0,0 +1,34 @@
+# Anagram of String
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given two strings<strong> S1 and S2</strong> in lowercase, the task is to make them anagram. The only allowed operation is to remove a character from any string. Find the&nbsp;<strong>minimum number of characters to be deleted</strong> to make both the strings anagram. Two strings are called anagram of each other if one of them can be converted into another by rearranging its letters.</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">S1 = bcadeh
+S2 = hea
+<strong>Output: </strong>3<strong>
+Explanation: </strong>We need to remove b, c
+and d from S1.</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">S1 = cddgk
+S2 = gcd
+<strong>Output: </strong>2<strong>
+Explanation: </strong>We need to remove d and
+k from S1.</span></pre>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong><br>
+<span style="font-size:18px">Complete&nbsp;the function&nbsp;<strong>remAnagram()&nbsp;</strong>which takes two strings <strong>S1, S2</strong>&nbsp;as input parameter, and returns minimum characters needs to be deleted.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(max(|S1|, |S2|)), where |S| = length of string S.<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(26)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= |S1|, |S2| &lt;= 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Anagram of String - GFG/anagram-of-string.cpp b/Anagram of String - GFG/anagram-of-string.cpp
new file mode 100644
index 0000000..1caba68
--- /dev/null
+++ b/Anagram of String - GFG/anagram-of-string.cpp	
@@ -0,0 +1,37 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+const int CHARS = 26;
+
+// function to calculate minimum numbers of characters
+// to be removed to make two strings anagram
+int remAnagram(string str1, string str2);
+
+// Driver program to run the case
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        string str1,str2;
+        cin>>str1>>str2;
+        cout << remAnagram(str1, str2);
+        cout<<endl;
+    }
+    return 0;
+}
+// } Driver Code Ends
+
+
+// function to calculate minimum numbers of characters
+// to be removed to make two strings anagram
+int remAnagram(string str1, string str2) {
+    vector<int> freq(26, 0);
+    for(char &ch:str1) freq[ch-'a']++;
+    for(char &ch:str2) freq[ch-'a']--;
+    int res = 0;
+    for(int i=0; i<26; i++)
+        res += abs(freq[i]);
+    return res;
+}
\ No newline at end of file
diff --git a/Array to BST - GFG/README.md b/Array to BST - GFG/README.md
new file mode 100644
index 0000000..1990d04
--- /dev/null
+++ b/Array to BST - GFG/README.md	
@@ -0,0 +1,50 @@
+# Array to BST
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a sorted array. Convert it into a Height balanced&nbsp;Binary Search Tree (BST). Find the preorder traversal of height balanced BST. If there exist many such balanced BST consider the tree whose preorder is lexicographically smallest.<br>
+Height balanced BST means a binary tree in which the depth of the left subtree and the right subtree&nbsp;of every node never differ by more than 1.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> nums = {1, 2, 3, 4}
+<strong>Output:</strong> {2, 1, 3, 4}
+<strong>Explanation:</strong> 
+The preorder traversal of the following 
+BST formed is {2, 1, 3, 4}:
+</span><span style="font-size:18px">&nbsp;          2
+</span><span style="font-size:18px">&nbsp;        /   \
+</span>           <span style="font-size:18px">1     3
+</span><span style="font-size:18px">&nbsp;              \
+&nbsp;               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>nums = {1,2,3,4,5,6,7}
+<strong>Ouput: </strong>{4,2,1,3,6,5,7}
+<strong>Explanation: 
+</strong>The preorder traversal of the following
+BST formed is {4,2,1,3,6,5,7} :
+        4
+       / \
+      2   6
+     / \  / \
+    1   3 5  7</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read or print anything. Your task is to complete the function&nbsp;<strong>sortedArrayToBST()&nbsp;</strong>which takes the sorted array <strong>nums</strong> as input paramater and returns the preorder traversal of height balanced BST. If there exist many such balanced BST consider the tree whose preorder is lexicographically smallest.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity: </strong>O(n)<br>
+<strong>Expected Space Complexity:&nbsp;</strong>O(n)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ |nums| ≤&nbsp;10<sup>4</sup><br>
+-10<sup>4</sup>&nbsp;≤&nbsp;nums[i] ≤&nbsp;10<sup>4</sup></span><br>
+&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Array to BST - GFG/array-to-bst.cpp b/Array to BST - GFG/array-to-bst.cpp
new file mode 100644
index 0000000..896adbe
--- /dev/null
+++ b/Array to BST - GFG/array-to-bst.cpp	
@@ -0,0 +1,46 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution {
+public:
+    void solve(vector<int> &nums, vector<int> &ans , int l, int h)
+   {
+       if(l>h)
+       return;
+       
+       int mid = (l+h) / 2;
+       int temp = nums[mid];
+       ans.push_back(temp);
+       
+       solve(nums,ans,l,mid-1);
+       solve(nums,ans,mid+1,h);
+   }
+   vector<int> sortedArrayToBST(vector<int>& nums) {
+       
+       vector<int>ans;
+       int l = 0;
+       int h = nums.size()-1;
+       solve(nums,ans,l,h);
+       return ans;
+   }
+};
+
+// { Driver Code Starts.
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		int n;
+		cin >> n;
+		vector<int>nums(n);
+		for(int i = 0; i < n; i++)cin >> nums[i];
+		Solution obj;
+		vector<int>ans = obj.sortedArrayToBST(nums);
+		for(auto i: ans)
+			cout << i <<" ";
+		cout << "\n";
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Biconnected Graph - GFG/README.md b/Biconnected Graph - GFG/README.md
new file mode 100644
index 0000000..6efbce4
--- /dev/null
+++ b/Biconnected Graph - GFG/README.md	
@@ -0,0 +1,53 @@
+# Biconnected Graph
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a graph with <strong>n</strong> vertices, <strong>e</strong> edges and an array <strong>arr[] </strong>denoting the edges connected to each other, check whether it is <a href="https://en.wikipedia.org/wiki/Biconnected_graph" target="_blank">Biconnected</a> or not.<br>
+<strong>Note: </strong>The given graph is Undirected.</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></span>
+<span style="font-size:18px"><strong>n = </strong>2, <strong>e = </strong>1</span>
+<span style="font-size:18px"><strong>arr = </strong>{0, 1}</span>
+<span style="font-size:18px"><strong>Output:</strong></span>
+<span style="font-size:18px">1</span>
+<span style="font-size:18px"><strong>Explanation:</strong></span>
+<span style="font-size:18px">       0
+      /
+     1
+The above graph is Biconnected.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong></span>
+<span style="font-size:18px"><strong>n = </strong>3, <strong>e = </strong>2</span>
+<span style="font-size:18px"><strong>arr = </strong>{0, 1, 1, 2}</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></span>
+<span style="font-size:18px">       0
+      /
+     1
+      \
+       2
+The above graph is not Biconnected.</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 <strong>biGraph()</strong> which takes 2 Integers n, and e and an array arr of length 2*e as input and returns 1 if the graph is biconnected else returns 0.</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(n+e)<br>
+<strong>Expected Auxiliary Space:</strong> O(n)</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong></span><br>
+<span style="font-size:18px">1 &lt;= e &lt;= 100<br>
+2 &lt;= n &lt;= 100</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Biconnected Graph - GFG/biconnected-graph.cpp b/Biconnected Graph - GFG/biconnected-graph.cpp
new file mode 100644
index 0000000..0f7910a
--- /dev/null
+++ b/Biconnected Graph - GFG/biconnected-graph.cpp	
@@ -0,0 +1,47 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution {
+  public:
+    int biGraph(int arr[], int n, int e) {
+        // code here
+        unordered_map<int,vector<int>> m;
+        
+        int size = 2*e;
+      
+        if(n <= 2)
+            return true;
+      
+        for(int i = 0; i < size; i += 2){
+                m[arr[i]].push_back(arr[i+1]); 
+                m[arr[i+1]].push_back(arr[i]);
+            }
+        
+        for(auto x: m){
+          if(x.second.size() <= 1)
+            return false;
+        }
+        
+        return true;
+    }
+};
+
+// { Driver Code Starts.
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int n,e;
+        cin>>n>>e;
+        
+        int arr[2*e];
+        for(int i=0; i<2*e; i++)
+            cin>>arr[i];
+
+        Solution ob;
+        cout << ob.biGraph(arr,n,e) << endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Binary Array Sorting - GFG/README.md b/Binary Array Sorting - GFG/README.md
new file mode 100644
index 0000000..b34c7ed
--- /dev/null
+++ b/Binary Array Sorting - GFG/README.md	
@@ -0,0 +1,47 @@
+# Binary Array Sorting
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a binary array <strong>A[]</strong> of size <strong>N</strong>. The task is to arrange the array in increasing order.</span><br>
+<span style="font-size:18px"><strong>Note:</strong> The binary array contains only 0&nbsp; and 1.</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>: 
+5
+1 0 1 1 0
+
+<strong>Output</strong>: 
+0 0 1 1 1
+
+<strong>Explanation</strong>: 
+After arranging the elements in 
+increasing order, elements will be as 
+0 0 1 1 1.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong>:
+10
+1 0 1 1 1 1 1 0 0 0
+
+<strong>Output</strong>: 
+0 0 0 0 1 1 1 1 1 1
+
+<strong>Explanation</strong>: 
+After arranging the elements in 
+increasing order, elements will be 
+0 0 0 0 1 1 1 1 1 1.
+</span>
+</pre>
+
+<p><strong><span style="font-size:18px">Your Task:&nbsp;</span></strong><span style="font-size:18px">This is a function problem. You only need to complete the function<strong> binSort()&nbsp;</strong>that takes the array&nbsp;<strong>A[] </strong>and it's size <strong>N</strong> as parameters and sorts the array. The <strong>printing </strong>is done <strong>automatically </strong>by the driver code.</span><br>
+<br>
+<span style="font-size:18px"><strong>Expected Time Complexity</strong>: O(N)<br>
+<strong>Expected Auxilliary Space</strong>: O(1)</span><br>
+<br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;=&nbsp;N &lt;= 10<sup>6</sup><br>
+0 &lt;= A[i] &lt;= 1</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Binary Array Sorting - GFG/binary-array-sorting.cpp b/Binary Array Sorting - GFG/binary-array-sorting.cpp
new file mode 100644
index 0000000..a5db672
--- /dev/null
+++ b/Binary Array Sorting - GFG/binary-array-sorting.cpp	
@@ -0,0 +1,79 @@
+// { Driver Code Starts
+// A Sample C++ program for beginners with Competitive Programming
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution{
+  public:
+    
+    // A[]: input array
+    // N: input array
+    //Function to sort the binary array.
+    void binSort(int A[], int N)
+    {
+       //Your code here
+       
+       /**************
+        * No need to print the array
+        * ************/
+        int i=0;
+        int j = N-1;
+        while(j>i)
+        {
+           
+            while(i<N && i<j)
+            {
+                if(A[i]==1)
+                {
+                    break;
+                }
+                else
+                i++;
+            } 
+            while(j>=0 && j>i)
+            {
+                if(A[j]==0)
+                break;
+                else
+                j--;
+            }
+            
+            swap(A[i],A[j]);
+            i++;
+            j--;
+        }
+        return;
+       
+    }
+};
+
+// { Driver Code Starts.
+int main() {
+	int T;
+	cin>>T;
+	// Input the number of testcases
+	while(T--)
+	{
+	    int N;
+	    cin>>N; //Input size of array N
+	    int A[N]; 
+	    
+	    for(int i = 0; i  < N; i++)
+	      cin>>A[i];
+	      
+	    Solution obj;
+	    obj.binSort(A,N);
+	    
+	    for(int x:A)
+	    cout<<x<<" ";
+	      
+	    cout<<endl;
+	}
+	return 0;
+}
+
+
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Binary number to decimal number - GFG/README.md b/Binary number to decimal number - GFG/README.md
new file mode 100644
index 0000000..d7486ec
--- /dev/null
+++ b/Binary number to decimal number - GFG/README.md	
@@ -0,0 +1,32 @@
+# Binary number to decimal number
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a Binary Number <strong>B</strong>, find&nbsp;its decimal equivalent.</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>B = 10001000
+<strong>Output: </strong>136</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>B = 101100
+<strong>Output: </strong>44</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read or print anything. Your task is to complete the function&nbsp;<strong>binary_to_decimal()</strong>&nbsp;which takes the binary number as string input parameter and returns its decimal equivalent.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(K * Log(K)) where K is number of bits&nbsp;in binary number.<br>
+<strong>Expected Space Complexity:&nbsp;</strong>O(1)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= number of bits in binary number&nbsp;&nbsp;&lt;= 16</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Binary number to decimal number - GFG/binary-number-to-decimal-number.cpp b/Binary number to decimal number - GFG/binary-number-to-decimal-number.cpp
new file mode 100644
index 0000000..970bd70
--- /dev/null
+++ b/Binary number to decimal number - GFG/binary-number-to-decimal-number.cpp	
@@ -0,0 +1,31 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution
+{
+	public:
+	int binary_to_decimal(string str){
+		  int len = str.length();
+		  int ans=0;
+		  for(int i=len-1;i>=0;i--)
+		    ans+=(1<<(len-i-1))*(str[i]-'0');
+		  return ans;
+    };
+};
+
+// { Driver Code Starts.
+int main(){
+    int T;
+    cin >> T;
+    while(T--)
+    {
+    	string str;
+    	cin >> str;
+    	Solution ob;
+    	int  ans = ob.binary_to_decimal(str);
+    	cout << ans <<"\n";
+    }
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Bitwise AND of the Array - GFG/README.md b/Bitwise AND of the Array - GFG/README.md
new file mode 100644
index 0000000..5bc4707
--- /dev/null
+++ b/Bitwise AND of the Array - GFG/README.md	
@@ -0,0 +1,40 @@
+# Bitwise AND of the Array
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array&nbsp;<strong>A[ ]</strong>&nbsp;of&nbsp;<strong>N</strong>&nbsp;integers and an&nbsp;integer&nbsp;<strong>X</strong>. In one operation, you can change the <strong>i<sup>th</sup></strong> element of the array to any integer value where <strong>1 ≤ i ≤ N</strong>. Calculate minimum number of such operations required such that the <strong>bitwise</strong> <a href="https://en.wikipedia.org/wiki/Bitwise_operation#AND" target="_blank"><strong>AND</strong></a> of all the elements of the&nbsp;array is strictly greater than <strong>X</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 = 4, X = 2
+A[] = {3, 1, 2, 7}
+<strong>Output: 
+</strong>2<strong>
+Explanation: 
+</strong>After performing two operations:
+Modified array: {3, <strong>3</strong>, <strong>11</strong>, 7} 
+Now, Bitwise AND of all the elements
+is 3 &amp; 3 &amp; 11 &amp; 7 = 3 
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 3, X = 1
+A[] = {2, 2, 2}
+<strong>Output: 
+</strong>0
+</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>count( )</strong>&nbsp;which takes&nbsp;<strong>N</strong>,&nbsp;<strong>A[ ]&nbsp;</strong>and&nbsp;<strong>X</strong>&nbsp;as input parameters and returns the minimum number of operations required.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N * Log(max(A[ ])))<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤&nbsp;N&nbsp;≤&nbsp;10<sup>5</sup><br>
+1&nbsp;≤&nbsp;A[i] ≤&nbsp;10<sup>9</sup><br>
+1&nbsp;≤&nbsp;X&nbsp;≤&nbsp;10<sup>9</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Bitwise AND of the Array - GFG/bitwise-and-of-the-array.cpp b/Bitwise AND of the Array - GFG/bitwise-and-of-the-array.cpp
new file mode 100644
index 0000000..748651b
--- /dev/null
+++ b/Bitwise AND of the Array - GFG/bitwise-and-of-the-array.cpp	
@@ -0,0 +1,64 @@
+// { Driver Code Starts
+//Initial Template for C++
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function Template for C++
+class Solution{
+    public:
+  int count(int N, vector<int> A,int X)
+
+    {   
+
+        int ans=N;
+
+        int mask=0;
+
+        for(int i=31;i>=0;i--){
+
+            if((X>>i)&1){
+
+              mask^=(1<<i);
+
+              continue;
+
+            }
+
+            int temp=mask^(1<<i);
+
+            int count=0;
+
+            for(int j=0;j<N;j++){
+
+              if((temp&A[j])!=temp)
+
+              count++;
+
+            }
+
+            ans=min(ans,count);
+
+        }
+
+      return ans;
+
+    }
+};
+
+// { Driver Code Starts.
+int main() {
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int N,X;
+        cin>>N>>X;
+        vector<int> A(N);
+        for(auto &i:A)
+            cin>>i;
+        Solution obj;
+        int ans = obj.count(N, A, X);
+        cout<<ans<<endl;
+    }
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Can Make Triangle - GFG/README.md b/Can Make Triangle - GFG/README.md
new file mode 100644
index 0000000..1196696
--- /dev/null
+++ b/Can Make Triangle - GFG/README.md	
@@ -0,0 +1,50 @@
+# Can Make Triangle
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array&nbsp;<strong>A[]&nbsp;</strong>of&nbsp;<strong>N&nbsp;</strong>elements, You'd like to know how many triangles can be formed with side lengths equal to adjacent elements from A[].</span></p>
+
+<p><span style="font-size:18px">Construct an array of integers of length N - 2 where ith element is equal to <strong>1</strong> if it is possible to form a triangle with side lengths<strong> A[i]</strong>, <strong>A[i+1]</strong>, and <strong>A[i+2]</strong>. otherwise <strong>0</strong>.</span></p>
+
+<p><span style="font-size:18px"><strong>Note: </strong>A triangle can be formed with side lengths a, b and c if a+b&gt;c and a+c&gt;b and b+c&gt;a.</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[] = {1, 2, 2, 4}
+<strong>Output:</strong>
+1 0
+<strong>Explanation:</strong>
+output[0] = 1 because we can form a 
+triangle with side lengths 1,2 and 2.
+output[1] = 0 because 2+2<u>&lt;</u>4 so, we cannot 
+form a triangle with side lengths 2,2 and 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 = 5
+A[] = {2, 10, 2, 10, 2}
+<strong>Output:</strong>
+0 1 0
+<strong>Explanation:
+</strong>output[0] = 0 because 2+2<u>&lt;</u>10 so, we cannot
+form a triangle with side lengths 2, 10 and 2.<strong> </strong>
+output[1] = 1 we can form a triangle with 
+side lengths 10,2 and 10.<strong> 
+</strong>output[1] = 0 because 2+2<u>&lt;</u>10 so, we can
+form a triangle with side lengths 2, 10 and 2.<strong> </strong></span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You dont need to read input or print anything. Your task is to c</span><span style="font-size:18px">omplete the function&nbsp;<strong>canMakeTriangle()&nbsp;</strong>which takes the array&nbsp;<strong>A</strong>&nbsp;and the integer&nbsp;<strong>N&nbsp;</strong>as the input parameters, and returns the array of answers.</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><br>
+3 ≤ N&nbsp;≤ 10<sup>5&nbsp;</sup><br>
+1 ≤ arr[i] ≤ 10<sup>9</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Can Make Triangle - GFG/can-make-triangle.cpp b/Can Make Triangle - GFG/can-make-triangle.cpp
new file mode 100644
index 0000000..b052964
--- /dev/null
+++ b/Can Make Triangle - GFG/can-make-triangle.cpp	
@@ -0,0 +1,52 @@
+// { Driver Code Starts
+//Initial Template for C++
+#include <bits/stdc++.h> 
+using namespace std; 
+
+ // } Driver Code Ends
+//User function Template for C++
+class Solution{
+   public:
+    bool check(int a,int b,int c)
+    {
+    	if(a + b > c and a + c > b and b + c > a)
+    		return true;
+    	return false;
+    }
+    	
+    vector<int> canMakeTriangle(vector<int> A, int N)
+    {
+        // code here
+        vector<int> res;
+        for(int i = 0;i < A.size() - 2;i++)
+        {
+        	if(check(A[i],A[i+1],A[i+2]))
+        		res.push_back(1);
+        	else
+        		res.push_back(0);
+        }
+        return res;
+    }
+};
+
+// { Driver Code Starts.
+int main() 
+{ 
+    int t;cin>>t;
+    while(t--)
+    {
+        int N;
+        cin>>N;
+        vector<int> A(N);
+        for(int i=0;i<N;i++)
+            cin>>A[i];
+        Solution ob;
+        auto ans = ob.canMakeTriangle(A, N);
+        for(int i=0;i<ans.size();i++)
+            cout << ans[i] << " ";
+        cout << endl;
+        
+    }
+
+    return 0; 
+}   // } Driver Code Ends
\ No newline at end of file
diff --git a/Check Mirror in N-ary tree - GFG/README.md b/Check Mirror in N-ary tree - GFG/README.md
new file mode 100644
index 0000000..b392d50
--- /dev/null
+++ b/Check Mirror in N-ary tree - GFG/README.md	
@@ -0,0 +1,50 @@
+# Check Mirror in N-ary tree
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given two <strong>n</strong>-ary trees.&nbsp;Check if they are mirror images of each other or not. You are also given <strong>e</strong> denoting the number of edges in both trees, and two arrays, <strong>A[] </strong>and<strong> </strong><strong>B[]</strong>. </span> <span style="font-size:18px">Each array has&nbsp;2*e space separated values u,v denoting an edge from u to v for the both trees.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong></span>
+<span style="font-size:18px"><strong>n = </strong>3, <strong>e = </strong>2</span>
+<span style="font-size:18px"><strong>A[] = </strong>{1, 2, 1, 3}</span>
+<span style="font-size:18px"><strong>B[] = </strong>{1, 3, 1, 2}</span>
+<span style="font-size:18px"><strong>Output:
+</strong>1</span>
+<span style="font-size:18px"><strong>Explanation:
+</strong></span>   <span style="font-size:18px">1          1
+ / \        /  \
+2   3      3    2</span> 
+<span style="font-size:18px">As we can clearly see, the second tree
+is mirror image of the first.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong></span>
+<span style="font-size:18px"><strong>n = </strong>3, <strong>e = </strong>2</span>
+<span style="font-size:18px"><strong>A[] = </strong>{1, 2, 1, 3}</span>
+<span style="font-size:18px"><strong>B[] = </strong>{1, 2, 1, 3}</span>
+<span style="font-size:18px"><strong>Output:
+</strong>0</span>
+<span style="font-size:18px"><strong>Explanation:
+</strong></span>   <span style="font-size:18px">1          1
+ / \        /  \
+2   3      2    3</span> 
+<span style="font-size:18px">As we can clearly see, the second tree
+isn't mirror image of the first.</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>checkMirrorTree()</strong> which takes 2 Integers n, and e;&nbsp; and two arrays A[] and B[] of size 2*e as input and returns 1 if the trees are mirror images of each other and 0 if not.</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></span><br>
+<span style="font-size:18px">1 &lt;= n,e &lt;= 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Check Mirror in N-ary tree - GFG/check-mirror-in-nary-tree.cpp b/Check Mirror in N-ary tree - GFG/check-mirror-in-nary-tree.cpp
new file mode 100644
index 0000000..42e7edd
--- /dev/null
+++ b/Check Mirror in N-ary tree - GFG/check-mirror-in-nary-tree.cpp	
@@ -0,0 +1,52 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution {
+  public:
+    int checkMirrorTree(int n, int e, int A[], int B[]) {
+        vector<vector<int>> adjA(n+1),adjB(n+1);
+        for(int i=0;i<2*e;i+=2){
+            adjA[A[i]].push_back(A[i+1]);
+            adjB[B[i]].push_back(B[i+1]);
+        }
+
+        for(int i=1;i<=n;i++){
+            int sizel = adjA[i].size(),sizer = adjB[i].size();
+            if(sizel!=sizer)return false;
+            for(int j=0;j<sizel;j++){
+                if(adjA[i][j] != adjB[i][sizel-j-1]){
+                return false;
+                }
+            }
+        }
+        return true;
+    }
+};
+
+// { Driver Code Starts.
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int n,e;
+        
+        cin>>n>>e;
+        int A[2*e], B[2*e];
+        
+        for(int i=0; i<2*e; i++)
+            cin>>A[i];
+            
+        for(int i=0; i<2*e; i++)
+            cin>>B[i];
+
+        Solution ob;
+        cout << ob.checkMirrorTree(n,e,A,B) << endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Check if subtree - GFG/README.md b/Check if subtree - GFG/README.md
new file mode 100644
index 0000000..bdc60f0
--- /dev/null
+++ b/Check if subtree - GFG/README.md	
@@ -0,0 +1,49 @@
+# Check if subtree
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given two binary trees with head reference as <strong>T</strong><strong> </strong>and <strong>S</strong> having at most <strong>N</strong> nodes. The&nbsp;task is to check if S is present as subtree in T.<br>
+A subtree of a tree T1 is a tree T2 consisting of a node in T1 and all of its descendants in T1.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>T:&nbsp; &nbsp; &nbsp;&nbsp;1&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; S:&nbsp; &nbsp;3
+ &nbsp; &nbsp; &nbsp;/&nbsp; &nbsp;\&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;   /
+ &nbsp; &nbsp; 2&nbsp; &nbsp; &nbsp;3&nbsp; &nbsp; &nbsp; &nbsp;  &nbsp;4
+ &nbsp; /&nbsp; \&nbsp; &nbsp; /
+&nbsp; N&nbsp; &nbsp; N&nbsp; 4
+<strong>Output: </strong>1 
+<strong>Explanation:</strong> S is present in T<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>T:&nbsp; &nbsp; &nbsp; 26&nbsp; &nbsp; &nbsp;   &nbsp;S: &nbsp; 26
+ &nbsp; &nbsp; &nbsp;&nbsp;/&nbsp; &nbsp;\&nbsp; &nbsp;      &nbsp; /&nbsp; \
+ &nbsp; &nbsp; 10&nbsp; &nbsp; &nbsp;N&nbsp; &nbsp;     10&nbsp; &nbsp;&nbsp;N
+ &nbsp; /&nbsp; &nbsp; \&nbsp; &nbsp; &nbsp; &nbsp;    /&nbsp;&nbsp;\
+ &nbsp;&nbsp;20&nbsp; &nbsp; 30&nbsp; &nbsp; &nbsp; &nbsp;&nbsp;20&nbsp; 30
+ &nbsp;/&nbsp; \&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;   /&nbsp; \
+ 40&nbsp; &nbsp;60&nbsp; &nbsp; &nbsp; &nbsp;  40&nbsp;&nbsp;60
+<strong>Output: </strong>1 
+<strong>Explanation: </strong>
+S and T are both same. Hence, 
+it can be said that S is a subtree 
+of T.
+</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 <strong>function isSubtree()&nbsp;</strong>that takes root&nbsp;node of S and T as parameters<strong> </strong>and <strong>returns 1</strong> if&nbsp;S is a subtree of T else <strong>0</strong>.</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(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;= Value of nodes &lt;= 10<sup>4</sup></span><br>
+&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Check if subtree - GFG/check-if-subtree.cpp b/Check if subtree - GFG/check-if-subtree.cpp
new file mode 100644
index 0000000..5e6de14
--- /dev/null
+++ b/Check if subtree - GFG/check-if-subtree.cpp	
@@ -0,0 +1,160 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+// Tree Node
+struct Node {
+    int data;
+    Node *left;
+    Node *right;
+
+    Node(int val) {
+        data = val;
+        left = right = NULL;
+    }
+};
+
+// Function to Build Tree
+Node *buildTree(string str) {
+    // Corner Case
+    if (str.length() == 0 || str[0] == 'N')
+        return NULL;
+
+    // Creating vector of strings from input
+    // string after spliting by space
+    vector<string> ip;
+
+    istringstream iss(str);
+    for (string str; iss >> str;)
+        ip.push_back(str);
+
+    // Create the root of the tree
+    Node *root = new Node(stoi(ip[0]));
+
+    // Push the root to the queue
+    queue<Node *> queue;
+    queue.push(root);
+
+    // Starting from the second element
+    int i = 1;
+    while (!queue.empty() && i < ip.size()) {
+
+        // Get and remove the front of the queue
+        Node *currNode = queue.front();
+        queue.pop();
+
+        // Get the current node's value from the string
+        string currVal = ip[i];
+
+        // If the left child is not null
+        if (currVal != "N") {
+
+            // Create the left child for the current node
+            currNode->left = new Node(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->left);
+        }
+
+        // For the right child
+        i++;
+        if (i >= ip.size())
+            break;
+        currVal = ip[i];
+
+        // If the right child is not null
+        if (currVal != "N") {
+
+            // Create the right child for the current node
+            currNode->right = new Node(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->right);
+        }
+        i++;
+    }
+
+    return root;
+}
+
+
+ // } Driver Code Ends
+/* A binary tree node
+
+struct Node
+{
+    int data;
+    struct Node* left;
+    struct Node* right;
+
+    Node(int x){
+        data = x;
+        left = right = NULL;
+    }
+};
+ */
+
+class Solution
+{
+  public:
+  bool issame(Node* root1, Node* root2)
+    {
+        if(root1 == NULL && root2 == NULL)
+        return true;
+        
+        if(root1 == NULL && root2)
+        return false;
+        
+        if(root1 && root2 == NULL)
+        return false;
+        
+        if(root1 -> data != root2 -> data)
+        return false;
+        
+        else
+        {
+            bool x = issame(root1 -> left, root2 -> left);
+            
+            if(x == false)
+            return false;
+            
+            else
+            return issame(root1 -> right, root2 -> right);
+        }
+    }
+    
+    bool isSubTree(Node* root1, Node* root2) 
+    {
+        if(root1 == NULL)
+        return false;
+        
+        bool x = issame(root1, root2);
+        
+        if(x)
+        return true;
+        
+        if(isSubTree(root1 -> left, root2))
+        return true;
+        
+        else
+        return isSubTree(root1 -> right, root2);
+    }
+};
+
+// { Driver Code Starts.
+
+int main() {
+    int tc;
+    scanf("%d ", &tc);
+    while (tc--) {
+        string strT, strS;
+        getline(cin, strT);
+        Node *rootT = buildTree(strT);
+        getline(cin, strS);
+        Solution obj;
+        Node *rootS = buildTree(strS);
+        cout << obj.isSubTree(rootT, rootS) << "\n";
+
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Clone a stack without using extra space - GFG/README.md b/Clone a stack without using extra space - GFG/README.md
new file mode 100644
index 0000000..8832ea9
--- /dev/null
+++ b/Clone a stack without using extra space - GFG/README.md	
@@ -0,0 +1,30 @@
+# Clone a stack without using extra space
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given elements of a stack, clone the stack without using extra space.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong></span>:
+<span style="font-size:18px">N = 10
+st[] = {1, 1, 2, 2, 3, 4, 5, 5, 6, 7}
+<strong>Output:</strong>
+1&nbsp;</span>
+</pre>
+
+<p><br>
+<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>clonestack()</strong>&nbsp;which takes the input stack st[], an empty stack cloned[], you have to clone the stack st into stack cloned.<br>
+The driver code itself prints 1 in the output if the stack st is cloned properly and prints 0 otherwise.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N*N)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 1000</span><br>
+<span style="font-size:18px">1&lt;= st[i] &lt;= 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Clone a stack without using extra space - GFG/clone-a-stack-without-using-extra-space.cpp b/Clone a stack without using extra space - GFG/clone-a-stack-without-using-extra-space.cpp
new file mode 100644
index 0000000..a45a167
--- /dev/null
+++ b/Clone a stack without using extra space - GFG/clone-a-stack-without-using-extra-space.cpp	
@@ -0,0 +1,87 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include<bits/stdc++.h> 
+using namespace std; 
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution{
+    public:
+    void clonestack(stack<int> st, stack<int>& cloned)
+    {
+        int n =st.size();
+        int k = 0;
+        
+        while(k+1 != n)
+        {
+        int var = st.top();
+        st.pop();
+        int p = n - k -1;
+        while(p--)
+        {
+            int a = st.top();
+            st.pop();
+            cloned.push(a);
+        }
+        st.push(var);
+        while(!cloned.empty())
+        {
+            int a = cloned.top();
+            cloned.pop();
+            st.push(a);
+        }
+        k++;
+            
+        }
+        
+        while(!st.empty())
+        {
+            int a = st.top();
+            st.pop();
+            cloned.push(a);  
+        }
+        
+    }
+};
+
+// { Driver Code Starts.
+int main() 
+{ 
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int N;
+        cin >> N;
+        int arr[N];
+        stack<int> st;
+        vector<int> copy;
+        for(int i = 0; i < N; i++){
+            cin >> arr[i];
+            st.push(arr[i]);
+            copy.push_back(arr[i]);
+        }
+        
+        reverse(copy.begin(), copy.end());
+        
+        Solution ob;
+        stack<int> cloned;
+        ob.clonestack(st,cloned);
+        vector<int> check;
+        while(cloned.size())
+        {
+            check.push_back(cloned.top());
+            cloned.pop();
+        }
+        
+        int flag = 0;
+        if(check!=copy)
+            flag = 1;
+        
+        cout<<1-flag<<endl;
+    }
+    return 0; 
+} 
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Clone a stack without usinig extra space - GFG/README.md b/Clone a stack without usinig extra space - GFG/README.md
new file mode 100644
index 0000000..5892202
--- /dev/null
+++ b/Clone a stack without usinig extra space - GFG/README.md	
@@ -0,0 +1,30 @@
+# Clone a stack without usinig extra space
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given elements of a stack, clone the stack without using extra space.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong></span>:
+<span style="font-size:18px">N = 10
+st[] = {1, 1, 2, 2, 3, 4, 5, 5, 6, 7}
+<strong>Output:</strong>
+1&nbsp;</span>
+</pre>
+
+<p><br>
+<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>clonestack()</strong>&nbsp;which takes the input stack st[], an empty stack cloned[], you have to clone the stack st into stack cloned.<br>
+The driver code itself prints 1 in the output if the stack st is cloned properly and prints 0 otherwise.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N*N)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 1000</span><br>
+<span style="font-size:18px">1&lt;= st[i] &lt;= 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Clone a stack without usinig extra space - GFG/clone-a-stack-without-usinig-extra-space.cpp b/Clone a stack without usinig extra space - GFG/clone-a-stack-without-usinig-extra-space.cpp
new file mode 100644
index 0000000..cc7548e
--- /dev/null
+++ b/Clone a stack without usinig extra space - GFG/clone-a-stack-without-usinig-extra-space.cpp	
@@ -0,0 +1,62 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include<bits/stdc++.h> 
+using namespace std; 
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution{
+    public:
+ void clonestack(stack<int> st, stack<int>& cloned)
+    {
+         if(st.empty()) return;
+           int topele=st.top();
+              st.pop();
+              
+              clonestack(st,cloned);
+              cloned.push(topele);
+         
+    }
+};
+
+// { Driver Code Starts.
+int main() 
+{ 
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int N;
+        cin >> N;
+        int arr[N];
+        stack<int> st;
+        vector<int> copy;
+        for(int i = 0; i < N; i++){
+            cin >> arr[i];
+            st.push(arr[i]);
+            copy.push_back(arr[i]);
+        }
+        
+        reverse(copy.begin(), copy.end());
+        
+        Solution ob;
+        stack<int> cloned;
+        ob.clonestack(st,cloned);
+        vector<int> check;
+        while(cloned.size())
+        {
+            check.push_back(cloned.top());
+            cloned.pop();
+        }
+        
+        int flag = 0;
+        if(check!=copy)
+            flag = 1;
+        
+        cout<<1-flag<<endl;
+    }
+    return 0; 
+} 
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Coins of Geekland - GFG/README.md b/Coins of Geekland - GFG/README.md
new file mode 100644
index 0000000..8cf762b
--- /dev/null
+++ b/Coins of Geekland - GFG/README.md	
@@ -0,0 +1,40 @@
+# Coins of Geekland
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">In Geekland there is a grid&nbsp;of coins of size <strong>N x</strong> <strong>N</strong>. You have to find the maximum sum of coins in any&nbsp;sub-grid&nbsp;of size<strong> K x K</strong>.<br>
+<strong>Note:</strong> Coins of the negative denomination are&nbsp;also possible at Geekland.</span><br>
+<br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>N = 5, K = 3 
+mat[[]] = {1, 1, 1, 1, 1}&nbsp;
+          {2, 2, 2, 2, 2}&nbsp;
+          {3, 8, 6, 7, 3}&nbsp;
+          {4, 4, 4, 4, 4}&nbsp;
+          {5, 5, 5, 5, 5}</span>
+<span style="font-size:18px"><strong>Output:</strong> 48</span>
+<span style="font-size:18px"><strong>Explanation:</strong> {8, 6, 7}
+             {4, 4, 4}
+             {5, 5, 5}
+has the maximum sum</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 = 1, K = 1
+mat[[]] = {{4}} </span>
+<span style="font-size:18px"><strong>Output:</strong> 4</span><span style="font-size:18px">
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task: </strong>&nbsp;<br>
+You don't need to read input or print anything. Complete the function <strong>Maximum_Sum()</strong> which takes the matrix mat[], size of Matrix N, and value K as input parameters and returns the maximum sum.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N<sup>2</sup>)<br>
+<strong>Expected Auxiliary Space:</strong> O(N<sup>2</sup>)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ K&nbsp;≤ N ≤ 10<sup>3</sup><br>
+-5*10<sup>5</sup> ≤ mat[i][j] ≤ 5*10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Coins of Geekland - GFG/coins-of-geekland.cpp b/Coins of Geekland - GFG/coins-of-geekland.cpp
new file mode 100644
index 0000000..7b5f754
--- /dev/null
+++ b/Coins of Geekland - GFG/coins-of-geekland.cpp	
@@ -0,0 +1,70 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution{
+    
+    public:
+    int Maximum_Sum(vector<vector<int>> &mat,int N,int K){
+        int dp[N+1][N+1];
+        for(int i=0 ;i<N+1;i++){
+            dp[0][i]=0;
+        }
+        
+        for(int i=0 ;i<N+1;i++){
+           dp[i][0]=0; 
+        }
+        
+        int maxcount=INT_MIN;
+        
+        
+        for(int i=1;i<N+1;i++){
+            for(int j=1;j<N+1;j++){
+                
+                dp[i][j]= dp[i-1][j]+dp[i][j-1] - dp[i-1][j-1] + mat[i-1][j-1];
+                
+            }
+        }
+        
+        for(int i=1;i<N+1;i++){
+            for(int j=1;j<N+1;j++){
+                int sum=INT_MIN;
+                if(i-K>=0 && j-K>=0){
+                    sum= dp[i][j]-dp[i-K][j]-dp[i][j-K] + dp[i-K][j-K];
+                    maxcount=max(sum,maxcount);
+                }
+                
+            }
+        }
+         
+        return maxcount;
+    }  
+};
+
+// { Driver Code Starts.
+
+int main() {
+    
+    int t;
+    cin >> t;
+    while(t--)
+    {
+    	int N;
+        cin>>N;
+        vector<vector<int>> mat(N,vector<int>(N,0));
+        
+        for(int i=0;i<N;i++){
+            for(int j=0;j<N;j++){
+                cin>>mat[i][j];
+            }
+        }
+        
+        int k;cin>>k;
+        Solution obj;
+        cout << obj.Maximum_Sum(mat,N,k)<<"\n";
+    }
+        
+    return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Compute Before Matrix - GFG/README.md b/Compute Before Matrix - GFG/README.md
new file mode 100644
index 0000000..1967e47
--- /dev/null
+++ b/Compute Before Matrix - GFG/README.md	
@@ -0,0 +1,54 @@
+# Compute Before Matrix
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">For a given 2D Matrix&nbsp;<strong>before,</strong>&nbsp;the corresponding cell (x, y) of the <strong>after</strong> matrix is calculated as follows:&nbsp;</span></p>
+
+<div style="background:#eee;border:1px solid #ccc;padding:5px 10px;">
+<pre><span style="font-size:18px">res = 0;
+for(i = 0; i &lt;= x; i++){
+    for( j = 0; j &lt;= y; j++){              
+&nbsp;       res += before(i,j);
+    }
+}
+after(x,y) = res;
+</span></pre>
+</div>
+
+<p><span style="font-size:18px">Given an&nbsp;<strong>N*M&nbsp;</strong>2D-Matrix&nbsp;<strong>after,</strong>&nbsp;your task is to find the corresponding&nbsp;<strong>before&nbsp;</strong>matrix for the given matrix.</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 = 2, M = 3
+after[][] = {{1, 3, 6},
+&nbsp;           {3, 7, 11}}
+<strong>Output:</strong>
+1 2 3
+2 2 1
+<strong>Explanation:</strong>
+The before matrix for the given after matrix
+matrix is {{1, 2, 3}, {2, 2, 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 = 1, M = 3
+after[][] = {{1, 3, 5}}
+<strong>Output:</strong>
+1 2 2
+<strong>Explanation: </strong>
+The before matrix for the given after matrix
+is {{1, 2, 2}}.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+Complete the function <strong>c</strong><strong>omputeBeforeMatrix() </strong>which takes the integers <strong>N</strong>, <strong>M,&nbsp;</strong>and the 2D Matrix&nbsp;<strong>after</strong>&nbsp;as the input parameters, and returns the before matrix of the given after matrix.</span></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><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N, M, after[i][j]&nbsp; ≤&nbsp; 10<sup>9</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Compute Before Matrix - GFG/compute-before-matrix.cpp b/Compute Before Matrix - GFG/compute-before-matrix.cpp
new file mode 100644
index 0000000..85748d8
--- /dev/null
+++ b/Compute Before Matrix - GFG/compute-before-matrix.cpp	
@@ -0,0 +1,52 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution {
+   public:
+    vector<vector<int>> computeBeforeMatrix(int n, int m, vector<vector<int>> after) {
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = m - 1; j >= 0; j--) {
+                int top = 0;
+                int left = 0;
+                int diagonal = 0;
+
+                if (i - 1 >= 0) top = after[i - 1][j];
+                if (j - 1 >= 0) left = after[i][j - 1];
+                if (i - 1 >= 0 and j - 1 >= 0) diagonal = after[i - 1][j - 1];
+
+                after[i][j] -= top + left - diagonal;
+            }
+        }
+        return after;
+    }
+};
+
+// { Driver Code Starts.
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int N, M;
+        cin>>N>>M; 
+        vector<vector<int>> after(N,vector<int>(M));
+        for(int i=0;i<N;i++){
+            for(int j=0;j<M;j++){
+                cin>>after[i][j];
+            }
+        } 
+        Solution obj;
+        vector<vector<int>> before=obj.computeBeforeMatrix(N,M,after); 
+        for(int i=0;i<before.size();i++){
+            for(int j=0;j<before[i].size();j++){
+                cout<<before[i][j]<<' ';
+            } 
+            cout<<endl;
+        }
+    }
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Concatenate two numbers - GFG/README.md b/Concatenate two numbers - GFG/README.md
new file mode 100644
index 0000000..c33dbd2
--- /dev/null
+++ b/Concatenate two numbers - GFG/README.md	
@@ -0,0 +1,46 @@
+# Concatenate two numbers
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array&nbsp;<strong>numbers</strong><strong>[]&nbsp;</strong>of&nbsp;<strong>N&nbsp;</strong>positive integers and a positive integer <strong>X</strong>, The task is to find the number of ways that X can be obtained by writing pair of integers in the array numbers[] next to each other. In other words, find the number of ordered pairs (i,j) such that i != j and X is the concatenation of numbers[i] and numbers[j]</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 
+numbers[] = {1, 212, 12, 12}
+X = 1212
+<strong>Output:</strong>
+3
+<strong>Explanation:</strong>
+We can obtain X=1212 by concatenating:
+numbers[0] = 1 with numbers[1] = 212
+numbers[2] = 12 with numbers[3] = 12
+numbers[3] = 12 with numbers[2] = 12
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>
+N = 3
+numbers[] = {11, 11, 110}
+X = 11011
+<strong>Output:</strong>
+2
+<strong>Explanation:
+</strong>We can obtain X=11011 by concatenating:
+numbers[2] = 110 with numbers[0] = 11
+numbers[2] = 110 with numbers[1] = 11
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You dont need to read input or print anything. Your task is to complete the function&nbsp;<strong>countPairs()&nbsp;</strong>which takes<strong>&nbsp;</strong>the integer&nbsp;<strong>N ,&nbsp;</strong>the integer<strong> X,</strong>&nbsp;and the array&nbsp;<strong>numbers[]&nbsp;</strong>as the input parameters, and returns the number of pairs which satisfies the above condition.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N*Log<sub>10</sub>(A[i]) +&nbsp;(Log<sub>10</sub>X)<sup>2</sup>)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(N*Log<sub>10</sub>(A[i]))</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N&nbsp;≤ 5*10<sup>4</sup><sup>&nbsp;</sup><br>
+1 ≤ numbers[]&nbsp;≤ 10<sup>9</sup><br>
+1 ≤ X ≤ 10<sup>9</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Concatenate two numbers - GFG/concatenate-two-numbers.cpp b/Concatenate two numbers - GFG/concatenate-two-numbers.cpp
new file mode 100644
index 0000000..551e356
--- /dev/null
+++ b/Concatenate two numbers - GFG/concatenate-two-numbers.cpp	
@@ -0,0 +1,62 @@
+// { Driver Code Starts
+//Initial Template for C++
+#include <bits/stdc++.h> 
+using namespace std; 
+
+ // } Driver Code Ends
+//User function Template for C++
+class Solution{
+    public:
+    long long countPairs(int N, int X, vector<int> numbers){
+        unordered_map<int, int> suffixMap;
+        int n = X, suffix = 0, mul = 1;
+        while(n > 0) {
+            if(n % 10) {
+                suffix = n % 10 * mul + suffix;
+                for(auto num: numbers) suffixMap[suffix] += num == suffix;
+            }
+            n /= 10;
+            mul *= 10;
+        }
+        
+        int ans = 0;
+        mul /= 10;
+        while(mul > 0) {
+            int prefix = X / mul;
+            int suffix = X % mul;
+            
+            // Don't calculate if suffix starts with 0.
+            if(suffix >= mul / 10) {
+                int prefixCount = 0;
+                for(auto num: numbers) prefixCount += num == prefix;
+                
+                ans += prefixCount * suffixMap[suffix];
+                if(prefix == suffix) ans -= prefixCount;
+            }
+            
+            mul /= 10;
+        }
+        
+        return ans;
+    }
+};
+
+// { Driver Code Starts.
+int main() 
+{ 
+    int t;cin>>t;
+    while(t--)
+    {
+        int N,X;
+        cin>>N>>X;
+        vector<int> numbers(N);
+        for(int i=0;i<N;i++)
+            cin>>numbers[i];
+        Solution ob;
+        long long ans = ob.countPairs(N, X, numbers);
+        cout<<ans<<endl;
+        
+    }
+
+    return 0; 
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Corona Vaccine - GFG/README.md b/Corona Vaccine - GFG/README.md
new file mode 100644
index 0000000..9497597
--- /dev/null
+++ b/Corona Vaccine - GFG/README.md	
@@ -0,0 +1,52 @@
+# Corona Vaccine
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Geek has developed an effective vaccine for Corona virus and he wants each of the N houses in Geek Land to have access to it. Given a binary tree where each node represents a house in Geek Land, find the minimum number of houses that should be supplied with the vaccine kit if one vaccine kit is sufficient for that house, its parent house and it's immediate child nodes. &nbsp;</span></p>
+
+<p>&nbsp;</p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+    1
+   / \
+  2   3 
+        \
+         4
+          \
+           5
+            \
+             6</span>
+
+<span style="font-size:18px"><strong>Output:</strong>
+2
+<strong>Explanation:</strong>
+The vaccine kits should be 
+supplied to house numbers 1 and 5. </span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+    1
+   / \
+  2   3 </span>
+<span style="font-size:18px"><strong>Output:</strong>
+1
+<strong>Explanation:</strong>
+The vaccine kits should be 
+supplied to house number 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. Complete the function <strong>supplyVaccine() </strong>which takes the root of the housing tree as input parameter and returns the minimum number of houses that should be supplied with the vaccine kit.</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 ≤ N ≤ 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Corona Vaccine - GFG/corona-vaccine.cpp b/Corona Vaccine - GFG/corona-vaccine.cpp
new file mode 100644
index 0000000..7d67af0
--- /dev/null
+++ b/Corona Vaccine - GFG/corona-vaccine.cpp	
@@ -0,0 +1,155 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Node 
+{
+    int data;
+    Node *left;
+    Node *right;
+
+    Node(int val) {
+        data = val;
+        left = right = NULL;
+    }
+};
+
+// Function to Build Tree
+Node *buildTree(string str) 
+{
+    // Corner Case
+    if (str.length() == 0 || str[0] == 'N')
+        return NULL;
+
+    // Creating vector of strings from input
+    // string after spliting by space
+    vector<string> ip;
+
+    istringstream iss(str);
+    for (string str; iss >> str;)
+        ip.push_back(str);
+
+    // Create the root of the tree
+    Node *root = new Node(stoi(ip[0]));
+
+    // Push the root to the queue
+    queue<Node *> queue;
+    queue.push(root);
+
+    // Starting from the second element
+    int i = 1;
+    while (!queue.empty() && i < ip.size()) {
+
+        // Get and remove the front of the queue
+        Node *currNode = queue.front();
+        queue.pop();
+
+        // Get the current Node's value from the string
+        string currVal = ip[i];
+
+        // If the left child is not null
+        if (currVal != "N") {
+
+            // Create the left child for the current Node
+            currNode->left = new Node(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->left);
+        }
+
+        // For the right child
+        i++;
+        if (i >= ip.size())
+            break;
+        currVal = ip[i];
+
+        // If the right child is not null
+        if (currVal != "N") {
+
+            // Create the right child for the current Node
+            currNode->right = new Node(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->right);
+        }
+        i++;
+    }
+
+    return root;
+}
+
+ // } Driver Code Ends
+//User function Template for C++
+
+/*
+struct Node
+{
+    int data;
+    struct Node* left;
+    struct Node* right;
+    
+    Node(int x){
+        data = x;
+        left = right = NULL;
+    }
+};
+*/
+class Solution{
+public:
+    void solve(Node *par,Node *root,unordered_map<Node*,int> &mp,int &cnt){
+        if(root == nullptr){
+            return;
+        }
+        mp[root] = 0;//unlike adjlist we cannot mark all nodes as unvisited atfirst, we need separate traversal for that
+        solve(root,root->left,mp,cnt);
+        solve(root,root->right,mp,cnt);
+        if((root->left && mp[root->left]==0) || (root->right && mp[root->right]==0)){
+            mp[root] = 1;
+            if(root->left){
+                mp[root->left] = 1;
+            }
+            if(root->right){
+                mp[root->right] = 1;
+            }
+            mp[par] = 1;
+            //inc the cnt;
+            cnt += 1;
+        }
+        else{
+            return;
+        }
+    }
+    int supplyVaccine(Node* root){
+        // Your code goes here
+        unordered_map<Node*,int> mp;
+        int cnt = 0;
+        solve(root,root,mp,cnt);
+        //lastly check for root, bcoz there is not parent for root to check root as any decendent
+        if(mp[root] == 0){
+            cnt += 1;
+            mp[root] = 1;
+        }
+        return cnt;
+    }
+};
+
+// { Driver Code Starts.
+int main() 
+{
+    int t;
+    scanf("%d ", &t);
+    while (t--) {
+        string treeString;
+        getline(cin, treeString);
+        Node *root = buildTree(treeString);
+        Solution ob;
+        cout<<ob.supplyVaccine(root)<<"\n";
+    }
+    return 0;
+}
+
+
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Counts Zeros Xor Pairs - GFG/README.md b/Counts Zeros Xor Pairs - GFG/README.md
new file mode 100644
index 0000000..4bdddcb
--- /dev/null
+++ b/Counts Zeros Xor Pairs - GFG/README.md	
@@ -0,0 +1,43 @@
+# Counts Zeros Xor Pairs
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array A[] of size N. Find the number of pairs (i, j) such that<br>
+A<sub>i&nbsp;</sub>XOR A<sub>j</sub>&nbsp;= 0, and 1 ≤ i &lt; j ≤ N.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>​Input :</strong> arr[ ] = {1, 3, 4, 1, 4}
+<strong>Output :</strong> 2
+<strong>Explanation:</strong>
+Index( 0, 3 ) and (2 ,&nbsp;4 ) are&nbsp;only&nbsp;pairs 
+whose xors is zero so&nbsp;count&nbsp;is 2.
+</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>​Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input :</strong> arr[ ] = {2, 2, 2} <strong>
+Output :</strong>  3
+
+</span></pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+This is a function problem. The input is already taken care of by the driver code. You only need to complete the function <strong>calculate()</strong> that takes an array <strong>(arr)</strong>, sizeOfArray <strong>(n)</strong>, and return the count&nbsp;of Zeros Xor's Pairs. The driver code takes care of the printing.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N*Log(N)).<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(1).</span></p>
+
+<p><br>
+<br>
+<span style="font-size:18px"><strong>Output:</strong><br>
+For each test case, output a single integer i.e counts of Zeros Xors Pairs</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints</strong><br>
+2 ≤ N ≤ 10^5<br>
+1 ≤ A[i] ≤ 10^5</span></p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Counts Zeros Xor Pairs - GFG/counts-zeros-xor-pairs.cpp b/Counts Zeros Xor Pairs - GFG/counts-zeros-xor-pairs.cpp
new file mode 100644
index 0000000..777681d
--- /dev/null
+++ b/Counts Zeros Xor Pairs - GFG/counts-zeros-xor-pairs.cpp	
@@ -0,0 +1,48 @@
+// { Driver Code Starts
+// C++ program to find number 
+// of pairs in an array such
+// that their XOR is 0
+#include <bits/stdc++.h>
+using namespace std;
+
+// Function to calculate the
+// count
+long long int calculate(int a[], int n);
+
+// Driver Code
+int main()
+{
+
+	int t;
+	cin>>t;
+	while(t--)
+	{
+	  int n;
+	  cin>>n;
+	  int arr[n+1];
+	  for( int i=0;i<n;i++)
+	        cin>>arr[i];
+	    cout << calculate(arr, n)<<endl;
+        
+	}
+	return 0;
+}
+
+// } Driver Code Ends
+
+
+long long int calculate(int a[], int n)
+{
+   // Complete the function
+   map<int,int>mp;
+   for(int i=0;i<n;i++)
+   {
+       mp[a[i]]++;
+   }
+   int c=0;
+   for(auto it:mp)
+   {
+       c+=(it.second*(it.second-1))/2;
+   }
+   return c;
+}
\ No newline at end of file
diff --git a/Cousins of a given node - GFG/README.md b/Cousins of a given node - GFG/README.md
new file mode 100644
index 0000000..32482f4
--- /dev/null
+++ b/Cousins of a given node - GFG/README.md	
@@ -0,0 +1,51 @@
+# Cousins of a given node
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a binary tree and a node, print all cousins of given node in order of their appearance. Note that siblings should not be printed.</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
+        /   \  /  \
+       4    5  6   7</span>
+
+<span style="font-size:18px">Given node : 5</span>
+<span style="font-size:18px"><strong>Output :</strong> 6 7</span>
+<strong><span style="font-size:18px">Explanation :</span></strong>
+<span style="font-size:18px">Nodes 6 and 7 are on the same level 
+as 5 and have different parents.</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">         9</span>
+<span style="font-size:18px">        /</span>
+<span style="font-size:18px">       5</span>
+<span style="font-size:18px">Given node : 5</span>
+<span style="font-size:18px"><strong>Output :</strong> -1</span>
+<strong><span style="font-size:18px">Explanation :</span></strong>
+<span style="font-size:18px">There no other nodes than 5 in the same level.</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> printCousins() </strong>which takes the root node of the tree and&nbsp;the node whose cousins need to be found,&nbsp;as input and returns a list containing the cousins of the given node in order of their appearance in the tree. If there is no cousin of the given node, return<strong> -1</strong> as the first element of the list.</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(n)</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^5</span></div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Cousins of a given node - GFG/cousins-of-a-given-node.cpp b/Cousins of a given node - GFG/cousins-of-a-given-node.cpp
new file mode 100644
index 0000000..4eca120
--- /dev/null
+++ b/Cousins of a given node - GFG/cousins-of-a-given-node.cpp	
@@ -0,0 +1,217 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// A Binary Tree Node
+struct Node
+{
+	int data;
+	Node* left;
+	Node* right;
+};
+
+// Utility function to create a new Tree Node
+Node* newNode(int val)
+{
+	Node* temp = new Node;
+	temp->data = val;
+	temp->left = NULL;
+	temp->right = NULL;
+
+	return temp;
+}
+
+// Function to Build Tree
+Node* buildTree(string str)
+{
+	// Corner Case
+	if (str.length() == 0 || str[0] == 'N')
+		return NULL;
+
+	// Creating vector of strings from input
+	// string after spliting by space
+	vector<string> ip;
+
+	istringstream iss(str);
+	for (string str; iss >> str; )
+		ip.push_back(str);
+
+	// Create the root of the tree
+	Node* root = newNode(stoi(ip[0]));
+
+	// Push the root to the queue
+	queue<Node*> queue;
+	queue.push(root);
+
+	// Starting from the second element
+	int i = 1;
+	while (!queue.empty() && i < ip.size()) {
+
+		// Get and remove the front of the queue
+		Node* currNode = queue.front();
+		queue.pop();
+
+		// Get the current node's value from the string
+		string currVal = ip[i];
+
+		// If the left child is not null
+		if (currVal != "N") {
+
+			// Create the left child for the current node
+			currNode->left = newNode(stoi(currVal));
+
+			// Push it to the queue
+			queue.push(currNode->left);
+		}
+
+		// For the right child
+		i++;
+		if (i >= ip.size())
+			break;
+		currVal = ip[i];
+
+		// If the right child is not null
+		if (currVal != "N") {
+
+			// Create the right child for the current node
+			currNode->right = newNode(stoi(currVal));
+
+			// Push it to the queue
+			queue.push(currNode->right);
+		}
+		i++;
+	}
+
+	return root;
+}
+
+Node* pointer(Node* root, int n)
+{
+	if (root == NULL)
+		return NULL;
+
+	if (root->data == n)
+		return root;
+
+	Node* l = pointer(root->left, n);
+	if (l != NULL && l->data == n)
+		return l;
+
+	Node* r = pointer(root->right, n);
+	return r;
+
+}
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+/*
+// A Binary Tree Node
+struct Node
+{
+	int data;
+	Node* left;
+	Node* right;
+};*/
+
+class Solution
+{  
+   private:
+     int finddepth(Node * data,Node *root ,int depth=1)
+     {
+         if(root==NULL)
+         {
+             return 0;
+         }
+         if(root==data)
+         {
+             return depth;
+         }
+         else
+         {
+            int height1=finddepth(data,root->right,depth+1);
+            int height2=finddepth(data,root->left,depth+1);
+             return max(height1,height2);
+       
+         }
+         
+     }
+   
+   private:
+   void printhelper(int depth,vector<int> & ans,Node * root, Node * data)
+   {
+       if(root==NULL)
+       {
+           return;
+       }
+       if((root->left==data || root->right==data) and depth-1==1)
+       {
+           return;
+       }
+       if(depth==1 and root!=data)
+       {
+           ans.push_back(root->data);
+       }
+       else
+       {
+           printhelper(depth-1,ans,root->left,data);
+           printhelper(depth-1,ans,root->right,data);
+       }
+       return;
+   }
+   
+   public:
+   vector<int> printCousins(Node* root, Node* node_to_find)
+   {
+       //code here
+       vector<int> ans;
+       int depth=finddepth(node_to_find,root);
+       //cout<<"depth:"<<depth<<endl;
+       printhelper(depth,ans,root,node_to_find);
+       if(ans.size()==0)
+       {
+           ans.push_back(-1);
+       }
+       return ans;
+   }
+};
+
+
+// { Driver Code Starts.
+
+int main()
+{
+	int t;
+	cin >> t;
+	getchar();
+	while (t--)
+	{
+		int n;
+		cin >> n;
+		getchar();
+
+		string inp;
+		getline(cin, inp);
+		
+		struct Node* root = buildTree(inp);
+
+		Node* p = pointer(root, n);
+
+        Solution ob;
+		vector<int> ans = ob.printCousins(root, p);
+
+		for (int i = 0; i < ans.size(); i++)
+			cout << ans[i] << " ";
+
+		cout << "\n";
+
+
+	}
+
+	return 0;
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Cyclically rotate an array by one - GFG/README.md b/Cyclically rotate an array by one - GFG/README.md
new file mode 100644
index 0000000..ba1b74b
--- /dev/null
+++ b/Cyclically rotate an array by one - GFG/README.md	
@@ -0,0 +1,41 @@
+# Cyclically rotate an array by one
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array,&nbsp;rotate the&nbsp;array by one position in clock-wise direction.</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>
+N = 5
+A[] = {1, 2, 3, 4, 5}
+<strong>Output:</strong>
+5 1 2 3 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 = 8
+A[] = {9, 8, 7, 6, 4, 2, 1, 3}
+<strong>Output:</strong>
+3 9 8 7 6 4 2 1</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>rotate()</strong>&nbsp;which takes the array <strong>A[]</strong> and its size <strong>N </strong>as inputs and modify the array.</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&lt;=N&lt;=10<sup>5</sup><br>
+0&lt;=a[i]&lt;=10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Cyclically rotate an array by one - GFG/cyclically-rotate-an-array-by-one.cpp b/Cyclically rotate an array by one - GFG/cyclically-rotate-an-array-by-one.cpp
new file mode 100644
index 0000000..1b011ba
--- /dev/null
+++ b/Cyclically rotate an array by one - GFG/cyclically-rotate-an-array-by-one.cpp	
@@ -0,0 +1,39 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+void rotate(int arr[], int n);
+
+int main()
+{
+    int t;
+    scanf("%d",&t);
+    while(t--)
+    {
+        int n;
+        scanf("%d",&n);
+        int a[n] , i;
+        for(i=0;i<n;i++)
+        scanf("%d",&a[i]);
+        rotate(a, n);
+        for (i = 0; i < n; i++)
+            printf("%d ", a[i]);
+        printf("\n");
+    }
+        return 0;
+}
+// } Driver Code Ends
+
+
+//User function Template for C++
+
+void rotate(int arr[], int n)
+{
+    int temp = arr[n-1];
+    for(int i=n-1;i>=1;i--)
+    arr[i] = arr[i-1];
+    
+    arr[0] = temp;
+    
+}
\ No newline at end of file
diff --git a/Escape the Forbidden Forest - GFG/README.md b/Escape the Forbidden Forest - GFG/README.md
new file mode 100644
index 0000000..6b086f9
--- /dev/null
+++ b/Escape the Forbidden Forest - GFG/README.md	
@@ -0,0 +1,42 @@
+# Escape the Forbidden Forest
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Penelope and her classmates are lost in the Forbidden Forest and the Devil is out to get them. But Penelope has magical powers that can build bridges across the dangerous river and take her friends to safety. The only bridges that can withstand the Devil's wrath are the ones built between two similar trees in the forest.&nbsp;<br>
+Given str1 and str2 denoting the order of trees on either side of the river, find the maximum number of bridges that Penelope can build and save everyone from the Devil.&nbsp;</span><br>
+<span style="font-size:18px"><strong>Note:</strong> Each tree in the forest belongs to one of the 3 categories represented by * or # or @</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+str1 = "*@#*" </span>
+<span style="font-size:18px">str2 = "*#"</span>
+<span style="font-size:18px"><strong>Output:</strong>
+2</span>
+<span style="font-size:18px"><strong>Explanation:</strong>
+str1 = "*@#*" and str2 = "*#" 
+Two bridges can be built between the banks 
+of the river in the following manner. 
+* @ # *
+|      |
+*     #</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong></span>
+<span style="font-size:18px">str1 = "***"</span>
+<span style="font-size:18px">str2 = "##"</span>
+<span style="font-size:18px"><strong>Output:</strong>
+0</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Complete the function <strong>build_bridges()</strong> that takes str1 and str2 as input parameters and returns the maximum number of bridges that can be built.&nbsp;</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N*M)<br>
+<strong>Expected Auxiliary Space:</strong> O(N*M)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N, M ≤ 100<br>
+Where, N and M are the size of the string str1 and str2 respectively.</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Escape the Forbidden Forest - GFG/escape-the-forbidden-forest.cpp b/Escape the Forbidden Forest - GFG/escape-the-forbidden-forest.cpp
new file mode 100644
index 0000000..9e8fcb1
--- /dev/null
+++ b/Escape the Forbidden Forest - GFG/escape-the-forbidden-forest.cpp	
@@ -0,0 +1,53 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std; 
+
+
+ // } Driver Code Ends
+class Solution
+{
+    public:
+    int build_bridges(string str1, string str2)
+    {
+       int dp[101][101];
+        int x = str1.length(), y = str2.length();
+        
+        for(int i=0; i<=x; i++)
+        {
+            for(int j=0; j<=y; j++)
+            {
+                if(i == 0 || j == 0)
+                dp[i][j] = 0;
+                
+                else if(str1[i-1] == str2[j-1])
+                dp[i][j] = 1 + dp[i-1][j-1];
+                
+                else
+                dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
+            }
+        }
+    
+        return dp[x][y];
+    }
+};
+
+// { Driver Code Starts.
+int main()
+{
+    ios_base::sync_with_stdio(0);
+    cin.tie(NULL);
+    cout.tie(NULL);
+
+    int t;
+    cin >> t;
+
+    while(t--)
+    {
+        string str1,str2;
+        cin >> str1 >> str2;
+        Solution obj;
+        cout<<obj.build_bridges(str1,str2)<<endl;
+    } 
+    return 0;
+} 
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Even and Odd - GFG/README.md b/Even and Odd - GFG/README.md
new file mode 100644
index 0000000..c6ae121
--- /dev/null
+++ b/Even and Odd - GFG/README.md	
@@ -0,0 +1,44 @@
+# Even and Odd
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array <strong>arr[] </strong>of size <strong>N</strong> containing equal number of odd and even numbers. Arrange the numbers in such a way that all the even numbers get the even index and odd numbers get the odd index.<br>
+<strong>Note: </strong>There are multiple possible solutions, Print any one of them. Also, 0-based indexing is considered.</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
+arr[] = {3, 6, 12, 1, 5, 8}
+<strong>Output:</strong></span>
+<span style="font-size:18px">1
+<strong>Explanation:
+</strong>6 3 12 1 8 5 is a possible solution.
+The output will always be 1 if your
+rearrangement is correct.</span>
+</pre>
+
+<div><span style="font-size:18px"><strong>Example 2:</strong></span></div>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 4
+arr[] = {1, 2, 3, 4}
+<strong>Output :</strong>
+1</span>
+</pre>
+
+<p><br>
+<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>reArrange()</strong>&nbsp;which takes an integer N and an array arr of size N as input and reArranges the array in Place without any extra space.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>5</sup><br>
+1 ≤ arr[i] ≤ 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Even and Odd - GFG/even-and-odd.cpp b/Even and Odd - GFG/even-and-odd.cpp
new file mode 100644
index 0000000..f7d27e2
--- /dev/null
+++ b/Even and Odd - GFG/even-and-odd.cpp	
@@ -0,0 +1,75 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution {
+  public:
+   
+void reArrange(int arr[], int N){
+    int i=0, j=1;
+    while(i<N && j<N){
+        if(arr[i]%2==0){ i+=2; }
+        if(arr[j]%2==1){ j+=2; }
+        else if(arr[i]%2==1 && arr[j]%2==0)
+        { int value=arr[i]; arr[i]=arr[j]; arr[j]=value; i+=2; j+=2; }
+    }
+}
+};
+
+// { Driver Code Starts.
+
+int check(int arr[], int n)
+{
+    int flag = 1;
+    int c=0, d=0;
+    for(int i=0; i<n; i++)
+    {
+        if(i%2==0)
+        {
+            if(arr[i]%2)
+            {
+                flag = 0;
+                break;
+            }
+            else
+                c++;
+        }
+        else
+        {
+            if(arr[i]%2==0)
+            {
+                flag = 0;
+                break;
+            }
+            else
+                d++;
+        }
+    }
+    if(c!=d)
+        flag = 0;
+        
+    return flag;
+}
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int N;
+        cin>>N;
+        
+        int arr[N];
+        for(int i=0; i<N; i++)
+            cin>>arr[i];
+
+        Solution ob;
+        ob.reArrange(arr,N);
+        
+        cout<<check(arr,N)<<endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Excel Sheet _ Part - 1 - GFG/README.md b/Excel Sheet _ Part - 1 - GFG/README.md
new file mode 100644
index 0000000..77a1e36
--- /dev/null
+++ b/Excel Sheet _ Part - 1 - GFG/README.md	
@@ -0,0 +1,25 @@
+# Excel Sheet | Part - 1
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a positive integer N, return&nbsp;its corresponding column title as it would appear in an Excel sheet.<br>
+For N =1 we have column A, for 27 we have AA and so on.</span></p>
+
+<p><span style="font-size:18px"><strong>Note: </strong>The alphabets are all in uppercase.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 51
+<strong>Output: </strong>AY</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+Complete the function <strong>ExcelColumn()</strong> which takes N as input and returns output string.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(Log(N))<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(Log(N))</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong></span><br>
+<span style="font-size:18px">1 ≤ N ≤ 10<sup>7</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Excel Sheet _ Part - 1 - GFG/excel-sheet-part-1.cpp b/Excel Sheet _ Part - 1 - GFG/excel-sheet-part-1.cpp
new file mode 100644
index 0000000..c41cacb
--- /dev/null
+++ b/Excel Sheet _ Part - 1 - GFG/excel-sheet-part-1.cpp	
@@ -0,0 +1,50 @@
+// { Driver Code Starts
+//Initial template for C++
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function template for C++
+
+class Solution{
+    public:
+  string ExcelColumn(int N)
+    {
+        // Your code goes here
+        string ans = "";
+        while(N != 0)
+        {
+            int h = (N%26);
+            if(h == 0)
+            {
+                h = 26;
+            }
+            h--;
+            ans += 'A' + h;
+            N = N/26;
+            if(N == 1 && h == 25) break;
+            if(h == 25) N--;
+        }
+        reverse(ans.begin(), ans.end());
+        return ans;
+    }
+
+};
+
+// { Driver Code Starts.
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int n;
+        cin>>n;
+        Solution ob;
+        cout<<ob.ExcelColumn(n)<<endl;
+    }
+    return 0;
+}
+      // } Driver Code Ends
\ No newline at end of file
diff --git a/Find Missing And Repeating - GFG/README.md b/Find Missing And Repeating - GFG/README.md
new file mode 100644
index 0000000..5979342
--- /dev/null
+++ b/Find Missing And Repeating - GFG/README.md	
@@ -0,0 +1,36 @@
+# Find Missing And Repeating
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an unsorted array <strong>Arr</strong> of size <strong>N</strong> of positive integers. <strong>One number 'A'</strong> from set {1, 2, …N} is missing and <strong>one number 'B'</strong> occurs twice in array. Find these two numbers.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 2
+Arr[] = {2, 2}
+<strong>Output:</strong> 2 1
+<strong>Explanation:</strong> Repeating number is 2 and 
+smallest positive missing number 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 = 3
+Arr[] = {1, 3, 3}
+<strong>Output:</strong> 3 2
+<strong>Explanation:</strong>&nbsp;Repeating number is 3 and 
+smallest positive missing number is 2.
+</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>findTwoElement()</strong>&nbsp;which takes the&nbsp;array of integers&nbsp;<strong>arr</strong>&nbsp;and&nbsp;<strong>n&nbsp;</strong>as parameters and returns an array of integers of size 2 denoting the answer ( The first index contains&nbsp;<strong>B&nbsp;</strong>and second index contains&nbsp;<strong>A.)</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><br>
+1 ≤ N ≤ 10<sup>5</sup><br>
+1 ≤ Arr[i] ≤ N</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Find Missing And Repeating - GFG/find-missing-and-repeating.cpp b/Find Missing And Repeating - GFG/find-missing-and-repeating.cpp
new file mode 100644
index 0000000..3253253
--- /dev/null
+++ b/Find Missing And Repeating - GFG/find-missing-and-repeating.cpp	
@@ -0,0 +1,56 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+
+using namespace std;
+
+ // } Driver Code Ends
+class Solution{
+public:
+    //Using swap sort in O(n)
+
+int *findTwoElement(int *arr, int n) {
+		
+        int *arr1 = new int[2];
+        
+        //unsorted arr 2 3 1 1 5
+        int i=0;
+        while(i<n){
+            if(arr[i] != arr[arr[i]-1])
+            swap(arr[i], arr[arr[i]-1]);
+            else
+            i++;
+        }
+        
+        //sorted array 1 2 3 1 5
+        int a=0,b=0;
+        for(int i=0;i<n;i++){
+            if(arr[i]!=i+1){
+                a=i+1;
+                b=arr[i];
+                break;
+            }
+        }
+        arr1[0]=b;
+        arr1[1]=a;
+        return arr1;
+    }
+};
+
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+        int a[n];
+        for (int i = 0; i < n; i++) {
+            cin >> a[i];
+        }
+        Solution ob;
+        auto ans = ob.findTwoElement(a, n);
+        cout << ans[0] << " " << ans[1] << "\n";
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Find Nth root of M - GFG/README.md b/Find Nth root of M - GFG/README.md
new file mode 100644
index 0000000..7e689fb
--- /dev/null
+++ b/Find Nth root of M - GFG/README.md	
@@ -0,0 +1,36 @@
+# Find Nth root of M
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">You are given 2 numbers <strong>(n&nbsp;, m)</strong>; the task is to find <strong><sup>n</sup>√m</strong>&nbsp;(n<sup>th</sup> root of m).</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>n = 2, m = 9
+<strong>Output: </strong>3
+<strong>Explanation: </strong>3<sup>2</sup>&nbsp;= 9</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>n = 3, m = 9
+<strong>Output: </strong>-1
+<strong>Explanation: </strong>3rd root of 9 is not
+integer.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read or print anyhting. Your task is to complete the function<strong>&nbsp;NthRoot()</strong>&nbsp;which takes n and m as input parameter and returns the nth root of m. If the root is not integer then returns -1.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(n* log(m))<br>
+<strong>Expected Space Complexity:&nbsp;</strong>O(1)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= n &lt;= 30</span><br>
+<span style="font-size:18px">1 &lt;= m &lt;= 10<sup>9</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Find Nth root of M - GFG/find-nth-root-of-m.cpp b/Find Nth root of M - GFG/find-nth-root-of-m.cpp
new file mode 100644
index 0000000..c4cb07a
--- /dev/null
+++ b/Find Nth root of M - GFG/find-nth-root-of-m.cpp	
@@ -0,0 +1,40 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution{
+	public:
+	int NthRoot(int n, int m)
+	{
+	    int low = 1;
+	    int high = m;
+	    while(low<=high)
+	    {
+	        int mid = low + (high-low)/2;
+	        
+	        
+	        if(pow(mid,n) == m )
+	           return mid;
+	        else if(pow(mid,n) > m)
+	            high = mid-1;
+	        else 
+	            low = mid+1;
+	    }
+	    return -1;
+	}  
+};
+
+// { Driver Code Starts.
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		int n, m;
+		cin >> n >> m;
+		Solution ob;
+		int ans = ob.NthRoot(n, m);
+		cout << ans << "\n";
+	}  
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Find Prime numbers in a range - GFG/README.md b/Find Prime numbers in a range - GFG/README.md
new file mode 100644
index 0000000..41b3e94
--- /dev/null
+++ b/Find Prime numbers in a range - GFG/README.md	
@@ -0,0 +1,38 @@
+# Find Prime numbers in a range
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given two integers M and N, generate all primes between M and N.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+M=1,N=10
+<strong>Output:</strong>
+2 3 5 7
+<strong>Explanation:</strong>
+The prime numbers between 1 and 10
+are 2,3,5 and 7.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+M=2, N=5
+<strong>Output:</strong>
+2,3,5
+<strong>Explanation:</strong>
+The prime numbers between 2 and 5 are 
+2,3 and 5.</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 primeRange() which takes 2 integer inputs M and N and returns a list of all primes between M and N.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong>O(N*sqrt(N))<br>
+<strong>Expected Auxillary Space:</strong>O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1&lt;=M&lt;=N&lt;=10<sup>6</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Find Prime numbers in a range - GFG/find-prime-numbers-in-a-range.cpp b/Find Prime numbers in a range - GFG/find-prime-numbers-in-a-range.cpp
new file mode 100644
index 0000000..449dac7
--- /dev/null
+++ b/Find Prime numbers in a range - GFG/find-prime-numbers-in-a-range.cpp	
@@ -0,0 +1,49 @@
+// { Driver Code Starts
+// Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+
+class Solution {
+  public:
+   bool isPrime(int n){
+        if(n==1){
+            return false;
+        }
+        for(int i=2;i<=sqrt(n);i++){
+            if(n%i==0){
+                return false;
+            }
+        }
+        return true;
+    }
+  
+    vector<int> primeRange(int M, int N) {
+        // code here
+        vector<int> v;
+        for(int i=M;i<=N;i++){
+            if(isPrime(i)){
+                v.push_back(i);
+            }
+        }
+        return v;
+    }
+};
+
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int N, M, K;
+        cin >> M >> N;
+        Solution ob;
+        vector<int> ans = ob.primeRange(M, N);
+        for (auto u : ans) cout << u << " ";
+        cout << "\n";
+    }
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Find position of set bit - GFG/README.md b/Find position of set bit - GFG/README.md
new file mode 100644
index 0000000..7ae3bc1
--- /dev/null
+++ b/Find position of set bit - GFG/README.md	
@@ -0,0 +1,39 @@
+# Find position of set bit
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a number <strong>N</strong> having only one ‘1’ and all other ’0’s in its binary representation, find position of the only set bit. If there are 0 or more than 1 set bit the answer should be -1. Position of &nbsp;set bit&nbsp;'1' should be counted starting with 1 from LSB side in&nbsp;binary representation of the number.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong></span>
+<span style="font-size:18px"><strong>N = </strong>2</span>
+<span style="font-size:18px"><strong>Output:</strong></span>
+<span style="font-size:18px">2</span>
+<span style="font-size:18px"><strong>Explanation:</strong></span>
+<span style="font-size:18px">2 is represented as "10" in Binary.
+As we see there's only one set bit
+and it's in Position 2 and thus the
+Output 2.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong></span>
+<span style="font-size:18px"><strong>N = </strong>5</span>
+<span style="font-size:18px"><strong>Output:</strong></span>
+<span style="font-size:18px">-1</span>
+<span style="font-size:18px"><strong>Explanation:</strong></span>
+<span style="font-size:18px">5 is represented as "101" in Binary.
+As we see there's two set bits
+and thus the Output -1.</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 <strong>findPosition()</strong> which takes an integer N as input and returns the answer.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(log(N))<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong></span><br>
+<span style="font-size:18px">0 &lt;= N &lt;= 10<sup>8</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Find position of set bit - GFG/find-position-of-set-bit.cpp b/Find position of set bit - GFG/find-position-of-set-bit.cpp
new file mode 100644
index 0000000..caf60fc
--- /dev/null
+++ b/Find position of set bit - GFG/find-position-of-set-bit.cpp	
@@ -0,0 +1,38 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution {
+  public:
+   int findPosition(int N) {
+  if (N == 0) return -1;
+  if (N == 1 || N == 2) return N;
+  // if N is odd and > 1, it will have more than 1 set bits;
+  if (N & 1) return -1;
+
+  int setBitPos = 2;
+  while (N > 2) {
+    setBitPos++;
+    N = N / 2;
+    if (!N & 1) continue;
+    if (N & 1) return -1;
+  }
+  return setBitPos;
+}
+};
+
+// { Driver Code Starts.
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int N;
+
+        cin>>N;
+
+        Solution ob;
+        cout << ob.findPosition(N) << endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Find rectangle with corners as 1 - GFG/README.md b/Find rectangle with corners as 1 - GFG/README.md
new file mode 100644
index 0000000..48d74a2
--- /dev/null
+++ b/Find rectangle with corners as 1 - GFG/README.md	
@@ -0,0 +1,39 @@
+# Find rectangle with corners as 1
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a&nbsp;NxM binary matrix consisting of 0s and 1s. Find if there exists a rectangle/ square within the matrix whose all four corners are 1.&nbsp;</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 4, M = 5
+matrix[][] = 
+{
+{1 0 0 1 0},
+{0 0 <span style="color:#FF0000">1</span> 0 <span style="color:#FF0000">1</span>},
+{0 0 0 1 0}, 
+{1 0 <span style="color:#FF0000">1</span> 0 <span style="color:#FF0000">1</span>}
+} </span>
+
+<span style="font-size:18px"><strong>Output</strong>: Yes
+<strong>Explanation:</strong>
+Valid corners are at index (1,2), (1,4), (3,2), (3,4) </span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 3, M = 3
+matrix[][] = 
+{{0 0 0},
+{0 0 0},
+{0 0 0}}
+<strong>Output:</strong> No</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to take input or print anything. Complete the function <strong>ValidCorners()</strong>&nbsp;that takes the given matrix as input parameter and returns a boolean value.</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= R, C &lt;= 200<br>
+0 &lt;= A[i] &lt;= 1</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Find rectangle with corners as 1 - GFG/find-rectangle-with-corners-as-1.cpp b/Find rectangle with corners as 1 - GFG/find-rectangle-with-corners-as-1.cpp
new file mode 100644
index 0000000..df244e0
--- /dev/null
+++ b/Find rectangle with corners as 1 - GFG/find-rectangle-with-corners-as-1.cpp	
@@ -0,0 +1,69 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h> 
+#include <unordered_map>
+#include <unordered_set>
+using namespace std; 
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution{
+    public:
+ bool ValidCorner(const vector<vector<int> >& matrix)
+    {
+        // Your code goes here
+        int m = matrix.size();
+        int n = matrix[0].size();
+        unordered_map<int,unordered_set<int>> temp;
+        
+        for(int i=0;i<m;i++){
+            for(int j=0;j<n;j++){
+                for(int k = j+1;k<n;k++){
+                    if(matrix[i][j] == 1 and matrix[i][k] == 1){
+                        // we found one pair on that row
+                        // next we have to check if we get any  pair in same column and different row
+                        // firstly finding key(first occourence of 1 in the row) , then finding if have the same pair in the set. 
+                        if(temp.find(j) != temp.end() and temp[j].find(k) != temp[j].end()) return true;
+                        else temp[j].insert(k); // we are {col,(next occ of 1 in the same row)} => {col,(col+)} pair
+                    }
+                }
+            }
+        }
+        return false;
+    }
+};
+
+// { Driver Code Starts.
+int main() 
+{ 
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int row, col;
+        cin>> row>> col;
+
+        vector<vector<int> > matrix(row);
+            
+        for(int i=0; i<row; i++)
+        {
+            matrix[i].assign(col, 0);
+            for( int j=0; j<col; j++)
+            {
+                cin>>matrix[i][j];
+            }
+        }
+        Solution ob;
+        if (ob.ValidCorner(matrix)) 
+            cout << "Yes\n"; 
+        else
+            cout << "No\n"; 
+    }
+
+    return 0;
+} 
+
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Find the Closest Element in BST - GFG/README.md b/Find the Closest Element in BST - GFG/README.md
new file mode 100644
index 0000000..8a987d1
--- /dev/null
+++ b/Find the Closest Element in BST - GFG/README.md	
@@ -0,0 +1,50 @@
+# Find the Closest Element in BST
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a <strong><a href="http://quiz.geeksforgeeks.org/binary-search-tree-set-1-search-and-insertion/" target="_blank">BST</a></strong>&nbsp;and an integer. Find the least absolute difference between any node value of the BST and the given integer.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>        10
+&nbsp;     /   \
+&nbsp;    2    11
+&nbsp;  /  \ 
+&nbsp; 1    5
+&nbsp;     /  \
+&nbsp;    3    6
+&nbsp;     \
+&nbsp;      4
+K = 13
+<strong>Output: </strong>2<strong>
+Explanation: </strong>K=13. The node that has
+value nearest to K is 11. so the answer
+is 2</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>      8
+&nbsp;   /   \
+&nbsp;  1     9
+&nbsp;   \     \
+&nbsp;    4    10
+&nbsp;   /
+&nbsp;  3
+K = 9
+<strong>Output: </strong>0<strong>
+Explanation: </strong>K=9. The node that has
+value nearest to K is 9. so the answer
+is 0.</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</span><span style="font-size:18px"><strong> minDiff()&nbsp;</strong>that takes&nbsp;the root of the BST and an integer K as its input and returns the minimum absolute difference between any node value of the BST and the integer K.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(Height of the BST).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(Height of the BST).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= Number of nodes&nbsp;&lt;= 100000</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Find the Closest Element in BST - GFG/find-the-closest-element-in-bst.cpp b/Find the Closest Element in BST - GFG/find-the-closest-element-in-bst.cpp
new file mode 100644
index 0000000..09f3bd5
--- /dev/null
+++ b/Find the Closest Element in BST - GFG/find-the-closest-element-in-bst.cpp	
@@ -0,0 +1,135 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+#define MAX_HEIGHT 100000
+
+// Tree Node
+struct Node {
+    int data;
+    Node *left;
+    Node *right;
+
+    Node(int val) {
+        data = val;
+        left = right = NULL;
+    }
+};
+
+
+
+ // } Driver Code Ends
+
+
+class Solution
+{
+    public:
+    //Function to find the least absolute difference between any node
+	//value of the BST and the given integer.
+    int minDiff(Node *root, int K)
+    {
+        if(root){
+           int d = abs(root->data - K);
+           if(K > root->data)
+               return min(d, minDiff(root->right, K));
+           else if(K < root->data)
+               return min(d, minDiff(root->left, K));
+           else
+               return 0;
+       }else
+           return INT_MAX;
+    }
+};
+
+
+// { Driver Code Starts.
+
+// Function to Build Tree
+Node* buildTree(string str)
+{
+   // Corner Case
+   if(str.length() == 0 || str[0] == 'N')
+       return NULL;
+
+   // Creating vector of strings from input
+   // string after spliting by space
+   vector<string> ip;
+
+   istringstream iss(str);
+   for(string str; iss >> str; )
+       ip.push_back(str);
+
+   // Create the root of the tree
+   Node* root = new Node(stoi(ip[0]));
+
+   // Push the root to the queue
+   queue<Node*> queue;
+   queue.push(root);
+
+   // Starting from the second element
+   int i = 1;
+   while(!queue.empty() && i < ip.size()) {
+
+       // Get and remove the front of the queue
+       Node* currNode = queue.front();
+       queue.pop();
+
+       // Get the current node's value from the string
+       string currVal = ip[i];
+
+       // If the left child is not null
+       if(currVal != "N") {
+
+           // Create the left child for the current node
+           currNode->left = new Node(stoi(currVal));
+
+           // Push it to the queue
+           queue.push(currNode->left);
+       }
+
+       // For the right child
+       i++;
+       if(i >= ip.size())
+           break;
+       currVal = ip[i];
+
+       // If the right child is not null
+       if(currVal != "N") {
+
+           // Create the right child for the current node
+           currNode->right = new Node(stoi(currVal));
+
+           // Push it to the queue
+           queue.push(currNode->right);
+       }
+       i++;
+   }
+
+   return root;
+}
+
+
+
+int main() {
+   
+   int t;
+   string tc;
+   getline(cin, tc);
+   t=stoi(tc);
+   while(t--)
+   {
+        string s; 
+       getline(cin, s);
+       Node* root1 = buildTree(s);
+
+       getline(cin, s);
+       int k = stoi(s);
+       // getline(cin, s);
+
+        Solution ob;
+       cout << ob.minDiff(root1, k);
+        cout << endl;
+       //cout<<"~"<<endl;
+   }
+   return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Find the Maximum Flow - GFG/README.md b/Find the Maximum Flow - GFG/README.md
new file mode 100644
index 0000000..d05de7b
--- /dev/null
+++ b/Find the Maximum Flow - GFG/README.md	
@@ -0,0 +1,51 @@
+# Find the Maximum Flow
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a graph with N vertices numbered 1 to N and M edges, The task is to find the max flow from vertex 1 to vertex N.</span></p>
+
+<p><span style="font-size:18px">In a flow network, the maximum flow of a path can't exceed the flow-capacity of an edge in the path.<br>
+<br>
+<strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 5, M =  4
+Edges[]= { {1, 2, 1} , {3, 2, 2}, {4, 2, 3}, {2, 5, 5} }
+<strong>Output:</strong>
+1 
+<strong>Explanation: </strong>
+1 - 2 - 3
+   / \
+  4   5 
+1 unit can flow from 1 -&gt; 2 - &gt;5 </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 = 4 , M = 4
+Edges[] = { {1, 2, 8}, {1, 3, 10}, {4, 2, 2}, {3, 4, 3} }
+<strong>Output:</strong>
+5 
+<strong>Explanation:</strong>
+  1 - 2 
+  |   |
+  3 - 4
+3 unit can flow from 1 -&gt; 3 -&gt; 4
+2 unit can flow from 1 -&gt; 2 -&gt; 4
+Total max flow from 1 to N = 3+2=5</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:&nbsp;</strong><br>
+You don't need to read input or print anything. Your task is to complete the function<strong>&nbsp;solve()</strong>&nbsp;which takes the <strong>N&nbsp;</strong>(the number of vertices) ,<strong>M </strong>(the number of Edges) and the array <strong>Edges</strong>[]&nbsp;(Where Edges[i]&nbsp;denoting an undirected edge between&nbsp;Edges[i][0] and&nbsp;Edges[i][1]&nbsp;with a flow capacity of Edges[i][2]&nbsp;),&nbsp;and returns the&nbsp;integer&nbsp;denoting the maximum flow from 1 to N.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O( max_flow* M)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(N+M)</span></p>
+
+<p><span style="font-size:18px">Where max_flow is the maximum flow from&nbsp;1 to N</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N,M,Edges[i][2] &lt;= 1000</span><br>
+<span style="font-size:18px">1 &lt;= Edges[i][0],Edges[i][1] &lt;= N</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Find the Maximum Flow - GFG/find-the-maximum-flow.cpp b/Find the Maximum Flow - GFG/find-the-maximum-flow.cpp
new file mode 100644
index 0000000..301183d
--- /dev/null
+++ b/Find the Maximum Flow - GFG/find-the-maximum-flow.cpp	
@@ -0,0 +1,126 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution
+{
+public:
+ int BFS(vector<vector<int>> &graph,vector<int> &parent,int source,int sink,int N)
+   {
+       int min_cap=INT_MAX;
+       fill(parent.begin(), parent.end(), -1);
+       vector<bool> visited(N,false);
+       queue<int> q;
+       
+       q.push(source);
+       visited[source]=true;
+       parent[source]=-1;
+       
+       while(q.empty()==false)
+       {
+           auto u=q.front();
+           q.pop();
+           
+           //adjacents
+           
+           for(int v=0;v<N;v++)
+           {
+               if(visited[v]==false && graph[u][v]!=0)
+               {
+                   if(v==sink)
+                   {
+                       parent[v]=u;
+                       min_cap=min(min_cap,graph[u][v]);
+                       return min_cap;
+                   }
+                   
+                   q.push(v);
+                   visited[v]=true;
+                   min_cap=min(min_cap,graph[u][v]);
+                   parent[v]=u;
+               }
+           }
+       }
+       
+       return 0;
+   }
+   
+   int fordFulkerson(vector<vector<int>> &graph,int source,int sink,int N)
+   {
+       vector<int> parent(N,-1);
+       
+       int res=0;
+       
+       while(BFS(graph,parent,source,sink,N)!=0)
+       {
+           int min_cap=BFS(graph,parent,source,sink,N);
+           
+           res+=min_cap;
+           
+           //considering all the edged in this path.
+           
+           int v=sink;
+           while(v!=source)
+           {
+               int u=parent[v];
+               graph[u][v]-=min_cap;
+               graph[v][u]+=min_cap;
+               v=parent[v];
+           }
+       }
+       
+       return res;
+   }
+   
+   int solve(int N,int M,vector<vector<int>> Edges)
+   {
+       // code here
+       vector<vector<int>> graph;
+       
+       for(int i=0;i<N;i++)
+       {
+           vector<int> v1;
+           for(int j=0;j<N;j++)
+           {
+               v1.push_back(0);
+           }
+           graph.push_back(v1);
+       }
+       
+       for(auto x: Edges)
+       {
+           int u=x[0]-1;
+           int v=x[1]-1;
+           int wt=x[2];
+           
+           graph[u][v]+=wt;
+           graph[v][u]+=wt;
+       }
+       
+       return fordFulkerson(graph,0,N-1,N);
+       
+   }
+};
+
+// { Driver Code Starts.
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--){
+        int i,j,N,M,u,v,w;
+        int res;
+        scanf("%d %d",&N,&M);
+        vector<vector<int>> Edges; 
+        for(i=0;i<M;i++)
+        {
+            scanf("%d %d %d",&u,&v,&w);
+        	Edges.push_back({u,v,w});
+    	}
+        Solution obj;
+        res = obj.solve(N, M, Edges);
+        cout<<res<<endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Find the number of islands - GFG/README.md b/Find the number of islands - GFG/README.md
new file mode 100644
index 0000000..7fca55d
--- /dev/null
+++ b/Find the number of islands - GFG/README.md	
@@ -0,0 +1,50 @@
+# Find the number of islands
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a grid of size n*m (n is number of rows and m is number of columns grid has) consisting of '0's(Water)&nbsp;and '1's(Land). Find the number of islands.</span><br>
+<strong><span style="font-size:18px">Note: </span></strong><span style="font-size:18px">An&nbsp;island&nbsp;is surrounded by water and is formed by connecting adjacent lands horizontally or vertically or diagonally i.e., in all 8 directions.</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>grid = {{0,1},{1,0},{1,1},{1,0}}
+<strong>Output:
+</strong>1
+<strong>Explanation:
+</strong>The grid is-
+0 <span style="color:#000080">1</span></span>
+<span style="font-size:18px"><span style="color:#000080">1</span> 0
+<span style="color:#000080">1</span> <span style="color:#000080">1
+1</span> 0
+All lands are connected.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>grid = {{0,1,1,1,0,0,0},{0,0,1,1,0,1,0}}
+<strong>Output:
+</strong>2
+<strong>Expanation:
+</strong>The grid is-
+0 <span style="color:#000080">1 1 1</span> 0 0 0
+0 0 <span style="color:#000080">1 1</span> 0 <span style="color:#FF0000">1</span> 0&nbsp;
+There are two islands one is colored in blue 
+and other in orange.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read or print anything. Your task is to complete the function <strong>numIslands()&nbsp;</strong>which takes grid as input parameter and returns the total number of islands.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Compelxity:&nbsp;</strong>O(n*m)<br>
+<strong>Expected Space Compelxity:&nbsp;</strong>O(n*m)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ n, m ≤ 500</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Find the number of islands - GFG/find-the-number-of-islands.cpp b/Find the number of islands - GFG/find-the-number-of-islands.cpp
new file mode 100644
index 0000000..3eb234e
--- /dev/null
+++ b/Find the number of islands - GFG/find-the-number-of-islands.cpp	
@@ -0,0 +1,57 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution {
+  public:
+    // Function to find the number of islands.
+   int numIslands(vector<vector<char>>& grid) {
+        
+        int n = grid.size();
+        int m = grid[0].size();
+        
+        function<void(int, int)> dfs = [&] (int x, int y) {
+            if(x < 0 || x >= n || y < 0 || y >= m || grid[x][y] != '1') return;
+            // Mark current cell as visited.
+            grid[x][y] = '#';
+            
+            // Traverse all 8 neighbors.
+            for(int i = -1; i <= 1; i++) for(int j = -1; j <= 1; j++) {
+                int nx = x + i;
+                int ny = y + j;
+                if(x == nx && y == ny) continue; // Why should I call myself ;)
+                dfs(nx, ny);
+            }
+        };
+        
+        int ans = 0;
+        
+        for(int i = 0; i < n; i++) for(int j = 0; j < m; j++) if(grid[i][j] == '1') {
+            ++ans;
+            dfs(i, j);
+        }
+        
+        return ans;
+    }
+};
+
+// { Driver Code Starts.
+int main() {
+    int tc;
+    cin >> tc;
+    while (tc--) {
+        int n, m;
+        cin >> n >> m;
+        vector<vector<char>> grid(n, vector<char>(m, '#'));
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                cin >> grid[i][j];
+            }
+        }
+        Solution obj;
+        int ans = obj.numIslands(grid);
+        cout << ans << '\n';
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Form a palindrome - GFG/README.md b/Form a palindrome - GFG/README.md
new file mode 100644
index 0000000..2331b4e
--- /dev/null
+++ b/Form a palindrome - GFG/README.md	
@@ -0,0 +1,40 @@
+# Form a palindrome
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a string, find the minimum number of characters to be inserted to convert it to palindrome.<br>
+For Example:<br>
+ab: Number of insertions required is 1.&nbsp;<strong>b</strong>ab or aba<br>
+aa: Number of insertions required is 0. aa<br>
+abcd: Number of insertions required is 3.&nbsp;<strong>dcb</strong>abcd</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+abcd</span>
+<span style="font-size:18px"><strong>Output:</strong>
+3</span>
+<span style="font-size:18px"><strong>Explanation:
+</strong>Here we can append 3 characters in the 
+beginning,and the resultant string will 
+be a palindrome ("dcbabcd").</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+aba</span>
+<span style="font-size:18px"><strong>Output:</strong>
+0</span>
+<span style="font-size:18px"><strong>Explanation:</strong>
+Given string is already a pallindrome hence
+no insertions are required.</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 <strong>findMinInsertions()</strong>&nbsp;which takes string S<strong> </strong>as input parameters&nbsp;and returns minimimum numser of insertions required.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(|S|<sup>2</sup>)<br>
+<strong>Expected Auxiliary Space:</strong> O(|S|<sup>2</sup>)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ |S| ≤ 500</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Form a palindrome - GFG/form-a-palindrome.cpp b/Form a palindrome - GFG/form-a-palindrome.cpp
new file mode 100644
index 0000000..f06325d
--- /dev/null
+++ b/Form a palindrome - GFG/form-a-palindrome.cpp	
@@ -0,0 +1,50 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include<bits/stdc++.h> 
+using namespace std; 
+
+ // } Driver Code Ends
+//User function template for C++
+
+
+
+class Solution{   
+public:
+   int findMinInsertions(string s){
+       int n=s.length();
+       string p=s;
+       reverse(s.begin(),s.end());
+       int dp[n+1][n+1];
+       for(int i=0;i<=n;i++)
+       {
+           for(int j=0;j<=n;j++)
+           {
+               if(i==0||j==0)
+                   dp[i][j]=0;
+               else if(s[i-1]==p[j-1])
+                   dp[i][j]=1+dp[i-1][j-1];
+               else
+                   dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
+           }
+       }
+       return n-dp[n][n];
+   }
+};
+
+// { Driver Code Starts.
+
+
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        string S;
+        cin>>S;
+        Solution ob;
+        cout<<ob.findMinInsertions(S)<<endl;
+    }
+    return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Fraction Trouble - GFG/README.md b/Fraction Trouble - GFG/README.md
new file mode 100644
index 0000000..fb98851
--- /dev/null
+++ b/Fraction Trouble - GFG/README.md	
@@ -0,0 +1,32 @@
+# Fraction Trouble
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Consider the set of irreducible fractions A = {n/d | n≤d and d ≤ 10000 and gcd(n,d) = 1}.You are given a member of this set and your task is to find the largest fraction in this set less than the given fraction.<br>
+<strong>Note</strong>&nbsp;: this&nbsp;is a set and all the members are unique.</span><br>
+<br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong>: n = 1, d = 4
+<strong>Output:</strong>&nbsp;{2499, 9997}&nbsp; 
+<strong>Explanation</strong>: 2499/9997 is the largest fraction.
+</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 = 2, d = 4
+<strong>Output:&nbsp;</strong>{4999, 9999}
+<strong>Explanation</strong>: 4999/9999 is the largest fraction. 
+</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:&nbsp;&nbsp;</strong><br>
+You dont need to read input or print anything. Complete the function <strong>numAndDen()&nbsp;</strong>which takes n&nbsp;and d&nbsp;as input parameter and returns&nbsp;the numerator and the denominator of the required irreducible fraction.<br>
+<br>
+<strong>Expected Time Complexity:</strong> O(n)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)<br>
+<br>
+<strong>Constraints:</strong><br>
+1 &lt;= n&nbsp;&lt;= d&nbsp;&lt;=1000</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Fraction Trouble - GFG/fraction-trouble.cpp b/Fraction Trouble - GFG/fraction-trouble.cpp
new file mode 100644
index 0000000..849f04e
--- /dev/null
+++ b/Fraction Trouble - GFG/fraction-trouble.cpp	
@@ -0,0 +1,38 @@
+// { Driver Code Starts
+// Initial Template for C++
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+class Solution {
+  public:
+    vector<int> numAndDen(int n, int d) {
+       // code here
+           int numerator =-1, denominator =1;
+      for(int y=d+1; y<=10000; y++) {
+       int x = (n*y)/d;
+       if(__gcd(x,y) == 1) {
+           if(1.0*x/y > 1.0*numerator /denominator )
+               numerator =x, denominator =y;
+       }
+   }
+   return {numerator , denominator };
+   }
+};
+
+// { Driver Code Starts.
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int n,d;
+        cin >> n >> d;
+        Solution ob;
+        vector<int>ans=ob.numAndDen(n,d);
+        for(int i=0;i<ans.size();i++)cout<<ans[i]<<" ";
+        cout<<endl;
+    }
+    return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Gadgets of Doraland - GFG/README.md b/Gadgets of Doraland - GFG/README.md
new file mode 100644
index 0000000..c5c3ab2
--- /dev/null
+++ b/Gadgets of Doraland - GFG/README.md	
@@ -0,0 +1,41 @@
+# Gadgets of Doraland
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">In Doraland, people have unique Identity Numbers called <strong>D-id.</strong> Doraemon owns the most popular gadget shop in Doraland. Since his gadgets are in high demand and he has only <strong>K</strong> gadgets left he has decided to sell his gadgets to his most frequent customers only. <strong>N</strong> customers visit his shop and <strong>D-id</strong> of each customer is given in an array <strong>array[ ]</strong>.&nbsp;In case two or more people have visited his shop the same number of time he gives priority to the customer with higher <strong>D-id</strong>. Find the <strong>D-ids</strong> of people he sells his <strong>K</strong> gadgets to.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 6
+array[] = {1, 1, 1, 2, 2, 3}
+K = 2
+<strong>Output:</strong> 
+1 2
+<strong>Explanation: </strong>
+Customers with D-id 1 and 2 are most 
+frequent.</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
+array[] = {1, 1, 2, 2, 3, 3, 3, 4}
+K = 2
+<strong>Output:</strong> 
+3 2
+<strong>Explanation: </strong>People with D-id&nbsp;1 and 2 have 
+visited shop 2 times&nbsp;Therefore, in this 
+case, the answer includes the D-id&nbsp;2 as 2 &gt; 1.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Complete the function <strong>TopK() </strong>which takes <strong>array[ ]</strong> and integer <strong>K</strong>&nbsp;as input parameters and returns an array containing <strong>D-id</strong> of customers he has decided to sell his gadgets to.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N)<br>
+<strong>Expected Auxiliary Space:</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&nbsp;≤&nbsp;D-id ≤&nbsp;10<sup>4</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Gadgets of Doraland - GFG/gadgets-of-doraland.py b/Gadgets of Doraland - GFG/gadgets-of-doraland.py
new file mode 100644
index 0000000..c7e8cad
--- /dev/null
+++ b/Gadgets of Doraland - GFG/gadgets-of-doraland.py	
@@ -0,0 +1,38 @@
+#User function Template for python3
+
+class Solution:
+   def TopK(self, array, k):
+        # code here
+        d={}
+        x=[]
+        out=[]
+        for i in array:
+            if i in d:
+                d[i] += 1
+            else:
+                d[i] = 1
+        for i in d:
+            x.append([i,d[i]])
+        x.sort(reverse=True,key=lambda x:(x[1],x[0]))
+        for i in range(k):
+            out.append(x[i][0])
+        return out
+
+
+#{ 
+#  Driver Code Starts
+#Initial Template for Python 3
+
+if __name__ == '__main__':
+    t = int(input())
+    for _ in range(t):
+        n = int(input())
+        array = [int(x) for x in input().strip().split()]
+        k = int(input())
+        obj = Solution()
+        res = obj.TopK(array, k)
+        for each in res:
+            print(each, end=' ')
+        print()
+
+# } Driver Code Ends
\ No newline at end of file
diff --git a/Handshakes - GFG/README.md b/Handshakes - GFG/README.md
new file mode 100644
index 0000000..ca61dad
--- /dev/null
+++ b/Handshakes - GFG/README.md	
@@ -0,0 +1,51 @@
+# Handshakes
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">We have N&nbsp;persons sitting on a round table. Any person can do a handshake with any other person. </span></p>
+
+<p><span style="font-size:18px">&nbsp; &nbsp; &nbsp;1<br>
+2&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;3<br>
+&nbsp; &nbsp; &nbsp;4</span></p>
+
+<p><span style="font-size:18px">Handshake with 2-3 and 1-4 will cause cross.</span></p>
+
+<p><span style="font-size:18px">In how many ways these N&nbsp;people can make handshakes so that no two handshakes cross each other.&nbsp;N would be even.&nbsp; </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>
+N = 2
+<strong>Output:</strong>
+1
+<strong>Explanation:</strong>
+{1,2} handshake is
+possible.
+</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
+<strong>Output:</strong>
+2
+<strong>Explanation:</strong>
+{{1, 2}, {3, 4}} are the
+two handshakes possible.
+{{1, 3}, {2, 4}} is another
+set of handshakes possible.</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>count()</strong>&nbsp;which takes&nbsp;an integer <strong>N</strong>&nbsp;as input parameters&nbsp;and returns an integer, the total number of handshakes possible so that no two handshakes cross each other.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(2<sup>N</sup>)<br>
+<strong>Expected Space Complexity:</strong> O(1)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 30</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Handshakes - GFG/handshakes.cpp b/Handshakes - GFG/handshakes.cpp
new file mode 100644
index 0000000..a3f4ad4
--- /dev/null
+++ b/Handshakes - GFG/handshakes.cpp	
@@ -0,0 +1,31 @@
+// { Driver Code Starts
+#include<bits/stdc++.h> 
+using namespace std;
+
+ // } Driver Code Ends
+class Solution{
+public:
+      int count(int N){
+// code here
+int sum=0;
+if(N==2 || N==0)
+{
+return 1;
+}
+for(int i=0;i<N;i=i+2) { sum+=count(i)*count(N-2-i); }return sum; } 
+};
+
+// { Driver Code Starts.
+int main() 
+{ 
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int N;
+        cin>>N;
+        Solution ob;
+        cout << ob.count(N) << endl;
+    }
+    return 0; 
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Height Using Parent Array - GFG/README.md b/Height Using Parent Array - GFG/README.md
new file mode 100644
index 0000000..8f70657
--- /dev/null
+++ b/Height Using Parent Array - GFG/README.md	
@@ -0,0 +1,33 @@
+# Height Using Parent Array
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a parent array <strong>arr</strong>[] of a binary tree of <strong>N</strong> nodes. Element at index i in the array arr[] represents the parent of ith node, i.e,&nbsp;<strong>arr[i] = parent(i)</strong>. Find the height of this binary tree.</span><br>
+<span style="font-size:18px"><strong>Note:</strong> There will be a node in the array arr[], where <strong>arr[i] = -1</strong>, which means this node is the root of binary tree.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> N = 7
+arr = {-1, 0, 0, 1, 1, 3, 5}
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> Tree formed is:
+                    0
+                   / \
+                  1   2
+                 / \
+                3   4
+               /
+              5
+             /
+            6      Height of the tree= 5</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You do not need to read input or print anything. Your task is to complete the function <strong>findHeight()</strong> which takes N and arr[] as input parameters and returns the height of the given binary tree.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N*N)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>4</sup><br>
+0 ≤ arr[i] ≤ 10<sup>4</sup>&nbsp; &nbsp;</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Height Using Parent Array - GFG/height-using-parent-array.cpp b/Height Using Parent Array - GFG/height-using-parent-array.cpp
new file mode 100644
index 0000000..c5e25de
--- /dev/null
+++ b/Height Using Parent Array - GFG/height-using-parent-array.cpp	
@@ -0,0 +1,50 @@
+// { Driver Code Starts
+// Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+
+class Solution{
+public:
+    int findHeight(int N, int arr[]){
+        // code here
+        
+        int ans = 1;
+        
+        for(int i=0; i<N; i++)
+        {
+            int cnt = 1, cur = arr[i];
+            
+            while(cur >= 0)
+            {
+                cur = arr[cur];
+                cnt++;
+            }
+            
+            ans = max(ans, cnt);
+        }
+        
+        return ans;
+    }
+};
+
+// { Driver Code Starts.
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int N;
+        cin>>N;
+        int arr[N];
+        for(int i = 0;i < N;i++)
+            cin>>arr[i];
+        
+        Solution ob;
+        cout<<ob.findHeight(N, arr)<<"\n";
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Help Classmates - GFG/README.md b/Help Classmates - GFG/README.md
new file mode 100644
index 0000000..fb56b16
--- /dev/null
+++ b/Help Classmates - GFG/README.md	
@@ -0,0 +1,44 @@
+# Help Classmates
+## Medium 
+<div class="problem-statement">
+                <p><a onclick="gtagHelperFunction('clickopen','salesevent_gsc_problemspage_promobanner')" href="https://practice.geeksforgeeks.org/summer-carnival-2022?utm_source=practiceproblems&amp;utm_medium=problemspromobanner&amp;utm_campaign=gsc22" target="_blank"></a></p><div style="margin: 14px 0px !important;" class="row"><a onclick="gtagHelperFunction('clickopen','salesevent_gsc_problemspage_promobanner')" href="https://practice.geeksforgeeks.org/summer-carnival-2022?utm_source=practiceproblems&amp;utm_medium=problemspromobanner&amp;utm_campaign=gsc22" target="_blank">             <div class="col-md-12" style="cursor:pointer;background: #EFF8F3 0% 0% no-repeat padding-box; display: flex; align-items: center; position:                 relative; padding: 1.5%; border-radius: 10px; display: inline-block; text-align: center; font-weight: 600; color: #333"> <img src="https://media.geeksforgeeks.org/img-practice/gcs2022thumbnail-1649059370.png" alt="Lamp" width="46" height="40" style="background: transparent 0% 0% no-repeat padding-box;opacity: 1; margin: 0 16px;" class="img-responsive"> Geeks Summer Carnival is LIVE NOW &nbsp; <i class="fa fa-external-link" aria-hidden="true"></i> </div></a></div><p><span style="font-size:18px">Professor X wants his students to help each other in the chemistry lab. He suggests that every student should help out a classmate who scored less marks than him in chemistry and whose roll number appears after him. But the students are lazy and they don't want to search too far. They each pick the first roll number after them that fits the criteria. Find the marks of the classmate that each student picks.<br>
+<strong>Note:</strong> one student may be selected by multiple classmates.</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[] = {3, 8, 5, 2, 25}
+<strong>Output:</strong> 2 5 2 -1 -1
+<strong>Explanation:</strong> 
+1. Roll number 1 has 3 marks. The first person 
+who has less marks than him is roll number 4, 
+who has 2 marks.
+2. Roll number 2 has 8 marks, he helps student 
+with 5 marks.
+3. Roll number 3 has 5 marks, he helps student 
+with 2 marks.
+4. Roll number 4 and 5 can not pick anyone as 
+no student with higher roll number has lesser 
+marks than them. This is denoted by -1.
+Output shows the marks of the weaker student that 
+each roll number helps in order. ie- 2,5,2,-1,-1</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, a[] = {1, 2, 3, 4}
+<strong>Output:</strong> -1 -1 -1 -1&nbsp;
+<strong>Explanation:</strong> As the marks ars in increasing order. 
+None of the students can find a classmate who has 
+a higher roll number and less marks than them.
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task: </strong>&nbsp;<br>
+You don't need to read input or print anything. Complete the function <strong>help_classmate()</strong> which takes the array arr[] and&nbsp;size of array N as input parameters and returns a list of numbers. If a student is unable to find anyone then output is&nbsp;-1.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N)<br>
+<strong>Expected Auxiliary Space:</strong> O(N)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 5*10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Help Classmates - GFG/help-classmates.cpp b/Help Classmates - GFG/help-classmates.cpp
new file mode 100644
index 0000000..719a298
--- /dev/null
+++ b/Help Classmates - GFG/help-classmates.cpp	
@@ -0,0 +1,60 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h> 
+using namespace std; 
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution{
+    
+    public:
+    vector<int> help_classmate(vector<int> arr, int n) 
+    { 
+        // Your code goes here
+        stack<int> s;
+        vector<int> res(n,-1);
+        for(int i=n-1;i>=0;i--)
+        {
+            while(!s.empty() &&  arr[i] <= s.top())
+                s.pop();
+            
+            if(!s.empty())
+            {
+                res[i] = s.top();
+            }
+            s.push(arr[i]);
+        }
+        return res;
+    } 
+};
+
+// { Driver Code Starts.
+
+int main() 
+{ 
+	int t;
+	cin>>t;
+	while(t--)
+	{
+		int n;
+		cin>>n;
+		vector<int> array(n);
+		for (int i = 0; i < n; ++i)
+		{
+			cin>>array[i];
+		}
+		Solution obj;
+		vector<int> result = obj.help_classmate(array,n);
+		for (int i = 0; i < n; ++i)
+		{
+			cout<<result[i]<<" ";
+		}
+		cout<<"\n";
+	}
+	return 0; 
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Hit most Balloons - GFG/README.md b/Hit most Balloons - GFG/README.md
new file mode 100644
index 0000000..f614e53
--- /dev/null
+++ b/Hit most Balloons - GFG/README.md	
@@ -0,0 +1,42 @@
+# Hit most Balloons
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">You are given an infinite two-dimensional grid. There are <strong>N </strong>balloons placed at certain coordinates of the grid. You have an arrow with yourself, which you will be using to shoot the balloons. You can select any point on the grid as your starting point and any point on the grid as the target point. When you fire the arrow, all ballons lying on the shortest path between the starting point and target point will be burst. Given the coordinates of the N ballons&nbsp;in an array&nbsp;<strong>arr, </strong>your task is to find out the maximum number of balloons that you can fire in one arrow shot.</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
+arr[] = {{1, 2}, {2, 3}, {3, 4}}
+<strong>Output:</strong>
+3
+<strong>Explanation:</strong>
+If you position yourself at point (1,2)
+and fire the arrow aiming at the point (3,4).
+Then all the balloons will burst.</span></pre>
+
+<p><strong><span style="font-size:18px">Example</span> <span style="font-size:18px">2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>
+N = 3
+arr[] = {{2,2}, {0,0}, {1,2}}&nbsp;
+<strong>Output:</strong>
+2
+<strong>Explanation: </strong>
+If you position yourself at point (2,2)
+and fire the arrow aiming at the point (0,0).
+Then the two balloons present at the two points
+will burst.
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+Complete the function <strong>mostBalloons</strong><strong>()</strong> which takes the integers <strong>N </strong>and the array <strong>arr&nbsp;</strong>as the input parameters, and returns the maximum number of balloons that can be burst using one arrow.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N<sup>2</sup>)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(N)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1&nbsp;≤ N&nbsp;≤ 10<sup>3</sup></span><br>
+<span style="font-size:18px">-10<sup>9</sup> ≤ arr[i][j]&nbsp;≤ 10<sup>9</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Hit most Balloons - GFG/hit-most-balloons.cpp b/Hit most Balloons - GFG/hit-most-balloons.cpp
new file mode 100644
index 0000000..ba3cd82
--- /dev/null
+++ b/Hit most Balloons - GFG/hit-most-balloons.cpp	
@@ -0,0 +1,85 @@
+// { Driver Code Starts
+// Initial Template for C++
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+
+class Fraction {
+  public:
+    int num, den;
+    
+    Fraction(int _a, int _b) {
+        if(_a == 0 || _b == 0) {
+            num = !_a;
+            den = !_b;
+        } else {
+            bool isNeg = _a > 0 != _b > 0;
+            _a = abs(_a);
+            _b = abs(_b);
+            int g = __gcd(_a, _b);
+            num = _a / g;
+            den = _b / g;
+            if(isNeg) num = -num;
+        }
+    }
+    
+    bool operator<(const Fraction& other) const {
+        if(num == other.num) return den < other.den;
+        return num < other.num;
+    }
+};
+
+class Solution {
+  public:
+    int mostBalloons(int N, pair<int, int> arr[]) {
+        int ans = 0;
+        
+        // It's mandate to pop i'th balloon.
+        for(int i = 0; i < N; i++) {
+            int cur = 0, onSpot = 1;
+            map<Fraction, int> dp;
+            // Check max j'th balloons which can be popped.
+            for(int j = i + 1; j < N; j++) {
+                // Calculate slope beween i'th and j'th balloon.
+                // (y2 - y1) / (x2 - x1)
+                int num = arr[j].second - arr[i].second;
+                int den = arr[j].first - arr[i].first;
+                
+                if(!num && !den) {
+                    ++onSpot;
+                    continue;
+                } else {
+                    Fraction ft(num, den);
+                    cur = max(cur, ++dp[ft]);
+                }
+            }
+            
+            // include i'th balloon
+            ans = max(ans, cur + onSpot);
+        }
+        
+        return ans;
+    }
+};
+
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int N;
+        cin >> N;
+        pair<int, int> arr[N];
+        for (int i = 0; i < N; i++) {
+            cin >> arr[i].first;
+        }
+        for (int i = 0; i < N; i++) {
+            cin >> arr[i].second;
+        }
+        Solution ob;
+        cout << ob.mostBalloons(N, arr) << endl;
+    }
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Implement stack using array - GFG/README.md b/Implement stack using array - GFG/README.md
new file mode 100644
index 0000000..ca3dec8
--- /dev/null
+++ b/Implement stack using array - GFG/README.md	
@@ -0,0 +1,43 @@
+# Implement stack using array
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Write a program to implement a Stack&nbsp;using Array. Your task is to use the class as shown in the comments in the code editor&nbsp;and complete&nbsp;the functions push() and pop() to implement a stack.&nbsp;</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()
+push(4) 
+pop()
+<strong>Output</strong>: 3, 4
+<strong>Explanation</strong>: 
+push(2)    the stack will be {2}
+push(3)    the stack will be {2 3}
+pop()      poped element will be 3,
+&nbsp;          the stack will be {2}
+push(4)    the stack will be {2 4}
+pop()      poped element will be 4</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong>: 
+pop()
+push(4)
+push(5)
+pop()
+<strong>Output</strong>: -1, 5</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You are required to complete two methods&nbsp;<strong>push() and pop(). </strong>The push() method&nbsp;takes one argument, an integer <strong>'x'</strong>&nbsp;to be pushed into the stack and&nbsp;<strong>pop()</strong>&nbsp;which returns an integer present at the top and popped out from the stack. If the stack is empty then return <strong>-1</strong> from the pop() method.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity</strong> : O(1) for both&nbsp;<strong>push()&nbsp;</strong>and&nbsp;<strong>pop()</strong>.</span><br>
+<span style="font-size:18px"><strong>Expected Auixilliary Space </strong>: O(1) for both&nbsp;<strong>push()&nbsp;</strong>and&nbsp;<strong>pop()</strong>.</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= Q &lt;= 100<br>
+1 &lt;= x &lt;= 100</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Implement stack using array - GFG/implement-stack-using-array.cpp b/Implement stack using array - GFG/implement-stack-using-array.cpp
new file mode 100644
index 0000000..7f5e685
--- /dev/null
+++ b/Implement stack using array - GFG/implement-stack-using-array.cpp	
@@ -0,0 +1,68 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+class MyStack
+{
+private:
+    int arr[1000];
+    int top;
+public:
+    MyStack(){top=-1;}
+    int pop();
+    void push(int);
+};
+
+
+int main()
+{
+
+    int T;
+    cin>>T;
+    while(T--)
+    {
+        MyStack *sq = new MyStack();
+
+        int Q;
+        cin>>Q;
+        while(Q--){
+        int QueryType=0;
+        cin>>QueryType;
+        if(QueryType==1)
+        {
+            int a;
+            cin>>a;
+            sq->push(a);
+        }else if(QueryType==2){
+            cout<<sq->pop()<<" ";
+
+        }
+        }
+        cout<<endl;
+    }
+}
+// } Driver Code Ends
+
+
+
+//Function to push an integer into the stack.
+void MyStack :: push(int x)
+{
+    // Your Code
+    if(top == 999)
+    return ;
+    
+    top++;
+    arr[top] = x;
+    
+}
+
+//Function to remove an item from top of the stack.
+int MyStack :: pop()
+{
+    // Your Code   
+    if(top == -1)
+    return -1;
+    
+    return arr[top--];
+}
diff --git a/Implementing Dijkstra Algorithm - GFG/README.md b/Implementing Dijkstra Algorithm - GFG/README.md
new file mode 100644
index 0000000..5da3cc1
--- /dev/null
+++ b/Implementing Dijkstra Algorithm - GFG/README.md	
@@ -0,0 +1,58 @@
+# Implementing Dijkstra Algorithm
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a weighted, undirected and connected graph of V vertices and E edges, Find the shortest distance of all the vertex's from the source vertex S.</span><br>
+<span style="font-size:18px"><strong>Note: </strong>The Graph doesn't contain any negative weight cycle.</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></span>
+<img alt="" src="data:image/png;base64,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" class="img-responsive">
+<span style="font-size:18px"><strong>S </strong>= 0</span>
+<span style="font-size:18px"><strong>Output:</strong>
+0 9
+<strong>Explanation</strong>:</span>
+<span style="font-size:18px">The source vertex is 0. Hence, the shortest 
+distance of node 0 is 0 and the shortest 
+distance from node 9 is 9 - 0 = 9.</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></span>
+<img alt="" src="data:image/png;base64,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" class="img-responsive">
+<span style="font-size:18px"><strong>S </strong>= 2</span>
+<span style="font-size:18px"><strong>Output:</strong>
+4 3 0
+<strong>Explanation</strong>:</span>
+<span style="font-size:18px">For nodes 2 to 0, we can follow the path-
+2-1-0. This has a distance of 1+3 = 4,
+whereas the path 2-0 has a distance of 6. So,
+the Shortest path from 2 to 0 is 4.
+The other distances are pretty straight-forward.</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&nbsp;<strong>dijkstra()</strong>&nbsp;</span> <span style="font-size:18px">which takes number of vertices V<strong> </strong>and<strong>&nbsp;</strong>an adjacency list adj as input parameters&nbsp;and returns a list of integers, where ith integer denotes the shortest distance of the ith node from Source node. </span> <span style="font-size:18px">Here adj[i] contains a list of lists containing two integers where the first integer j denotes that there is an edge between i and j and second integer w denotes that the weight between edge i and j is w.</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(V<sup>2</sup>).<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(V<sup>2</sup>).</span></p>
+
+<p>&nbsp;</p>
+
+<div><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 </span> <span style="font-size:18px">≤</span> <span style="font-size:18px"> V </span> <span style="font-size:18px">≤</span> <span style="font-size:18px"> 1000<br>
+0 </span> <span style="font-size:18px">≤</span> <span style="font-size:18px"> adj[i][j] </span> <span style="font-size:18px">≤</span> <span style="font-size:18px"> 1000</span></div>
+
+<div><span style="font-size:18px">1 ≤&nbsp;adj.size()&nbsp;≤ [ (V*(V - 1)) / 2 ]<br>
+0 </span> <span style="font-size:18px">≤</span> <span style="font-size:18px"> S &lt; V</span></div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Implementing Dijkstra Algorithm - GFG/implementing-dijkstra-algorithm.cpp b/Implementing Dijkstra Algorithm - GFG/implementing-dijkstra-algorithm.cpp
new file mode 100644
index 0000000..f9a7644
--- /dev/null
+++ b/Implementing Dijkstra Algorithm - GFG/implementing-dijkstra-algorithm.cpp	
@@ -0,0 +1,76 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution
+{
+	public:
+	//Function to find the shortest distance of all the vertices
+    //from the source vertex S.
+  vector <int> dijkstra(int V, vector<vector<int>> adj[], int S)
+    {
+        // Code here
+        vector<int>dist(V,INT_MAX);
+        priority_queue<pair<int,int>>pq;
+        pq.push({0,S});
+        dist[S]=0;
+        while(!pq.empty())
+        {
+            pair<int,int>p=pq.top();
+            int a=p.second;
+            pq.pop();
+            for(int i=0;i<adj[a].size();i++)
+            {
+                int res=adj[a][i][0];
+                int w=adj[a][i][1];
+                if(w+dist[a]<dist[res])
+                {
+                    dist[res]=dist[a]+w;
+                    pq.push({-1*dist[res],res});
+                }
+            }
+        }
+        return dist;
+    }
+};
+
+
+// { Driver Code Starts.
+
+
+int main()
+{
+    int t;
+    cin >> t;
+    while (t--) {
+        int V, E;
+        cin >> V >> E;
+        vector<vector<int>> adj[V];
+        int i=0;
+        while (i++<E) {
+            int u, v, w;
+            cin >> u >> v >> w;
+            vector<int> t1,t2;
+            t1.push_back(v);
+            t1.push_back(w);
+            adj[u].push_back(t1);
+            t2.push_back(u);
+            t2.push_back(w);
+            adj[v].push_back(t2);
+        }
+        int S;
+        cin>>S;
+        
+        Solution obj;
+    	vector<int> res = obj.dijkstra(V, adj, S);
+    	
+    	for(int i=0; i<V; i++)
+    	    cout<<res[i]<<" ";
+    	cout<<endl;
+    }
+
+    return 0;
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Insertion Sort for Singly Linked List - GFG/README.md b/Insertion Sort for Singly Linked List - GFG/README.md
new file mode 100644
index 0000000..bfd9df0
--- /dev/null
+++ b/Insertion Sort for Singly Linked List - GFG/README.md	
@@ -0,0 +1,41 @@
+# Insertion Sort for Singly Linked List
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a singly linked list, sort the list (in ascending order) using insertion sort algorithm.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N<strong> </strong>= 10
+Linked List = 30-&gt;23-&gt;28-&gt;30-&gt;11-&gt;14-&gt;
+&nbsp;             19-&gt;16-&gt;21-&gt;25 
+<strong>Output : </strong>11 14 16 19 21 23 25 28 30 30<strong> </strong>
+<strong>Explanation :</strong>
+The resultant linked list is sorted.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input : </strong>
+N = 7
+Linked List=19-&gt;20-&gt;16-&gt;24-&gt;12-&gt;29-&gt;30 
+<strong>Output : </strong>12 16 19 20 24 29 30 
+<strong>Explanation : </strong>
+The resultant linked list is sorted.</span></pre>
+
+<div><span style="font-size:18px"><strong>Your task:</strong></span></div>
+
+<div><span style="font-size:18px">You don't need to read input or print anything. Your task is to complete the function&nbsp;<strong>insertionSort()</strong> which takes the head of the linked list, sorts the list using insertion sort algorithm and returns the head of the sorted linked list.</span></div>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Expected Time Complexity :</strong> O(n<sup>2</sup>)</span></div>
+
+<div><span style="font-size:18px"><strong>Expected Auxiliary Space :</strong> O(1)</span></div>
+
+<div>&nbsp;</div>
+
+<div><strong><span style="font-size:18px">Constraints:</span></strong></div>
+
+<div><span style="font-size:18px">1&lt;=n&lt;=10^5</span></div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Insertion Sort for Singly Linked List - GFG/insertion-sort-for-singly-linked-list.cpp b/Insertion Sort for Singly Linked List - GFG/insertion-sort-for-singly-linked-list.cpp
new file mode 100644
index 0000000..3895d1a
--- /dev/null
+++ b/Insertion Sort for Singly Linked List - GFG/insertion-sort-for-singly-linked-list.cpp	
@@ -0,0 +1,105 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include<bits/stdc++.h>
+using namespace std;
+
+/* Link list node */
+struct Node {
+	int data;
+	struct Node *next;
+	Node(int x) {
+		data = x;
+		next = NULL;
+	}
+};
+
+/* Function to print linked list */
+void printList(struct Node *head)
+{
+	struct Node *temp = head;
+	while (temp != NULL)
+	{
+		printf("%d ", temp->data);
+		temp = temp->next;
+	}
+}
+
+
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+/*Link list node
+struct Node {
+	int data;
+	struct Node *next;
+	Node(int x) {
+		data = x;
+		next = NULL;
+	}
+};*/
+
+class Solution
+{
+    public:
+    Node* insertionSort(struct Node* head)
+    {
+         Node *ans=new Node(0);
+         Node *h=head;
+         while(h!=NULL)
+         {
+            Node *curr=ans;Node *prev=NULL;
+            while(curr!=NULL&&(curr->data)<(h->data))
+            {
+                prev=curr;
+                curr=curr->next;
+            }
+            Node *hnext=h->next;
+            Node *temp=curr;prev->next=h;h->next=temp;
+            h=hnext;
+         }
+         return ans->next;
+    }
+    
+};
+
+// { Driver Code Starts.
+int main()
+{
+	int T;
+	cin >> T;
+
+	while (T--)
+	{
+		int n;
+		cin >> n;
+
+		Node *head = NULL;
+		Node *temp = head;
+
+		for (int i = 0; i < n; i++) {
+			int data;
+			cin >> data;
+			if (head == NULL)
+				head = temp = new Node(data);
+			else
+			{
+				temp->next = new Node(data);
+				temp = temp->next;
+			}
+		}
+
+        Solution ob;
+
+		head = ob.insertionSort(head);
+		printList(head);
+
+		cout << "\n";
+
+
+
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/K-th element of two sorted Arrays - GFG/README.md b/K-th element of two sorted Arrays - GFG/README.md
new file mode 100644
index 0000000..7307caf
--- /dev/null
+++ b/K-th element of two sorted Arrays - GFG/README.md	
@@ -0,0 +1,48 @@
+# K-th element of two sorted Arrays
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given two sorted arrays <strong>arr1</strong> and <strong>arr2</strong> of size <strong>N</strong>&nbsp;and <strong>M</strong>&nbsp;respectively and an element <strong>K</strong>. The task is to find the element that would be at the k’th position of the final sorted array.</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>
+arr1[] = {2, 3, 6, 7, 9}
+arr2[] = {1, 4, 8, 10}
+k = 5
+<strong>Output:</strong>
+6
+<strong>Explanation:</strong>
+The final sorted array would be -
+1, 2, 3, 4, 6, 7, 8, 9, 10
+The 5th element of this array is 6.
+</span></pre>
+
+<div><span style="font-size:18px"><strong>Example 2:</strong></span></div>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+arr1[] = {100, 112, 256, 349, 770}
+arr2[] = {72, 86, 113, 119, 265, 445, 892}
+k = 7
+<strong>Output:</strong>
+256
+<strong>Explanation:</strong>
+Final sorted array is - 72, 86, 100, 112,
+113, 119, 256, 265, 349, 445, 770, 892
+7th element of this array is 256.</span></pre>
+
+<p><br>
+<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>kthElement()</strong>&nbsp;which takes the arrays <strong>arr1[]</strong>,&nbsp;<strong>arr2[]</strong>, its size <strong>N </strong>and <strong>M </strong>respectively and an integer <strong>K </strong>as inputs and returns the element at the Kth position.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(Log(N) + Log(M))<br>
+<strong>Expected Auxiliary Space:</strong> O(Log (N))</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N, M &lt;= 10<sup>6</sup><br>
+1 &lt;= arr1<sub>i</sub>, arr2<sub>i</sub> &lt;&nbsp;INT_MAX<br>
+1 &lt;= K &lt;= N+M</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/K-th element of two sorted Arrays - GFG/kth-element-of-two-sorted-arrays.cpp b/K-th element of two sorted Arrays - GFG/kth-element-of-two-sorted-arrays.cpp
new file mode 100644
index 0000000..aa469aa
--- /dev/null
+++ b/K-th element of two sorted Arrays - GFG/kth-element-of-two-sorted-arrays.cpp	
@@ -0,0 +1,69 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+class Solution{
+    public:
+    int kthElement(int arr1[], int arr2[], int n, int m, int k)
+    {
+        if(n>m)
+        {
+            return kthElement(arr2,arr1,m,n,k);
+        }
+        
+        int low = max(0,k-m), high = min(k,n);
+        
+        while(low<=high)
+        {
+            int cut1 = (low+high)/2;
+            int cut2 = k - cut1;
+       
+            int l1 = cut1 == 0 ? INT_MIN : arr1[cut1-1];
+            int l2 = cut2 == 0 ? INT_MIN : arr2[cut2-1];
+            
+            int r1 = cut1 == n ? INT_MAX : arr1[cut1];
+            int r2 = cut2 == m ? INT_MAX : arr2[cut2];
+            
+       //    cout<<"l1 -> "<<l1<<" l2 -> "<<l2<<" r1 -> "<<r1<<" r2 -> "<<r2<<endl;
+            if(l1<=r2  && l2<=r1)
+            {
+                return max(l2,l1);
+            }
+            else if(l1>r2)
+            {
+                 high = cut1-1;
+            }
+            else if(l2>r1)
+            {
+               low = cut1+1;
+            }
+      
+            
+        }
+        return 1;
+   }
+};
+
+// { Driver Code Starts.
+ 
+// Driver code
+int main()
+{
+	int t;
+	cin>>t;
+	while(t--){
+		int n,m,k;
+		cin>>n>>m>>k;
+		int arr1[n],arr2[m];
+		for(int i=0;i<n;i++)
+			cin>>arr1[i];
+		for(int i=0;i<m;i++)
+			cin>>arr2[i];
+		
+		Solution ob;
+        cout << ob.kthElement(arr1, arr2, n, m, k)<<endl;
+	}
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Kadane's Algorithm - GFG/README.md b/Kadane's Algorithm - GFG/README.md
new file mode 100644
index 0000000..8b58152
--- /dev/null
+++ b/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/Kadane's Algorithm - GFG/kadanes-algorithm.cpp b/Kadane's Algorithm - GFG/kadanes-algorithm.cpp
new file mode 100644
index 0000000..e90ffec
--- /dev/null
+++ b/Kadane's Algorithm - GFG/kadanes-algorithm.cpp	
@@ -0,0 +1,56 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+class Solution{
+    public:
+    // arr: input array
+    // n: size of array
+    //Function to find the sum of contiguous subarray with maximum sum.
+    long long maxSubarraySum(int arr[], int n){
+        
+        // Your code here
+       int max_so_far = INT_MIN;
+       int max_till_here = 0;
+       
+       for(int i=0;i<n;i++)
+       {
+           max_till_here = max_till_here + arr[i];
+           
+           if(max_till_here > max_so_far)
+           {
+               max_so_far = max_till_here;
+           }
+           
+           if(max_till_here <  0)
+           max_till_here = 0;
+       }
+       return max_so_far;
+    }
+};
+
+// { Driver Code Starts.
+
+int main()
+{
+    int t,n;
+    
+    cin>>t; //input testcases
+    while(t--) //while testcases exist
+    {
+        
+        cin>>n; //input size of array
+        
+        int a[n];
+        
+        for(int i=0;i<n;i++)
+            cin>>a[i]; //inputting elements of array
+            
+        Solution ob;
+        
+        cout << ob.maxSubarraySum(a, n) << endl;
+    }
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Kth smallest element - GFG/README.md b/Kth smallest element - GFG/README.md
new file mode 100644
index 0000000..4616178
--- /dev/null
+++ b/Kth smallest element - GFG/README.md	
@@ -0,0 +1,46 @@
+# Kth smallest element
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array <strong>arr[]</strong> and an integer&nbsp;<strong>K</strong> where K is smaller than size of array, the task is to find the <strong>K<sup>th</sup> smallest</strong> element in the given array. It is given that all array elements are distinct.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong></span>
+<span style="font-size:18px">N = 6
+arr[] = 7 10 4 3 20 15
+K = 3</span>
+<span style="font-size:18px"><strong>Output :</strong> 7</span>
+<strong><span style="font-size:18px">Explanation :</span></strong>
+<span style="font-size:18px">3rd smallest element in the given 
+array is 7.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong></span>
+<span style="font-size:18px">N = 5
+arr[] = 7 10 4 20 15
+K = 4</span>
+<span style="font-size:18px"><strong>Output :</strong> 15</span>
+<strong><span style="font-size:18px">Explanation :</span></strong>
+<span style="font-size:18px">4th smallest element in the given 
+array is 15.</span></pre>
+
+<div><span style="font-size:18px"><strong>Your&nbsp;Task:</strong><br>
+You don't have to read input or print anything. Your task is to complete the function&nbsp;<strong>kthSmallest() </strong>which takes the array <strong>arr[]</strong>, integers&nbsp;<strong>l</strong>&nbsp;and&nbsp;<strong>r</strong>&nbsp;denoting the <strong>starting</strong> and <strong>ending</strong> index of the array&nbsp;and an integer <strong>K</strong>&nbsp;as input<strong>&nbsp;</strong>and returns the <strong>K<sup>th</sup></strong> smallest element. </span></div>
+
+<div>&nbsp;</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(1)</span></div>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 10<sup>5</sup><br>
+1 &lt;= arr[i] &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/Kth smallest element - GFG/kth-smallest-element.cpp b/Kth smallest element - GFG/kth-smallest-element.cpp
new file mode 100644
index 0000000..56fdd85
--- /dev/null
+++ b/Kth smallest element - GFG/kth-smallest-element.cpp	
@@ -0,0 +1,45 @@
+// { Driver Code Starts
+//Initial function template for C++
+
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function template for C++
+
+class Solution{
+    public:
+    // arr : given array
+    // l : starting index of the array i.e 0
+    // r : ending index of the array i.e size-1
+    // k : find kth smallest element and return using this function
+    int kthSmallest(int arr[], int l, int r, int k) {
+       
+       sort(arr+l,arr+r+1);
+       return arr[l+k-1];
+       
+    }
+};
+
+// { Driver Code Starts.
+ 
+int main()
+{
+    int test_case;
+    cin>>test_case;
+    while(test_case--)
+    {
+        int number_of_elements;
+        cin>>number_of_elements;
+        int a[number_of_elements];
+        
+        for(int i=0;i<number_of_elements;i++)
+            cin>>a[i];
+            
+        int k;
+        cin>>k;
+        Solution ob;
+        cout<<ob.kthSmallest(a, 0, number_of_elements-1, k)<<endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Largest subarray with 0 sum - GFG/README.md b/Largest subarray with 0 sum - GFG/README.md
new file mode 100644
index 0000000..37854a3
--- /dev/null
+++ b/Largest subarray with 0 sum - GFG/README.md	
@@ -0,0 +1,25 @@
+# Largest subarray with 0 sum
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array having both positive and negative integers. The task is to compute the&nbsp;length of the largest subarray with sum 0.</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
+A[] = {15,-2,2,-8,1,7,10,23}
+<strong>Output: </strong>5<strong>
+Explanation: </strong>The largest subarray with
+sum 0 will be&nbsp;-2 2 -8 1 7.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You just have to complete the function <strong>maxLen() </strong>which<strong>&nbsp;</strong>takes two arguments an array<strong> A</strong> and<strong> n,</strong> where n is the size of the array A and&nbsp;returns&nbsp;the length of the largest&nbsp;subarray with 0 sum.</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;= N &lt;= 10<sup>5</sup><br>
+-1000 &lt;= A[i] &lt;= 1000, for each valid i</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Largest subarray with 0 sum - GFG/largest-subarray-with-0-sum.cpp b/Largest subarray with 0 sum - GFG/largest-subarray-with-0-sum.cpp
new file mode 100644
index 0000000..0040df6
--- /dev/null
+++ b/Largest subarray with 0 sum - GFG/largest-subarray-with-0-sum.cpp	
@@ -0,0 +1,56 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+/*You are required to complete this function*/
+
+class Solution{
+    public:
+    int maxLen(vector<int>&A, int n)
+    {   
+        // Your code here
+        unordered_map<int,int> m;
+        int sum = 0;
+        int maxlen = 0;
+        m[0] = -1;
+        for(int i=0;i<n;i++)
+        {
+            sum += A[i];
+            if(m.find(sum) != m.end())
+            {
+                maxlen = max(maxlen,i-m[sum]);
+            }
+            else
+                m[sum] = i;
+        }
+        return maxlen;
+    }
+};
+
+
+// { Driver Code Starts.
+
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int m;
+        cin>>m;
+        vector<int> array1(m);
+        for (int i = 0; i < m; ++i){
+            cin>>array1[i];
+        }
+        Solution ob;
+        cout<<ob.maxLen(array1,m)<<endl;
+    }
+    return 0; 
+}
+
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Largest value in each level - GFG/README.md b/Largest value in each level - GFG/README.md
new file mode 100644
index 0000000..baa39d3
--- /dev/null
+++ b/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/Largest value in each level - GFG/largest-value-in-each-level.cpp b/Largest value in each level - GFG/largest-value-in-each-level.cpp
new file mode 100644
index 0000000..651411a
--- /dev/null
+++ b/Largest value in each level - GFG/largest-value-in-each-level.cpp	
@@ -0,0 +1,142 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// Tree Node
+struct Node
+{
+    int data;
+    Node* left;
+    Node* right;
+};
+
+// Utility function to create a new Tree Node
+Node* newNode(int val)
+{
+    Node* temp = new Node;
+    temp->data = val;
+    temp->left = NULL;
+    temp->right = NULL;
+
+    return temp;
+}
+
+// Function to Build Tree
+Node* buildTree(string str)
+{
+    // Corner Case
+    if (str.length() == 0 || str[0] == 'N')
+        return NULL;
+
+    // Creating vector of strings from input
+    // string after spliting by space
+    vector<string> ip;
+
+    istringstream iss(str);
+    for (string str; iss >> str; )
+        ip.push_back(str);
+
+    // Create the root of the tree
+    Node* root = newNode(stoi(ip[0]));
+
+    // Push the root to the queue
+    queue<Node*> queue;
+    queue.push(root);
+
+    // Starting from the second element
+    int i = 1;
+    while (!queue.empty() && i < ip.size()) {
+
+        // Get and remove the front of the queue
+        Node* currNode = queue.front();
+        queue.pop();
+
+        // Get the current node's value from the string
+        string currVal = ip[i];
+
+        // If the left child is not null
+        if (currVal != "N") {
+
+            // Create the left child for the current node
+            currNode->left = newNode(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->left);
+        }
+
+        // For the right child
+        i++;
+        if (i >= ip.size())
+            break;
+        currVal = ip[i];
+
+        // If the right child is not null
+        if (currVal != "N") {
+
+            // Create the right child for the current node
+            currNode->right = newNode(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->right);
+        }
+        i++;
+    }
+
+    return root;
+}
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution
+{
+    public:
+    vector<int> largestValues(Node* root)
+    {
+        //code here
+        vector<int> res;
+        queue<Node*> q;
+        q.push(root);
+        while(!q.empty()){
+            int sz=q.size(),mx=0;
+            while(sz--){
+            auto x=q.front();
+            q.pop();
+            mx=max(mx,x->data);
+            if(x->left)q.push(x->left);
+            if(x->right)q.push(x->right);
+            }
+            res.push_back(mx);
+        }
+        return res;
+    }
+};
+
+// { Driver Code Starts.
+int main()
+{
+
+    int t;
+    cin >> t;
+    getchar();
+    while (t--)
+    {
+
+        string inp;
+        getline(cin, inp);
+
+        struct Node* root = buildTree(inp);
+        Solution ob;
+        vector<int> ans = ob.largestValues(root);
+
+        for (int i = 0; i < ans.size(); i++)
+            cout << ans[i] << " ";
+
+        cout << "\n";
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Leaves to DLL - GFG/README.md b/Leaves to DLL - GFG/README.md
new file mode 100644
index 0000000..9355539
--- /dev/null
+++ b/Leaves to DLL - GFG/README.md	
@@ -0,0 +1,61 @@
+# Leaves to DLL
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a Binary Tree of size N, extract all its leaf nodes to form a Doubly Link List starting from the left most leaf. Modify the original tree to make the DLL thus removing the leaf nodes from the tree. Consider the left and right pointers of the tree to be the previous and next pointer of the DLL respectively.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input :</strong>
+        1
+      /   \
+     2     3
+    / \   / \
+   4   5 6   7    </span>
+
+<span style="font-size:18px"><strong>Output: </strong>
+Modified Tree :
+        1
+      /   \
+     2     3</span>
+
+<span style="font-size:18px">Doubly Link List :
+4 &lt;-&gt; 5 &lt;-&gt; 6 &lt;-&gt; 7</span>
+
+<span style="font-size:18px"><strong>Explanation:</strong>
+The leaf nodes are modified to form the DLL 
+in-place. Thus their links are removed from 
+the tree.</span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input :</strong>
+        1
+      /   \
+     2     3
+    / \   
+   4   5 </span>
+
+<span style="font-size:18px"><strong>Output: </strong>
+Modified Tree :
+        1
+      /   
+     2    </span>
+
+<span style="font-size:18px">Doubly Link List :
+4 &lt;-&gt; 5 &lt;-&gt; 3</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>convertToDLL()</strong> which takes root of the given tree as input parameter and returns the head of the doubly link list.</span></p>
+
+<p><span style="font-size:18px"><strong>Note:</strong><br>
+The generated output will contain the inorder traversal of the modified tree, the DLL from left to right and the DLL from right to left.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N)<br>
+<strong>Expected Auxiliary Space:</strong> O(height of tree)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10^4</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Leaves to DLL - GFG/leaves-to-dll.cpp b/Leaves to DLL - GFG/leaves-to-dll.cpp
new file mode 100644
index 0000000..c68b9bc
--- /dev/null
+++ b/Leaves to DLL - GFG/leaves-to-dll.cpp	
@@ -0,0 +1,169 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+// Tree Node
+struct Node {
+    int data;
+    Node *left;
+    Node *right;
+
+    Node(int val) {
+        data = val;
+        left = right = NULL;
+    }
+};
+
+// Function to Build Tree
+Node *buildTree(string str) {
+    // Corner Case
+    if (str.length() == 0 || str[0] == 'N') return NULL;
+
+    // Creating vector of strings from input
+    // string after spliting by space
+    vector<string> ip;
+
+    istringstream iss(str);
+    for (string str; iss >> str;) ip.push_back(str);
+
+    // Create the root of the tree
+    Node *root = new Node(stoi(ip[0]));
+
+    // Push the root to the queue
+    queue<Node *> queue;
+    queue.push(root);
+
+    // Starting from the second element
+    int i = 1;
+    while (!queue.empty() && i < ip.size()) {
+
+        // Get and remove the front of the queue
+        Node *currNode = queue.front();
+        queue.pop();
+
+        // Get the current Node's value from the string
+        string currVal = ip[i];
+
+        // If the left child is not null
+        if (currVal != "N") {
+
+            // Create the left child for the current Node
+            currNode->left = new Node(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->left);
+        }
+
+        // For the right child
+        i++;
+        if (i >= ip.size()) break;
+        currVal = ip[i];
+
+        // If the right child is not null
+        if (currVal != "N") {
+
+            // Create the right child for the current Node
+            currNode->right = new Node(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->right);
+        }
+        i++;
+    }
+
+    return root;
+}
+
+void inOrder(Node *root) {
+    if (!root) return;
+    inOrder(root->left);
+    cout << root->data << " ";
+    inOrder(root->right);
+}
+
+
+ // } Driver Code Ends
+/*Complete the function below
+Node is as follows:
+struct Node{
+    int data;
+    Node *left,*right;
+
+    Node(int x){
+        data = x;
+        left = NULL;
+        right = NULL;
+    }
+};
+*/
+// return the head of the DLL and remove those node from the tree as well.
+Node*temp;
+Node*head;
+Node* preorder(Node*root)
+{
+   if(root==NULL)return root;
+   
+   if(root->left==NULL && root->right==NULL)
+   {
+       if(temp==NULL)
+       {
+           head=root;
+           temp=root;
+       }
+       else
+       {
+        temp->right=root;
+        root->left=temp;
+        temp=root;
+       }
+        return NULL;
+   }
+   
+   root->left=preorder(root->left);
+   root->right=preorder(root->right);
+   return root;
+   
+}
+Node * convertToDLL(Node *root)
+{
+  
+  temp=NULL;
+  head=NULL;
+  preorder(root);
+  return head;
+  
+  
+  
+  
+}
+
+// { Driver Code Starts.
+
+int main() {
+    int tc;
+    scanf("%d ", &tc);
+    while (tc--) {
+        string treeString;
+        getline(cin, treeString);
+        Node* root = buildTree(treeString);
+        Node* head = convertToDLL(root);
+        inOrder(root);
+        cout << "\n";
+        Node *curr = head, *last = head;
+        while (curr) {
+            cout << curr->data << " ";
+            last = curr;
+            curr = curr->right;
+        }
+        cout << "\n";
+        curr = last;
+        while (curr) {
+            cout << curr->data << " ";
+            curr = curr->left;
+        }
+        cout << "\n";
+    }
+    return 0;
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Left View of Binary Tree - GFG/README.md b/Left View of Binary Tree - GFG/README.md
new file mode 100644
index 0000000..d4fb5ae
--- /dev/null
+++ b/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/Left View of Binary Tree - GFG/left-view-of-binary-tree.cpp b/Left View of Binary Tree - GFG/left-view-of-binary-tree.cpp
new file mode 100644
index 0000000..94308b2
--- /dev/null
+++ b/Left View of Binary Tree - GFG/left-view-of-binary-tree.cpp	
@@ -0,0 +1,148 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+// Tree Node
+struct Node
+{
+    int data;
+    Node* left;
+    Node* right;
+};
+
+vector<int> leftView(struct Node *root);
+
+// Utility function to create a new Tree Node
+Node* newNode(int val)
+{
+    Node* temp = new Node;
+    temp->data = val;
+    temp->left = NULL;
+    temp->right = NULL;
+
+    return temp;
+}
+
+
+// Function to Build Tree
+Node* buildTree(string str)
+{
+    // Corner Case
+    if(str.length() == 0 || str[0] == 'N')
+        return NULL;
+
+    // Creating vector of strings from input
+    // string after spliting by space
+    vector<string> ip;
+
+    istringstream iss(str);
+    for(string str; iss >> str; )
+        ip.push_back(str);
+
+    // for(string i:ip)
+    //     cout<<i<<" ";
+    // cout<<endl;
+    // Create the root of the tree
+    Node* root = newNode(stoi(ip[0]));
+
+    // Push the root to the queue
+    queue<Node*> queue;
+    queue.push(root);
+
+    // Starting from the second element
+    int i = 1;
+    while(!queue.empty() && i < ip.size()) {
+
+        // Get and remove the front of the queue
+        Node* currNode = queue.front();
+        queue.pop();
+
+        // Get the current node's value from the string
+        string currVal = ip[i];
+
+        // If the left child is not null
+        if(currVal != "N") {
+
+            // Create the left child for the current node
+            currNode->left = newNode(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->left);
+        }
+
+        // For the right child
+        i++;
+        if(i >= ip.size())
+            break;
+        currVal = ip[i];
+
+        // If the right child is not null
+        if(currVal != "N") {
+
+            // Create the right child for the current node
+            currNode->right = newNode(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->right);
+        }
+        i++;
+    }
+
+    return root;
+}
+
+
+int main() {
+    int t;
+    scanf("%d ",&t);
+    while(t--)
+    {
+        string s;
+        getline(cin,s);
+        Node* root = buildTree(s);
+        vector<int> vec = leftView(root);
+        for(int x : vec)
+        cout<<x<<" ";
+        cout << endl;
+    }
+    return 0;
+}
+
+// } Driver Code Ends
+
+
+/* A binary tree node
+
+struct Node
+{
+    int data;
+    struct Node* left;
+    struct Node* right;
+    
+    Node(int x){
+        data = x;
+        left = right = NULL;
+    }
+};
+ */
+
+//Function to return a list containing elements of left view of the binary tree.
+
+ void recur(Node * root,vector<int>& ans,int level)
+    {
+        if(root == NULL)return ;
+        
+        if(ans.size()<level)ans.push_back(root->data);
+         recur(root->left,ans,level+1);
+        recur(root->right,ans,level+1);
+       
+    }
+    
+vector<int> leftView(Node *root)
+{
+   // Your code here
+        vector<int> ans;
+        
+        recur(root,ans,1);
+        return ans;
+}
diff --git a/Longest Common Prefix in an Array - GFG/README.md b/Longest Common Prefix in an Array - GFG/README.md
new file mode 100644
index 0000000..27129ba
--- /dev/null
+++ b/Longest Common Prefix in an Array - GFG/README.md	
@@ -0,0 +1,41 @@
+# Longest Common Prefix in an Array
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a array of <strong>N</strong> strings, find the longest common prefix among all strings present in the array.</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 = 4
+arr[] = {geeksforgeeks, geeks, geek,
+&nbsp;        geezer}
+<strong>Output:</strong> gee
+<strong>Explanation</strong>: "gee" is the longest common
+prefix in all the given strings.</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
+arr[] = {hello, world}
+<strong>Output:</strong> -1
+<strong>Explanation</strong>: There's no common prefix
+in the given strings.</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>longestCommonPrefix()&nbsp;</strong>which takes the string array <strong>arr</strong>[] and its size <strong>N</strong> as inputs and <strong>returns</strong> the longest common prefix common in all the strings in the array. If there's no prefix common in all the strings, return "-1".</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(N*max(|arr<sub>i</sub>|)).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(max(|arr<sub>i</sub>|)) for result.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>3</sup><br>
+1 ≤ |arr<sub>i</sub>| ≤ 10<sup>3</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Longest Common Prefix in an Array - GFG/longest-common-prefix-in-an-array.cpp b/Longest Common Prefix in an Array - GFG/longest-common-prefix-in-an-array.cpp
new file mode 100644
index 0000000..9f6bf21
--- /dev/null
+++ b/Longest Common Prefix in an Array - GFG/longest-common-prefix-in-an-array.cpp	
@@ -0,0 +1,56 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function template for C++
+
+class Solution{
+ public:
+   
+   string longestCommonPrefix (string arr[], int N)
+   {
+       int mi=INT_MAX;
+       string first=arr[0];//store the first string
+       for(int i=1;i<N;i++)//start iterating from 1st index
+       {
+           int j=0;//for iterating on first string 
+           int k=0;//for iteration on current string
+           int length=0;//minumum length of common prefix
+           while(j<first.size() and k<arr[i].size())
+           {
+               if(first[j]==arr[i][k])
+                  length++;
+               else
+                  break;
+               j++;
+               k++;
+           }
+           mi=min(mi,length);
+       }
+       if(mi==0)
+          return "-1";
+       return first.substr(0,mi);
+   }
+};
+
+// { Driver Code Starts.
+int main()
+{
+    int t; cin >> t;
+    while (t--)
+    {
+        int n; cin >> n;
+        string arr[n];
+        for (int i = 0; i < n; ++i)
+            cin >> arr[i];
+        
+        Solution ob;
+        cout << ob.longestCommonPrefix (arr, n) << endl;
+    }
+}
+
+// Contributed By: Pranay Bansal
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Longest substring to form a Palindrome - GFG/README.md b/Longest substring to form a Palindrome - GFG/README.md
new file mode 100644
index 0000000..840427f
--- /dev/null
+++ b/Longest substring to form a Palindrome - GFG/README.md	
@@ -0,0 +1,44 @@
+# Longest substring to form a Palindrome
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a string <strong>S </strong>which only contains lowercase alphabets. Find the length of the longest substring of <strong>S</strong> such that the characters in it can be rearranged to form a <a href="https://www.geeksforgeeks.org/c-program-check-given-string-palindrome/" target="_blank">palindrome</a>. </span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>S = "aabe"
+<strong>Output:
+</strong>3
+<strong>Explanation:</strong>
+The substring "aab" can be rearranged to
+"aba" which is the longest palindrome
+possible for this String.</span>
+</pre>
+
+<div><span style="font-size:18px"><strong>Example 2:</strong></span></div>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>S = "adbabd"
+<strong>Output:</strong>
+6</span>
+<span style="font-size:18px"><strong>Explanation:</strong>
+The whole string “adbabd” can be
+rearranged to form a palindromic substring.
+One possible arrangement is "abddba".
+Thus, output length of the string is 6. </span>
+</pre>
+
+<p><br>
+<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>longestSubstring()</strong>&nbsp;which takes a String S as input and returns the length of largest possible Palindrome.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(|S|*26)<br>
+<strong>Expected Auxiliary Space:</strong> O(|S|*26)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ |S| ≤ 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Longest substring to form a Palindrome - GFG/longest-substring-to-form-a-palindrome.cpp b/Longest substring to form a Palindrome - GFG/longest-substring-to-form-a-palindrome.cpp
new file mode 100644
index 0000000..09ee765
--- /dev/null
+++ b/Longest substring to form a Palindrome - GFG/longest-substring-to-form-a-palindrome.cpp	
@@ -0,0 +1,43 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+//User function Template for C++
+class Solution {
+  public:
+    int longestSubstring(string S) {
+        unordered_map<int, int> mp;
+        mp[0] = -1;
+        
+        int state = 0, res = 0;
+        for(int i=0; i<S.length(); i++) {
+            state ^= 1<<(S[i]-'a');
+            if(mp.find(state) != mp.end()) res = max(res, i-mp[state]);
+            else mp[state] = i;
+            
+            for(int k=0; k<26; k++) {
+                int mask = state^(1<<k);
+                if(mp.find(mask) != mp.end())
+                    res = max(res, i-mp[mask]);
+            }
+        }
+        
+        return res;
+    }
+};
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        string S;
+        cin>>S;
+
+        Solution ob;
+        cout << ob.longestSubstring(S) << endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/M-Coloring Problem - GFG/README.md b/M-Coloring Problem - GFG/README.md
new file mode 100644
index 0000000..7672d8a
--- /dev/null
+++ b/M-Coloring Problem - GFG/README.md	
@@ -0,0 +1,39 @@
+# M-Coloring Problem
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an undirected graph and an integer&nbsp;<strong>M</strong>. The task is to determine if the graph can be colored with at most M&nbsp;colors such that no two adjacent vertices of the graph are colored with the same color. Here coloring of a graph means the assignment of colors to all vertices. Print 1&nbsp;if it is possible to colour vertices and 0&nbsp;otherwise.</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
+M = 3
+E = 5
+Edges[] = {(0,1),(1,2),(2,3),(3,0),(0,2)}
+<strong>Output: </strong>1<strong>
+Explanation: </strong>It is possible to colour the
+given graph using 3 colours.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 3
+M = 2
+E = 3
+Edges[] = {(0,1),(1,2),(0,2)}
+<strong>Output: </strong>0</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+Your task is to complete the function&nbsp;<strong>graphColoring()</strong>&nbsp;which takes the 2d-array graph[], the number of colours and the number of nodes&nbsp;as inputs and returns <strong>true</strong>&nbsp;if answer exists otherwise <strong>false</strong>. 1 is printed if the returned value is&nbsp;<strong>true,&nbsp;</strong>0 otherwise. The printing is done by the driver's code.<br>
+<strong>Note</strong>: In Example there are Edges not the graph.Graph will be like, if there is an edge between vertex X and vertex Y graph[] will contain 1 at graph[X-1][Y-1], else 0.&nbsp;In 2d-array graph[ ], nodes are 0-based indexed, i.e. from 0 to N-1.Function will be contain 2-D graph not the edges.</span><br>
+<br>
+<strong><span style="font-size:18px">Expected Time Complexity:</span></strong><span style="font-size:18px">&nbsp;O(M</span><sup>N</sup><span style="font-size:18px">).</span><br>
+<strong><span style="font-size:18px">Expected Auxiliary&nbsp;</span></strong><span style="font-size:18px"><strong>Space:</strong>&nbsp;O(N).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 20<br>
+1 ≤ E ≤ (N*(N-1))/2<br>
+1 ≤ M ≤ N</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/M-Coloring Problem - GFG/mcoloring-problem.cpp b/M-Coloring Problem - GFG/mcoloring-problem.cpp
new file mode 100644
index 0000000..763145c
--- /dev/null
+++ b/M-Coloring Problem - GFG/mcoloring-problem.cpp	
@@ -0,0 +1,66 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+//Function to determine if graph can be coloured with at most M colours such
+//that no two adjacent vertices of graph are coloured with same colour.
+
+bool isPossible(int k,int n,int color[],bool graph[101][101], int V)
+{
+    for(int i=0;i<V;i++)
+    {
+        if(n != i && graph[n][i] == 1 && color[i] == k)
+          return false;
+    }
+    return true;
+}
+
+bool solve(int n,int color[],bool graph[101][101], int m, int V)
+{
+    if(n == V)return true;
+    
+    for(int i=1;i<=m;i++)
+    {
+        if(isPossible(i,n,color,graph,V))
+        {
+            color[n] = i;
+            if(solve(n+1,color,graph,m,V) == true)return true;
+            color[n] = 0;
+        }
+    }
+    return false;
+}
+
+bool graphColoring(bool graph[101][101], int m, int V)
+{
+    int color[V] = {0};
+    if(solve(0,color,graph,m,V)==true)return true;
+    return false;
+}
+
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int n, m, e;
+        cin >> n >> m >> e;
+        int i;
+        bool graph[101][101];
+        for (i = 0; i < n; i++) {
+            memset(graph[i], 0, sizeof(graph[i]));
+        }
+        for (i = 0; i < e; i++) {
+            int a, b;
+            cin >> a >> b;
+            graph[a - 1][b - 1] = 1;
+            graph[b - 1][a - 1] = 1;
+        }
+        cout << graphColoring(graph, m, n) << endl;
+    }
+    return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Matrix Operations - GFG/README.md b/Matrix Operations - GFG/README.md
new file mode 100644
index 0000000..363c756
--- /dev/null
+++ b/Matrix Operations - GFG/README.md	
@@ -0,0 +1,49 @@
+# Matrix Operations
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a binary matrix&nbsp;of dimensions <strong>M&nbsp;* N.&nbsp;</strong>One can perform the given operation in&nbsp;the matrix.</span></p>
+
+<ul>
+	<li><span style="font-size:18px">If the value of&nbsp;<strong>matrix[i][j]</strong>&nbsp;is&nbsp;<strong>0</strong>, then traverse in the same direction and check the next value.</span></li>
+	<li><span style="font-size:18px">If the value of&nbsp;<strong>matrix[i][j]</strong>&nbsp;is&nbsp;<strong>1</strong>, then update&nbsp;<strong>matrix[i][j]</strong>&nbsp;to&nbsp;<strong>0</strong>&nbsp;and change the current direction from&nbsp;<strong>up</strong>,&nbsp;<strong>right</strong>,&nbsp;<strong>down</strong>, or&nbsp;<strong>left</strong>&nbsp;to the directions&nbsp;<strong>right</strong>,&nbsp;<strong>down</strong>,&nbsp;<strong>left</strong>, and&nbsp;<strong>up</strong>&nbsp;respectively.</span></li>
+</ul>
+
+<p><span style="font-size:18px">Initially you start from <strong>cell(0, 0)</strong>, moving in <strong>right</strong> direction.</span></p>
+
+<p><span style="font-size:18px">The task is to find the first cell&nbsp;of the matrix </span>&nbsp;<span style="font-size:18px">which&nbsp;</span><span style="font-size:18px">leads to outside the matrix from</span><span style="font-size:18px">&nbsp;the traversal of the given matrix&nbsp;from the cell&nbsp;<strong>(0, 0)</strong> by performing the operations.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+matrix[][] = {{0,1},
+              {1,0}}</span>
+
+<span style="font-size:18px"><strong>Output:</strong> (1,1)
+<strong>Explanation:</strong>
+<img alt="" src="https://media.geeksforgeeks.org/img-practice/endpoint1-1622886995.jpg" style="height:178px; width:300px" class="img-responsive">
+<img alt="" src="https://media.geeksforgeeks.org/img-practice/endpoint2-1622887085.jpg" style="height:178px; width:500px" class="img-responsive">
+<img alt="" src="https://media.geeksforgeeks.org/img-practice/endpoint3-1622887174.jpg" style="height:250px; width:500px" class="img-responsive"></span>
+
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> 
+matrix[][] = {{0, 1, 1, 1, 0},</span>
+                   <span style="font-size:18px">{1, 0, 1, 0, 1},
+              {1, 1, 1, 0, 0}}</span>
+
+<span style="font-size:18px"><strong>Output:</strong> (2,0)</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read input or print anything. Complete the function <strong>endPoints()</strong>&nbsp;that take the matrix as input parameter and output the last cell before the pointer gets outside of the matrix.</span></p>
+
+<p><span style="font-size:18px"><strong>Constrains:</strong><br>
+1&lt;= M, N&nbsp;&lt;=1000<br>
+0&lt;= matrix[i][j] &lt;=1</span></p>
+
+<p>&nbsp;</p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Matrix Operations - GFG/matrix-operations.cpp b/Matrix Operations - GFG/matrix-operations.cpp
new file mode 100644
index 0000000..308ea9e
--- /dev/null
+++ b/Matrix Operations - GFG/matrix-operations.cpp	
@@ -0,0 +1,83 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include<bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution{
+    public:
+    pair<int,int> endPoints(vector<vector<int>> arr){
+       //code here
+       int m = arr.size();
+       int n = arr[0].size();
+       
+       int a = 0, b = 1;
+       int i = 0, j = 0;
+       pair<int, int> res = {0, 0};
+       
+       while(true){
+           if(arr[i][j] == 0){
+               i = i + a;
+               j = j + b;
+           }
+           else{
+               arr[i][j] = 0;
+               if(a==0 && b==1){
+                   a = 1;
+                   b = 0;
+               }
+               else if(a==1 && b==0){
+                   a = 0;
+                   b = -1;
+               }
+               else if(a==0 && b==-1){
+                   a = -1;
+                   b = 0;
+               }
+               else if(a==-1 && b==0){
+                   a = 0;
+                   b = 1;
+               }
+               i = i + a;
+               j = j + b;
+           }
+           if(i>=m || i<0 || j>=n || j<0){
+               res.first = i-a;
+               res.second = j-b;
+               break;
+           }
+       }
+       return res;
+   }
+
+};
+
+// { Driver Code Starts.
+
+
+int main()
+{
+    int tc;
+	scanf("%d", &tc);
+	while(tc--){
+		int row, col;
+		scanf("%d", &row);
+		scanf("%d", &col);
+		vector<vector<int>> matrix(row , vector<int> (col));
+	 
+		for(int i = 0; i < row; i++){
+			for(int j = 0; j < col; j++){
+			    cin>>matrix[i][j];
+			}
+		}
+		Solution obj;
+		pair<int,int> p = obj.endPoints(matrix);
+		
+		cout << "(" << p.first << ", " << p.second << ")" << endl;
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Maximum Winning score - GFG/README.md b/Maximum Winning score - GFG/README.md
new file mode 100644
index 0000000..423b1a6
--- /dev/null
+++ b/Maximum Winning score - GFG/README.md	
@@ -0,0 +1,53 @@
+# Maximum Winning score
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">In an online game, <strong>N</strong> blocks are arranged in a hierarchical manner. All the blocks are connected together by a total of N-1 connections.&nbsp;Each block is given an ID from 1 to N. A block may be further connected to other blocks. Each block is also assigned a specific<strong> point value</strong>.</span></p>
+
+<p><span style="font-size:18px">A player starts from Block 1. She must move forward from each block to a directly connected block until she reaches the final block, which has no further connection. When the player lands on a block, she <strong>collects the point value</strong> of that block. The players score is calculated as the <strong>product of point values</strong>&nbsp;that the player collects.<br>
+Find the maximum score a player can achieve.<br>
+<strong>Note:&nbsp;</strong>The answer can always be represented with 64 bits.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>     4
+&nbsp;   / \
+&nbsp;  2   8
+&nbsp; / \ / \
+&nbsp;2  1 3  4
+<strong>Output: </strong>128<strong>
+Explanation: </strong>Path in the given tree 
+goes like 4, 8, 4 which gives the max
+score of 4x8x4 = 128.
+</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; 7      5
+          \
+           1
+<strong>Output: </strong>70<strong>
+Explanation: </strong>The path 10, 7 gives a 
+score of 70 which is the maximum possible.</span>
+</pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your&nbsp;Task:</strong><br>
+You don't need to take input or print anything. Your task is to <strong>complete </strong>the function&nbsp;<strong>findMaxScore()&nbsp;</strong>that takes <strong>root </strong>as input and returns max score possible.</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></p>
+
+<div><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤&nbsp;Number of nodes ≤&nbsp;10<sup>3</sup><br>
+1&nbsp;≤&nbsp;Data on node&nbsp;≤&nbsp;10 </span></div>
+
+<div><span style="font-size:18px">It is guaranteed that the answer will always fit in the 64-bit Integer</span></div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Maximum Winning score - GFG/maximum-winning-score.cpp b/Maximum Winning score - GFG/maximum-winning-score.cpp
new file mode 100644
index 0000000..eb88f8a
--- /dev/null
+++ b/Maximum Winning score - GFG/maximum-winning-score.cpp	
@@ -0,0 +1,137 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// Tree Node
+struct Node
+{
+    int data;
+    Node* left;
+    Node* right;
+};
+
+// Utility function to create a new Tree Node
+Node* newNode(int val)
+{
+    Node* temp = new Node;
+    temp->data = val;
+    temp->left = NULL;
+    temp->right = NULL;
+
+    return temp;
+}
+
+// Function to Build Tree
+Node* buildTree(string str)
+{
+    // Corner Case
+    if (str.length() == 0 || str[0] == 'N')
+        return NULL;
+
+    // Creating vector of strings from input
+    // string after spliting by space
+    vector<string> ip;
+
+    istringstream iss(str);
+    for (string str; iss >> str; )
+        ip.push_back(str);
+
+    // Create the root of the tree
+    Node* root = newNode(stoi(ip[0]));
+
+    // Push the root to the queue
+    queue<Node*> queue;
+    queue.push(root);
+
+    // Starting from the second element
+    int i = 1;
+    while (!queue.empty() && i < ip.size()) {
+
+        // Get and remove the front of the queue
+        Node* currNode = queue.front();
+        queue.pop();
+
+        // Get the current node's value from the string
+        string currVal = ip[i];
+
+        // If the left child is not null
+        if (currVal != "N") {
+
+            // Create the left child for the current node
+            currNode->left = newNode(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->left);
+        }
+
+        // For the right child
+        i++;
+        if (i >= ip.size())
+            break;
+        currVal = ip[i];
+
+        // If the right child is not null
+        if (currVal != "N") {
+
+            // Create the right child for the current node
+            currNode->right = newNode(stoi(currVal));
+
+            // Push it to the queue
+            queue.push(currNode->right);
+        }
+        i++;
+    }
+
+    return root;
+}
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+//Structure of node
+/*struct Node {
+    int data;
+    Node *left;
+    Node *right;
+
+    Node(int val) {
+        data = val;
+        left = right = NULL;
+    }
+};*/
+class Solution {
+  public:
+    //Function to return maximum path product from any node in a tree.
+   long long findMaxScore(Node* root)
+    {
+        if(root == NULL) return 1;
+        
+        long long lScore = findMaxScore(root->left);
+        long long rScore = findMaxScore(root->right);
+        
+        
+        return max(lScore*root->data,rScore*root->data);
+    }
+};
+
+// { Driver Code Starts.
+
+
+int main() {
+    int tc;
+    cin>>tc;
+    cin.ignore(256, '\n');
+    while (tc--) {
+        string treeString;
+        getline(cin, treeString);
+        Solution ob;
+        Node *root = buildTree(treeString);
+        cout << ob.findMaxScore(root) << "\n";
+    }
+
+
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Maximum average subarray - GFG/README.md b/Maximum average subarray - GFG/README.md
new file mode 100644
index 0000000..bfd2b16
--- /dev/null
+++ b/Maximum average subarray - GFG/README.md	
@@ -0,0 +1,39 @@
+# Maximum average subarray
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array <strong>Arr</strong>&nbsp;of size <strong>N</strong> and a positive integer <strong>K</strong>, find the sub-array of length <strong>K</strong> with the maximum&nbsp;average. </span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>K = 4, N = 6
+Arr[] = {1, 12, -5, -6, 50, 3}
+<strong>Output:</strong> 12 -5 -6 50
+<strong>Explanation:</strong> Maximum average is 
+(12 - 5 - 6 + 50)/4 = 51/4.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>K = 3, N = 7
+Arr[] = {3, -435, 335, 10, -50, 100, 20}
+<strong>Output:</strong> 335 10 -50
+<strong>Explanation:</strong>&nbsp;Maximum average is 
+(335 + 10 - 50)/3 = 295/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&nbsp;<strong>findMaxAverage()</strong>&nbsp;which takes the array of integers&nbsp;<strong>arr, </strong>its size <strong>n</strong>&nbsp;and integer&nbsp;<strong>k&nbsp;</strong>as input parameters and returns an integer&nbsp;denoting the starting index of the subarray.</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)<br>
+<br>
+<strong>Constraints</strong><br>
+1 &lt;=&nbsp;N &lt;= 10<sup>5</sup><br>
+0 &lt;= |Arr[i]| &lt;= 10<sup>3</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Maximum average subarray - GFG/maximum-average-subarray.cpp b/Maximum average subarray - GFG/maximum-average-subarray.cpp
new file mode 100644
index 0000000..3b6fb37
--- /dev/null
+++ b/Maximum average subarray - GFG/maximum-average-subarray.cpp	
@@ -0,0 +1,53 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function template for C++
+
+class Solution{   
+public:
+   int findMaxAverage(int arr[], int n, int k) {
+       if(n<k)
+            return 0;
+       int sum =0;
+       for(int i=0;i<k;i++){
+           sum+=arr[i];
+       }
+       int ans=sum;
+       int idx=0;
+       for(int j=k;j<n;j++){
+           sum+=arr[j]-arr[j-k];
+           if(sum>=ans){
+               ans=sum;
+               idx=j-k+1;
+           }
+       }
+       return idx;
+    }
+};
+
+// { Driver Code Starts.
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int n, k;
+        cin >> k;
+        cin >> n;
+        int arr[n];
+        for (int i = 0; i < n; i++) {
+            cin >> arr[i];
+        }
+        Solution ob;
+        auto ans = ob.findMaxAverage(arr, n, k);
+        for (int i = ans; i < ans + k; i++) {
+            cout << arr[i] << " ";
+        }
+        cout << "\n";
+    }
+    return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Maximum number of events that can be attended - GFG/maximum-number-of-events-that-can-be-attended.cpp b/Maximum number of events that can be attended - GFG/maximum-number-of-events-that-can-be-attended.cpp
new file mode 100644
index 0000000..037cad4
--- /dev/null
+++ b/Maximum number of events that can be attended - GFG/maximum-number-of-events-that-can-be-attended.cpp	
@@ -0,0 +1,55 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+//User function Template for C++
+class Solution {
+  public:
+    int maxEvents(int start[], int end[], int N) {
+        priority_queue <int, vector<int>, greater<int>> pq;
+        vector<pair<int,int>> A(N);
+        for(int i=0; i<N; i++)
+        {
+            A[i].first = start[i];
+            A[i].second = end[i];
+        }
+        sort(A.begin(),A.end());
+        
+        int i = 0, res = 0, d = 0;
+        while (pq.size() > 0 || i < N) {
+            if (pq.size() == 0)
+                d = A[i].first;
+            while (i < N && A[i].first <= d)
+                pq.push(A[i++].second);
+            pq.pop();
+            ++res, ++d;
+            while (pq.size() > 0 && pq.top() < d)
+                pq.pop();
+
+        }
+        return res;
+    }
+};
+
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int N;
+        cin>>N;
+        
+        int start[N], end[N];
+        for(int i=0; i<N; i++)
+            cin>>start[i];
+        for(int i=0; i<N; i++)
+            cin>>end[i];
+
+        Solution ob;
+        cout << ob.maxEvents(start,end,N) << endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Maximum selections - GFG/README.md b/Maximum selections - GFG/README.md
new file mode 100644
index 0000000..940e731
--- /dev/null
+++ b/Maximum selections - GFG/README.md	
@@ -0,0 +1,68 @@
+# Maximum selections
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px"><strong>Note: This&nbsp;<a href="http://practice.geeksforgeeks.org/problem-of-the-day" target="_blank">POTD</a>&nbsp;is a part of&nbsp;<a href="https://practice.geeksforgeeks.org/summer-carnival-2022?utm_source=potd&amp;utm_medium=problempage&amp;utm_campaign=gsc22" target="_blank">Geek Summer Carnival</a>. Solve all POTD consecutively from 5th to 10th April and get a chance to win exclusive discount vouchers on our GfG courses.</strong></span></p>
+
+<hr>
+<p><span style="font-size:18px">Geek wants to select the maximum number of course bundles at the Geek Summer Carnival.&nbsp;</span></p>
+
+<p><span style="font-size:18px">You are given a finite number of courses and N range of numbers each depicting a bundle of courses.&nbsp;Select the maximum number of bundles such that no courses overlap in any of the bundle.</span></p>
+
+<p><span style="font-size:18px"><strong>Note:</strong> The ending of a range being the same as start of another isn't considered as an overlap.</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 = 4
+Bundles = 
+1 5
+2 3
+1 8
+3 5</span>
+
+<span style="font-size:18px"><strong>Output:</strong>
+2</span>
+
+<span style="font-size:18px"><strong>Explanation: 
+<img alt="" src="https://media.geeksforgeeks.org/img-practice/ScreenShot2022-04-01at4-1648812950.png" style="height:65px; width:250px" class="img-responsive"></strong>
+We can select 2 bundles at max while 
+staying true to the condition. For this, 
+we can pick the ranges (2,3) and (3,5) 
+without any overlap. </span></pre>
+
+<p>&nbsp;</p>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 5
+Bundles = 
+7 9 
+2 8 
+1 3 
+10 11 
+10 16</span>
+
+<span style="font-size:18px"><strong>Output:</strong>
+3</span>
+
+<span style="font-size:18px"><strong>Explanation: 
+<img alt="" src="https://media.geeksforgeeks.org/img-practice/ScreenShot2022-04-01at4-1648813138.png" style="height:60px; width:400px" class="img-responsive"></strong>
+We can pick the ranges (1,3), 
+(7,9) and (10,11) without any overlap.</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>max_non_overlapping()</strong> that takes&nbsp;a 2D array representing N ranges as input parameter. &nbsp;Return the maximum number of course bundles.&nbsp;</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected time complexity: </strong>O(NlogN)<br>
+<strong>Expected space complexity:</strong> O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 1000<br>
+0 &lt;= range[i][j] &lt;= 1000</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Maximum selections - GFG/maximum-selections.cpp b/Maximum selections - GFG/maximum-selections.cpp
new file mode 100644
index 0000000..1b03aac
--- /dev/null
+++ b/Maximum selections - GFG/maximum-selections.cpp	
@@ -0,0 +1,53 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+// ranges[i][0] is the start of ith range
+// ranges[i][1] is the end of ith range
+
+class Solution{
+public:
+    static bool cmp(vector<int> &a, vector<int> &b){
+        return a[1] < b[1];
+    }
+    int max_non_overlapping( vector< vector<int> >& ranges )
+    {
+        // code here
+         sort(ranges.begin(), ranges.end(), cmp);
+        int n = ranges.size();
+        int val = ranges[0][1];
+        int count = 1;
+
+        for(int i = 1;i < n;i++){
+            if(ranges[i][0] >= val){
+                val = ranges[i][1];
+                count++;
+            }
+        }
+        return count;
+    }
+};
+// { Driver Code Starts.
+
+int main()
+{
+	int t;
+	cin>>t;
+	while(t--)
+	{
+		int n;
+		cin>>n;
+
+		vector< vector<int> > v(n,vector<int>(2));
+		for(int i=0; i<n; i++)
+			cin>> v[i][0] >> v[i][1];
+			
+        Solution ob;
+		cout<< ob.max_non_overlapping(v) << endl;
+	}
+	return 1;
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Maximum sum of increasing order elements from n arrays - GFG/README.md b/Maximum sum of increasing order elements from n arrays - GFG/README.md
new file mode 100644
index 0000000..c721277
--- /dev/null
+++ b/Maximum sum of increasing order elements from n arrays - GFG/README.md	
@@ -0,0 +1,34 @@
+# Maximum sum of increasing order elements from n arrays
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given <strong>n</strong> arrays of size <strong>m </strong>each. Find maximum sum obtained by selecting a number from each array such that the element&nbsp;selected from the <strong>i-th</strong> array is more than the element selected from <strong>(i-1)-th</strong> array. If maximum sum cannot be obtained then return <strong>0</strong>.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>​Input :</strong> arr[ ] = {{1,7,4,3}, {4,2,5,1}, {9,5,1,8}}
+<strong>Output :</strong> 18
+<strong>Explanation:</strong>
+We can select 4 from the first array,
+5 from second array and 9 from the third array.
+</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>​Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input :</strong> arr[ ] = {{9,8,7}, {6,5,4}, {3,2,1}} <strong>
+Output :</strong>  0
+
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+This is a function problem. The input is already taken care of by the driver code. You only need to complete the function <strong>maximumSum()</strong> that takes number of row&nbsp;<strong>N</strong>, a number of Column<strong> M</strong>, 2-d array <strong>(arr)</strong>, and return the maximum sum if cannot be obtained then return <strong>0</strong>. The driver code takes care of the printing.</span></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 ≤ 500</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Maximum sum of increasing order elements from n arrays - GFG/maximum-sum-of-increasing-order-elements-from-n-arrays.cpp b/Maximum sum of increasing order elements from n arrays - GFG/maximum-sum-of-increasing-order-elements-from-n-arrays.cpp
new file mode 100644
index 0000000..e8472a1
--- /dev/null
+++ b/Maximum sum of increasing order elements from n arrays - GFG/maximum-sum-of-increasing-order-elements-from-n-arrays.cpp	
@@ -0,0 +1,62 @@
+// { Driver Code Starts
+// CPP program to find maximum sum
+// by selecting a element from n arrays
+#include<bits/stdc++.h>
+
+using namespace std;
+
+// To calculate maximum sum by
+// selecting element from each array
+int maximumSum( int n,int m, vector<vector<int>> &a);
+
+
+
+// Driver program to test maximumSum
+int main() {
+    int t,n,m;
+    cin>>t;
+    while(t--)
+    {
+        cin>>n>>m;
+        vector<vector<int>> arr(n, vector<int>(m,0));
+        for(int i=0;i<n;i++)
+            for(int j=0;j<m;j++)
+            cin>>arr[i][j];
+            
+        cout << maximumSum(n,m,arr)<<endl;
+    
+    }
+    return 0;
+
+}
+// } Driver Code Ends
+
+int maximumSum( int n,int m, vector<vector<int>> &a) {
+
+   for(int i=0;i<n;i++)
+   {
+       sort(a[i].begin(),a[i].end());
+   }
+   int ans=0;
+   int x=a[n-1][m-1];
+   bool flag=false;
+   for(int i=n-2;i>=0;i--)
+   {
+      for(int j=m-1;j>=0;j--)
+      {
+          if(a[i][j]<x)
+          {
+              ans+=a[i][j];
+              x=a[i][j];
+              flag=true;
+              break;
+          }
+      }
+     if(flag==false)
+     return 0;
+     else 
+     flag=false;
+   }
+   ans+=a[n-1][m-1];
+   return ans;
+}
\ No newline at end of file
diff --git a/Median in a row-wise sorted Matrix - GFG/README.md b/Median in a row-wise sorted Matrix - GFG/README.md
new file mode 100644
index 0000000..cc5a221
--- /dev/null
+++ b/Median in a row-wise sorted Matrix - GFG/README.md	
@@ -0,0 +1,45 @@
+# Median in a row-wise sorted Matrix
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a row wise sorted matrix of size RxC where R and C are always odd,&nbsp;find the median of the matrix.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong>:
+R = 3, C = 3
+M = [[1, 3, 5], 
+&nbsp;    [2, 6, 9], 
+&nbsp;    [3, 6, 9]]
+
+<strong>Output:</strong>&nbsp;5
+
+<strong>Explanation</strong>:
+Sorting matrix elements gives us 
+{1,2,3,3,5,6,6,9,9}. Hence, 5 is median. 
+</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>
+R = 3, C = 1
+M = [[1], [2], [3]]
+<strong>Output: </strong>2
+</span></pre>
+
+<p><br>
+<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>median()</strong>&nbsp;which takes the integers&nbsp;R and&nbsp;C along with the&nbsp;2D&nbsp;matrix&nbsp;as input parameters and returns the median of the matrix.<br>
+<br>
+<strong>Expected Time Complexity:</strong> O(32 * R * log(C))</span><br>
+<span style="font-size:18px"><strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1&lt;= R,C&nbsp;&lt;=150<br>
+1&lt;= matrix[i][j] &lt;=2000</span><br>
+<br>
+&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Median in a row-wise sorted Matrix - GFG/median-in-a-rowwise-sorted-matrix.cpp b/Median in a row-wise sorted Matrix - GFG/median-in-a-rowwise-sorted-matrix.cpp
new file mode 100644
index 0000000..f121336
--- /dev/null
+++ b/Median in a row-wise sorted Matrix - GFG/median-in-a-rowwise-sorted-matrix.cpp	
@@ -0,0 +1,69 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+//User function template for C++
+
+class Solution{   
+public:
+int counter(int mid,vector<vector<int>> &matrix, int r, int c)
+{
+    int ans = 0;
+    for(int i=0;i<r;i++)
+    {
+        ans += upper_bound(matrix[i].begin(),matrix[i].end(),mid) - matrix[i].begin();
+    }
+    return ans;
+}
+    int median(vector<vector<int>> &matrix, int r, int c){
+        // code here  
+        int low = INT_MAX;
+        int high = INT_MIN;
+        for(int i = 0;i<r;i++)
+        low = min(low,matrix[i][0]);
+        for(int i = 0;i<r;i++)
+        high = max(high,matrix[i][c-1]);
+     //   cout<<low<<high<<endl;
+       
+        
+        
+        int des =  ((r*c) +1)/2;
+        while(high>low)
+        {
+             int mid = low +(high - low)/2;
+            int ans = counter(mid,matrix,r,c);
+            
+            if(ans < des)
+            low = mid+1;
+            else
+            high = mid;
+            
+        }
+        return low;
+        
+    }
+};
+
+// { Driver Code Starts.
+
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int r, c;
+        cin>>r>>c;
+        vector<vector<int>> matrix(r, vector<int>(c));
+        for(int i = 0; i < r; ++i)
+            for(int j = 0;j < c; ++j)
+                cin>>matrix[i][j];
+        Solution obj;
+        cout<<obj.median(matrix, r, c)<<endl;        
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Merge K sorted linked lists - GFG/README.md b/Merge K sorted linked lists - GFG/README.md
new file mode 100644
index 0000000..3cc515b
--- /dev/null
+++ b/Merge K sorted linked lists - GFG/README.md	
@@ -0,0 +1,51 @@
+# Merge K sorted linked lists
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given <strong>K</strong> sorted linked lists of different sizes. The task is to merge them in such a way that after merging they will be a single sorted 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>K = 4
+value = {{1,2,3},{4 5},{5 6},{7,8}}
+<strong>Output: </strong>1&nbsp;2&nbsp;3&nbsp;4&nbsp;5&nbsp;5&nbsp;6&nbsp;7&nbsp;8<strong>
+Explanation:
+</strong>The test case has 4 sorted linked 
+list of size 3, 2,&nbsp;2,&nbsp;2
+1st&nbsp; &nbsp; list &nbsp; &nbsp;&nbsp;1 -&gt; 2-&gt; 3
+2nd&nbsp; &nbsp;list &nbsp; &nbsp; &nbsp;4-&gt;5
+3rd&nbsp; &nbsp; list &nbsp; &nbsp; &nbsp;5-&gt;6
+4th&nbsp; &nbsp; list &nbsp; &nbsp; &nbsp;7-&gt;8
+The merged list will be
+1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;5-&gt;6-&gt;7-&gt;8.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>K = 3
+value = {{1,3},{4,5,6},{8}}
+<strong>Output: </strong>1 3 4 5 6 8<strong>
+Explanation:
+</strong>The test case has 3 sorted linked
+list of size 2, 3, 1.
+1st list 1&nbsp;-&gt; 3
+2nd list 4 -&gt; 5&nbsp;-&gt; 6
+3rd list 8
+The merged list will be
+1-&gt;3-&gt;4-&gt;5-&gt;6-&gt;8.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+The task is to complete the function <strong>mergeKList</strong>() which merges the K given lists into a sorted one. 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:</strong>&nbsp;O(nk Logk)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(k)<br>
+<strong>Note: n&nbsp;</strong>is the maximum size of all the <strong>k</strong>&nbsp;link list</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints</strong><br>
+1 &lt;= K&nbsp;&lt;= 10<sup>3</sup></span></p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Merge K sorted linked lists - GFG/merge-k-sorted-linked-lists.cpp b/Merge K sorted linked lists - GFG/merge-k-sorted-linked-lists.cpp
new file mode 100644
index 0000000..c715f96
--- /dev/null
+++ b/Merge K sorted linked lists - GFG/merge-k-sorted-linked-lists.cpp	
@@ -0,0 +1,134 @@
+// { Driver Code Starts
+// C++ program to merge k sorted arrays of size n each
+#include <bits/stdc++.h>
+using namespace std;
+
+// A Linked List node
+struct Node
+{
+	int data;
+	Node* next;
+	
+	Node(int x){
+	    data = x;
+	    next = NULL;
+	}
+	
+};
+
+/* Function to print nodes in a given linked list */
+void printList(Node* node)
+{
+	while (node != NULL)
+	{
+		printf("%d ", node->data);
+		node = node->next;
+	}
+	cout<<endl;
+}
+
+ // } Driver Code Ends
+/*Linked list Node structure
+
+struct Node
+{
+	int data;
+	Node* next;
+	
+	Node(int x){
+	    data = x;
+	    next = NULL;
+	}
+	
+};
+*/ 
+
+class Solution {
+ public:
+   //Function to merge K sorted linked list.
+   Node * mergeKLists(Node *arr[], int k)
+   {
+          
+          int minN = INT_MAX;
+          int minNode = 0;
+          
+          Node* head = NULL;
+          Node * ans = NULL;
+          
+          while (1)
+          {
+              int nodes = 0;
+              for (int i = 0; i < k; ++i)
+               {
+                   if (arr[i])
+                   {
+                       if (minN > arr[i]->data)
+                           {
+                               minN = arr[i]->data;
+                               minNode = i;
+                           }
+                   }
+                   else
+                       ++nodes;
+               }
+               
+               if (nodes == k)
+                   break;
+               
+               if (!head)
+               {
+                   head = new Node(minN);
+                   ans = head;
+               }
+               else
+               {
+                   head->next = new Node(minN);  
+                   head = head->next;
+               }           
+               arr[minNode] = arr[minNode] ->next;
+               minN = INT_MAX;               
+          }          
+          return ans;
+   }
+};
+
+
+// { Driver Code Starts.
+// Driver program to test above functions
+int main()
+{
+   int t;
+   cin>>t;
+   while(t--)
+   {
+	   int N;
+	   cin>>N;
+       struct Node *arr[N];
+       for(int j=0;j<N;j++)
+        {
+           int n;
+           cin>>n;
+
+           int x;
+           cin>>x;
+           arr[j]=new Node(x);
+           Node *curr = arr[j];
+           n--;
+
+           for(int i=0;i<n;i++)
+           {
+               cin>>x;
+               Node *temp = new Node(x);
+               curr->next =temp;
+               curr=temp;
+           }
+   		}
+   		Solution obj;
+   		Node *res = obj.mergeKLists(arr,N);
+		printList(res);
+
+   }
+
+	return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Min Coin - GFG/README.md b/Min Coin - GFG/README.md
new file mode 100644
index 0000000..7bd8c27
--- /dev/null
+++ b/Min Coin - GFG/README.md	
@@ -0,0 +1,39 @@
+# Min Coin
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a list of coins of distinct denominations and total amount of money. Find&nbsp;the minimum number of coins required to make up that amount. Output<strong> -1</strong> if that money cannot be made up using given coins.<br>
+You may assume that there are infinite numbers of coins of each type.</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>arr = [1, 2, 5], amount = 11
+<strong>Output: </strong>3
+<strong>Explanation: </strong>2*5 + 1 = 11. So taking 2 
+denominations of 5 and 1 denomination of  
+1, </span><span style="font-size:18px">one can make 11.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><strong><span style="font-size:18px">Input: </span></strong><span style="font-size:18px">arr = [2, 6], amount = 7
+<strong>Output: </strong>-1
+<strong>Explanation: </strong>Not possible to make 7 using 
+denominations 2 and 6.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read or print anything. Your task is to complete the function&nbsp;<strong>MinCoin()</strong>&nbsp;which takes list of denominations and amount as input parameter and returns miimum number of coins to make up amount. If not possible returns -1.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(n*amount)<br>
+<strong>Expected Space Complexity:&nbsp;</strong>O(amount)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Contstraints:</strong><br>
+1 &lt;= number of distinct denominations&nbsp;&lt;= 100</span><br>
+<span style="font-size:18px">1 &lt;= amount &lt;= 10<sup>4</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Min Coin - GFG/min-coin.cpp b/Min Coin - GFG/min-coin.cpp
new file mode 100644
index 0000000..50f5f23
--- /dev/null
+++ b/Min Coin - GFG/min-coin.cpp	
@@ -0,0 +1,61 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+
+class Solution{
+public:
+int min_coin(vector<int>nums, int amount, int i, vector<vector<int>>&dp){
+    if(amount==0)
+        return 0;
+        
+    if(i==0){
+        if(amount>=nums[0] && amount%nums[0]==0)
+            return amount/nums[0];
+        else
+            return 100001;
+    }
+    
+    if(dp[i][amount]!=-1)
+        return dp[i][amount];
+       
+    int mini = INT_MAX;
+    
+    // not pick
+    mini = min(mini, min_coin(nums, amount, i-1, dp));
+    
+    // pick
+    if(amount>=nums[i])
+        mini = min(mini, min_coin(nums, amount-nums[i], i, dp) + 1);
+       
+    dp[i][amount] = mini;
+    return mini;
+}
+int MinCoin(vector<int>nums, int amount)
+{
+    int n = nums.size();
+    vector<vector<int>>dp(n, vector<int>(amount+1, -1));
+    int val = min_coin(nums, amount, n-1, dp);
+    if(val<=10000)
+        return val;
+    else
+        return -1;
+}
+};
+// { Driver Code Starts.
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		int n, amount;
+		cin >> n >> amount;
+		vector<int>nums(n);
+		for(int i = 0; i < n; i++)
+			cin >> nums[i];
+		Solution ob;
+		int ans = ob.MinCoin(nums, amount);
+		cout << ans <<"\n";
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Minimum Swaps to Sort - GFG/README.md b/Minimum Swaps to Sort - GFG/README.md
new file mode 100644
index 0000000..3f912b5
--- /dev/null
+++ b/Minimum Swaps to Sort - GFG/README.md	
@@ -0,0 +1,38 @@
+# Minimum Swaps to Sort
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array of n distinct elements. Find the minimum number of swaps required to sort the array in strictly increasing&nbsp;order.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>nums = {2, 8, 5, 4}
+<strong>Output:</strong>
+1
+<strong>Explaination:</strong>
+swap 8 with 4.</span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>nums = {10, 19, 6, 3, 5}
+<strong>Output:</strong>
+2
+<strong>Explaination:
+</strong>swap 10 with 3 and swap 19 with 5.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You do not need to read input or print anything. Your task is to complete the function <strong>minSwaps() </strong>which takes the <strong>nums&nbsp;</strong>as input parameter&nbsp;and returns an integer denoting the minimum number of swaps required to sort the array. If the array is already sorted, return 0.&nbsp;</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(nlogn)<br>
+<strong>Expected Auxiliary Space: </strong>O(n)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ n&nbsp;≤ 10<sup>5</sup><br>
+1 ≤ nums<sub>i</sub>&nbsp;≤ 10<sup>6</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Minimum Swaps to Sort - GFG/minimum-swaps-to-sort.cpp b/Minimum Swaps to Sort - GFG/minimum-swaps-to-sort.cpp
new file mode 100644
index 0000000..21e016b
--- /dev/null
+++ b/Minimum Swaps to Sort - GFG/minimum-swaps-to-sort.cpp	
@@ -0,0 +1,47 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+
+
+class Solution 
+{
+    public:
+    //Function to find the minimum number of swaps required to sort the array. 
+	int minSwaps(vector<int>&nums)
+	{
+	   map<int,int> mp;
+    for(int i=0;i<nums.size();i++)
+    mp[nums[i]]=i;
+    int i=0,c=0;;
+    for(auto it=mp.begin();it!=mp.end();it++)
+    {
+        if(nums[i]!=it->first)
+        {
+            swap(nums[i],nums[it->second]);
+            mp[nums[it->second]]=it->second;
+            c++;
+        }
+        i++;
+    }
+    return c;
+	}
+};
+
+// { Driver Code Starts.
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		int n;
+		cin >> n;
+		vector<int>nums(n);
+		for(int i = 0; i < n; i++)
+			cin >> nums[i];
+		Solution obj;
+		int ans = obj.minSwaps(nums);
+		cout << ans <<"\n";
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Move all zeros to the front of the linked list - GFG/README.md b/Move all zeros to the front of the linked list - GFG/README.md
new file mode 100644
index 0000000..7610538
--- /dev/null
+++ b/Move all zeros to the front of the linked list - GFG/README.md	
@@ -0,0 +1,30 @@
+# Move all zeros to the front of the linked list
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a linked list, the task is to move all 0s to the front of the linked list. The order of all another element except 0 should be same after rearrangement. </span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong> 0 -&gt; 4 -&gt; 0 -&gt; 5 -&gt; 0<strong>
+Output: </strong>0 -&gt; 0 -&gt; 0 -&gt; 4 -&gt; 5
+<strong>Explanation: </strong>After moving all 0s of the given
+list to the front, the list is:
+0 -&gt; 0 -&gt; 0 -&gt; 4 -&gt; 5</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>0 -&gt; 1 -&gt; 0 -&gt; 1 -&gt; 2<strong>
+Output: </strong>0 -&gt; 0 -&gt; 1 -&gt; 1 -&gt; 2</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>moveZeroes()&nbsp;</strong>which takes head node of the linked list as input parameter.</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><br>
+1 &lt;= N&nbsp;&lt;= 50</span><br>
+<br>
+&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Move all zeros to the front of the linked list - GFG/move-all-zeros-to-the-front-of-the-linked-list.cpp b/Move all zeros to the front of the linked list - GFG/move-all-zeros-to-the-front-of-the-linked-list.cpp
new file mode 100644
index 0000000..8643c39
--- /dev/null
+++ b/Move all zeros to the front of the linked list - GFG/move-all-zeros-to-the-front-of-the-linked-list.cpp	
@@ -0,0 +1,87 @@
+// { Driver Code Starts
+//Initial Template for C++
+#include<bits/stdc++.h>
+using namespace std;
+struct Node
+{
+    int data;
+    struct Node* next;
+    
+    Node(int x){
+        data = x;
+        next = NULL;
+    }
+    
+};
+
+void push(struct Node **head_ref, int new_data) {
+    struct Node *new_node = new Node(new_data);
+    new_node->next = (*head_ref);
+    (*head_ref) = new_node;
+}
+
+void moveZeroes(struct Node **head);
+
+// function to displaying nodes
+void display(struct Node *head) {
+    while (head != NULL) {
+	    cout << head->data << " ";
+	    head = head->next;
+    }
+    cout <<endl;
+}
+
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int n;
+        cin>>n;
+        int q;
+        struct Node *Head=NULL;
+        for(int i=0;i<n;i++)
+        {
+            cin>>q;
+            push(&Head,q);
+        }
+        moveZeroes(&Head);
+        display(Head);
+
+    }
+}
+// } Driver Code Ends
+
+
+//User function Template for C++
+/* Linked List Node structure
+struct Node
+{
+    int data;
+    struct Node* next;
+    
+    Node(int x){
+        data = x;
+        next = NULL;
+    }
+    
+};
+*/
+// Move Zeros to the front of the list
+void moveZeroes(struct Node **head)
+{
+    //Your code here
+    Node * left = *head, *right = *head;
+    while(left && right){
+        if(right->data == 0 && left != right){
+            int temp = left->data; left->data = 0; left = left->next; Node* curr = left;
+            while(curr != right){
+                swap(temp, curr->data);
+                curr = curr->next;
+            }
+            curr->data = temp;
+        }
+        right = right->next;
+    }
+}
\ No newline at end of file
diff --git a/N Digit numbers with digits in increasing order - GFG/README.md b/N Digit numbers with digits in increasing order - GFG/README.md
new file mode 100644
index 0000000..31ff826
--- /dev/null
+++ b/N Digit numbers with digits in increasing order - GFG/README.md	
@@ -0,0 +1,37 @@
+# N Digit numbers with digits in increasing order
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an integer&nbsp;<strong>N</strong>, print all the&nbsp;<strong>N</strong> digit numbers in increasing order, such that their digits are in strictly increasing order(from left to right).</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>N = 1</span>
+<span style="font-size:18px"><strong>Output:
+</strong>0 1 2 3 4 5 6 7 8 9</span>
+<span style="font-size:18px"><strong>Explanation:
+</strong>Single digit numbers are considered to be 
+strictly increasing order.
+</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</span>
+<strong><span style="font-size:18px">Output:
+</span></strong><span style="font-size:18px">12 13 14 15 16 17 18 19 23....79 89</span>
+<strong><span style="font-size:18px">Explanation:
+</span></strong><span style="font-size:18px">For N = 2, the correct sequence is
+12 13 14 15 16 17 18 19 23 and so on 
+up to 89.</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>increasingNumbers</strong>()&nbsp;which takes an integer N as an input parameter and return the list of numbers such that their digits are in strictly increasing order.</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><br>
+1 &lt;= N &lt;= 9</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/N Digit numbers with digits in increasing order - GFG/n-digit-numbers-with-digits-in-increasing-order.cpp b/N Digit numbers with digits in increasing order - GFG/n-digit-numbers-with-digits-in-increasing-order.cpp
new file mode 100644
index 0000000..1b93818
--- /dev/null
+++ b/N Digit numbers with digits in increasing order - GFG/n-digit-numbers-with-digits-in-increasing-order.cpp	
@@ -0,0 +1,56 @@
+// { Driver Code Starts
+#include<bits/stdc++.h> 
+using namespace std; 
+
+ // } Driver Code Ends
+//User function Template for C++
+class Solution
+{
+public:
+   vector<int> ans;
+    void solve(int s, int n, int str, int size)
+    {
+        if(size==n)
+        {
+            ans.push_back(str);
+            return;
+        }
+            
+        for(int i=s; i<=9; i++)
+        {
+            str = str * 10 + i;
+            size++;
+            solve(i+1, n, str, size);
+            size--;
+            str =  (str - i)/10;
+        }
+    }
+    vector<int> increasingNumbers(int N)
+    {
+       if(N==1)
+         solve(0, N, 0, 0);
+       else
+         solve(1, N, 0, 0);
+       return ans;
+    }
+};
+
+// { Driver Code Starts.
+int main()
+{
+    int t;
+    cin >> t;
+    while (t--)
+    {
+        int N;
+        cin>>N;
+        Solution ob;
+        vector<int> ans = ob.increasingNumbers(N);
+        for(auto num : ans){
+            cout<< num <<" ";
+        }
+        cout<<endl;
+        
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Negative weight cycle - GFG/README.md b/Negative weight cycle - GFG/README.md
new file mode 100644
index 0000000..2868e6f
--- /dev/null
+++ b/Negative weight cycle - GFG/README.md	
@@ -0,0 +1,40 @@
+# Negative weight cycle
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a weighted directed graph with n nodes and m edges. Nodes are labeled from 0 to n-1, the task is to check if it contains a negative weight cycle or not.<br>
+<strong>Note:&nbsp;</strong>edges[i] is&nbsp;defined as u, v and weight.</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>n = 3, edges = {{0,1,-1},{1,2,-2},
+{2,0,-3}}
+<strong>Output: </strong>1
+<strong>Explanation: </strong>The graph contains negative weight
+cycle as 0-&gt;1-&gt;2-&gt;0 with weight -1,-2,-3.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>n = 3, edges = {{0,1,-1},{1,2,-2},
+{2,0,3}}
+<strong>Output: </strong>0
+<strong>Explanation: </strong>The graph does not contain any
+negative weight cycle.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read or print anyhting. Your task is to complete the function&nbsp;<strong>isNegativeWeightCycle()&nbsp;</strong>which takes n and edges as input paramater and returns 1 if graph contains negative weight cycle otherwise returns 0.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(n*m)<br>
+<strong>Expected Space Compelxity:&nbsp;</strong>O(n)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= n &lt;= 100<br>
+1 &lt;= m &lt;= n*(n-1)</span><span style="font-size:18px">, where m is the total number of Edges in the directed graph.</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Negative weight cycle - GFG/negative-weight-cycle.cpp b/Negative weight cycle - GFG/negative-weight-cycle.cpp
new file mode 100644
index 0000000..e03e9ef
--- /dev/null
+++ b/Negative weight cycle - GFG/negative-weight-cycle.cpp	
@@ -0,0 +1,44 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution {
+public:
+	int isNegativeWeightCycle(int n, vector<vector<int>>edges){
+	     vector<int> dis(n,1e6);
+	    dis[0]=0;
+	    for(int i=1;i<n;i++){
+	        for(auto &p:edges){
+	            if(dis[p[0]]+p[2]<dis[p[1]]){
+	                dis[p[1]]=p[2]+dis[p[0]];
+	            }
+	        }
+	    }
+	    for(auto &p:edges){
+	        if(dis[p[0]]+p[2]<dis[p[1]]) return 1;
+	    }
+	    return 0;
+	}
+
+};
+
+// { Driver Code Starts.
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		int n, m;
+		cin >> n >> m;
+		vector<vector<int>>edges;
+		for(int i = 0; i < m; i++){
+			int x, y, z;
+			cin >> x >> y >> z;
+			edges.push_back({x,y,z});
+		}
+		Solution obj;
+		int ans = obj.isNegativeWeightCycle(n, edges);
+		cout << ans <<"\n";
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Next Permutation - GFG/README.md b/Next Permutation - GFG/README.md
new file mode 100644
index 0000000..381abbc
--- /dev/null
+++ b/Next Permutation - GFG/README.md	
@@ -0,0 +1,32 @@
+# Next Permutation
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Implement the next permutation, which rearranges the list of numbers into Lexicographically next greater permutation of list of&nbsp;numbers. If such arrangement is not possible, it must be rearranged to the lowest possible order <em>i.e.</em>&nbsp;sorted in an ascending order. You are given an list of numbers <strong>arr[ ]</strong> of size <strong>N</strong>.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> N = 6
+arr = {1, 2, 3, 6, 5, 4}
+<strong>Output:</strong> {1, 2, 4, 3, 5, 6}
+<strong>Explaination:</strong> The next permutation of the 
+given array is {1, 2, 4, 3, 5, 6}.</span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> N = 3
+arr = {3, 2, 1}
+<strong>Output:</strong> {1, 2, 3}
+<strong>Explaination:</strong> As arr[] is the last 
+permutation. So, the next permutation 
+is the lowest one.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You do not need to read input or print anything. Your task is to complete the function <strong>nextPermutation()</strong> which takes N and arr[ ] as input parameters and returns a list of numbers containing the next permutation.</span></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><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10000</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Next Permutation - GFG/next-permutation.cpp b/Next Permutation - GFG/next-permutation.cpp
new file mode 100644
index 0000000..db7edf1
--- /dev/null
+++ b/Next Permutation - GFG/next-permutation.cpp	
@@ -0,0 +1,67 @@
+// { Driver Code Starts
+// Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+
+class Solution{
+public:
+   vector<int> nextPermutation(int n, vector<int> number){
+        int i, j; 
+  
+    // I) Start from the right most digit and find the first digit that is 
+    // smaller than the digit next to it. 
+    for (i = n-1; i > 0; i--) 
+        if (number[i] > number[i-1]) 
+           break; 
+  
+    // If no such digit is found, then all digits are in descending order 
+    // means there cannot be a greater number with same set of digits 
+    if (i==0) 
+    { 
+       sort(number.begin() , number.end());
+       return number;
+    } 
+  
+    // II) Find the smallest digit on right side of (i-1)'th digit that is 
+    // greater than number[i-1] 
+    int x = number[i-1], smallest = i; 
+    for (j = i+1; j < n; j++) 
+        if (number[j] > x && number[j] < number[smallest]) 
+            smallest = j; 
+  
+    // III) Swap the above found smallest digit with number[i-1] 
+    swap(number[smallest], number[i-1]); 
+  
+    // IV) Sort the digits after (i-1) in ascending order 
+    sort(number.begin() + i, number.end() ); 
+  
+    //cout << "Next number with same set of digits is " << number; 
+  
+    return number; 
+    }
+};
+
+// { Driver Code Starts.
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int N;
+        cin>>N;
+        vector<int> arr(N);
+        for(int i = 0;i < N;i++)
+            cin>>arr[i];
+        
+        Solution ob;
+        vector<int> ans = ob.nextPermutation(N, arr);
+        for(int u: ans)
+            cout<<u<<" ";
+        cout<<"\n";
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Nodes at even distance - GFG/README.md b/Nodes at even distance - GFG/README.md
new file mode 100644
index 0000000..2c32edd
--- /dev/null
+++ b/Nodes at even distance - GFG/README.md	
@@ -0,0 +1,44 @@
+# Nodes at even distance
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a connected acyclic graph with n&nbsp;nodes and n-1 edges, count the pair&nbsp;of nodes that are at even distance(number of edges) from each other.</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 = 3
+graph = {{}, {2}, {1, 3}, {2}}
+<strong>Output:</strong> 1
+<strong>Explaination:</strong> Here there are three pairs {1,2},{1,3}
+and {2,3} and only {1,3} has even distance between them.
+</span><span style="font-size:18px">i.e</span> <span style="font-size:18px">          1
+             /
+            2
+           /
+          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
+graph = {{}, {2,4}, {1,3}, {2}, {1,5}, {4}}
+<strong>Output:</strong> 4
+<strong>Explaination:</strong> There are four pairs {1,3},{1,5},{2,4}
+and {3,5} which has even distance.</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>countOfNodes()</strong>&nbsp;which takes the array <strong>graph[]</strong>&nbsp;(given as <a href="https://en.wikipedia.org/wiki/Adjacency_list#:~:text=In%20graph%20theory%20and%20computer,particular%20vertex%20in%20the%20graph." target="_blank">Adjacency list</a>)&nbsp;</span><span style="font-size:18px">and its size <strong>n&nbsp;</strong>as input parameters&nbsp;and returns the count&nbsp;of&nbsp;pair of nodes that are at even distance from each other</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(V+E)<br>
+<strong>Expected Auxiliary Space:</strong> O(V)</span></p>
+
+<p><br>
+<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/Nodes at even distance - GFG/nodes-at-even-distance.cpp b/Nodes at even distance - GFG/nodes-at-even-distance.cpp
new file mode 100644
index 0000000..0abe419
--- /dev/null
+++ b/Nodes at even distance - GFG/nodes-at-even-distance.cpp	
@@ -0,0 +1,64 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution{
+    public:
+    int countOfNodes(vector<int> graph[], int n)
+    {
+        // code here
+        vector<bool>visited(n+1, 0);
+        queue<int>q;
+        int red=0,black=0;
+        q.push(1);
+        visited[1]=true;
+        int level=0;
+        while(!q.empty())
+        {
+            int sz=q.size();
+            if(level%2==0)black+=sz;
+            else red+=sz;
+            while(sz--){
+                int node=q.front();
+                q.pop();
+                for(int i=0; i<graph[node].size(); i++)
+                {
+                    if(!visited[graph[node][i]])
+                    {
+                        q.push(graph[node][i]);
+                        visited[graph[node][i]]=true;
+                    }
+                }
+            }
+            level++;
+        }
+        return ((red*(red-1))/2)+((black*(black-1))/2);
+    }
+};
+
+// { Driver Code Starts.
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int n;
+        cin >> n;
+        vector<int>graph[n+1];
+        for(int i=0;i<n-1;i++){
+            int u, v;
+            cin >> u >> v;
+            graph[u].push_back(v);
+            graph[v].push_back(u);
+        }
+        Solution ob;
+        cout<<ob.countOfNodes(graph, n)<<endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Number of distinct Words with k maximum contiguous vowels - GFG/README.md b/Number of distinct Words with k maximum contiguous vowels - GFG/README.md
new file mode 100644
index 0000000..e47b10d
--- /dev/null
+++ b/Number of distinct Words with k maximum contiguous vowels - GFG/README.md	
@@ -0,0 +1,49 @@
+# Number of distinct Words with k maximum contiguous vowels
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Find the number of unique words consisting of lowercase alphabets only of length N that can be formed with at-most K contiguous vowels.&nbsp;</span></p>
+
+<p><br>
+<strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 2</span>
+<span style="font-size:18px">K = 0</span>
+<span style="font-size:18px"><strong>Output:</strong>
+441
+</span><span style="font-size:18px"><strong>Explanation:</strong>
+Total of 441 unique words are possible
+of length 2 that will have K( =0) vowels
+together, e.g. "bc", "cd", "df", etc are
+valid words while "ab" (with 1 vowel) is
+not a valid word.</span>
+
+</pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 1</span>
+<span style="font-size:18px">K = 1</span>
+<span style="font-size:18px"><strong>Output:</strong>
+26</span>
+<span style="font-size:18px"><strong>Explanation:</strong>
+All the english alphabets including</span>
+<span style="font-size:18px">vowels and consonants; as atmost K( =1)
+vowel can be taken.</span>
+</pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong>&nbsp;&nbsp;<br>
+You don't need to read input or print anything. Your task is to complete the function <strong>kvowelwords</strong>()&nbsp;which takes an Integer N, an intege K and returns the total number of words of size N with atmost K vowels. As the answer maybe to large please <strong>return answer modulo 1000000007</strong>.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N*K)<br>
+<strong>Expected Auxiliary Space:</strong> O(N*K)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 1000</span><br>
+<span style="font-size:18px">0 ≤ K ≤ N</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Number of distinct Words with k maximum contiguous vowels - GFG/number-of-distinct-words-with-k-maximum-contiguous-vowels.cpp b/Number of distinct Words with k maximum contiguous vowels - GFG/number-of-distinct-words-with-k-maximum-contiguous-vowels.cpp
new file mode 100644
index 0000000..0789e00
--- /dev/null
+++ b/Number of distinct Words with k maximum contiguous vowels - GFG/number-of-distinct-words-with-k-maximum-contiguous-vowels.cpp	
@@ -0,0 +1,86 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include<bits/stdc++.h> 
+using namespace std; 
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution
+{
+  public:
+    const int mod = 1e9+7;
+    
+    using ll = long long;
+    int max_K;
+    int kvowelwords(int N, int K) {
+        int cnt = 0;
+        max_K = K;
+        vector<vector<ll>> dp(N+1,vector<ll> (K+1,-1));
+        
+        for(int i=0; i<=N; i++){
+            for(int j=0; j<=K; j++){
+                if(i == 0){
+                    dp[i][j] = 1;
+                    continue;
+                }
+                if(j>0){
+                    dp[i][j] = (5*dp[i-1][j-1]%mod+21*dp[i-1][K]%mod)%mod;
+                }
+                else{
+                    dp[i][j] = 21*dp[i-1][K]%mod;
+                }
+            }
+        }
+        return dp[N][K];
+        
+        // ll ans = solve(N,K,dp);
+        // return (int)ans;
+    }
+    
+    long long solve(int n,int k,vector<vector<ll>> &dp){
+        
+        if(n == 0){
+            return 1;
+        }
+        if(dp[n][k] != -1){
+            return dp[n][k];
+        }
+        if(k>0){
+            //take oval
+            ll ans1 = 5*solve(n-1,k-1,dp)%mod;
+            
+            //no take oval
+            
+            ll ans2 = 21*solve(n-1,max_K,dp)%mod;
+            
+            return dp[n][k] = (ans1+ans2)%mod;
+        }
+        else{
+            //not possible to take oval, broken sequence so can take ovals again
+            return dp[n][k] = 21*solve(n-1,max_K,dp)%mod;
+        }
+    }
+};
+
+
+// { Driver Code Starts.
+
+
+int main()
+{
+    int t;
+    cin >> t;
+    while (t--)
+    {
+        int N;int K;
+        cin >>N>>K;
+        
+        Solution ob;
+        int ans = ob.kvowelwords(N,K);
+        cout << ans << endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Optimal binary search tree - GFG/README.md b/Optimal binary search tree - GFG/README.md
new file mode 100644
index 0000000..18f8792
--- /dev/null
+++ b/Optimal binary search tree - GFG/README.md	
@@ -0,0 +1,56 @@
+# Optimal binary search tree
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a sorted array <strong>keys[0.. n-1]</strong> of search keys and an array <strong>freq[0.. n-1]</strong> of frequency counts, where freq[i] is the number of searches to keys[i]. Construct a binary search tree of all keys such that the total cost of all the searches is as small as possible.<br>
+Let us first define the cost of a BST. The cost of a BST node is level of that node multiplied by its frequency. Level of root is 1.</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 = 2
+keys = {10, 12}
+freq = {34, 50}
+<strong>Output:</strong> 118
+<strong>Explaination:</strong>
+There can be following two possible BSTs 
+        10                       12
+          \                     / 
+           12                 10
+          <em>                    
+The cost of tree I is 34*1 + 50*2 = 134
+The cost of tree II is 50*1 + 34*2 = 118 </em></span></pre>
+
+<p><br>
+<em><span style="font-size:18px"><strong>Example 2:</strong></span></em></p>
+
+<pre><em>
+<span style="font-size:18px"><strong>Input:</strong>
+N = 3
+keys = {10, 12, 20}
+freq = {34, 8, 50}
+<strong>Output:</strong> 142
+<strong>Explaination:</strong> There can be many possible BSTs
+     20
+    /
+   10  
+    \
+     12  
+     <em>
+Among all possible BSTs, 
+cost of this BST is minimum.  
+Cost of this BST is 1*50 + 2*34 + 3*8 = 142</em></span></em></pre>
+
+<p><br>
+<em><em><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>optimalSearchTree()</strong>&nbsp;which takes the array <strong>keys[], freq[]</strong> and their&nbsp;size <strong>n&nbsp;</strong>as input parameters&nbsp;and returns the total cost of all the searches is as small as possible.</span></em></em></p>
+
+<p><br>
+<em><em><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(n<sup>3</sup>)<br>
+<strong>Expected Auxiliary Space:</strong> O(n<sup>2</sup>)</span></em></em></p>
+
+<p><br>
+<em><em><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 100</span></em></em></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Optimal binary search tree - GFG/optimal-binary-search-tree.cpp b/Optimal binary search tree - GFG/optimal-binary-search-tree.cpp
new file mode 100644
index 0000000..14f44cb
--- /dev/null
+++ b/Optimal binary search tree - GFG/optimal-binary-search-tree.cpp	
@@ -0,0 +1,58 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function Template for C++
+class Solution {
+public:
+int dp[101][101];
+int sumfreq(int i, int j, int freq[]) {
+int sum = 0;
+for (int k = i; k <= j; k++) {
+sum += freq[k];
+}
+return sum;
+}
+int optimalBST(int keys[], int freq[], int i, int j) {
+if (i > j)
+return dp[i][j] = 0;
+if (i == j)
+return dp[i][j] = freq[i];
+if (dp[i][j] != -1)
+return dp[i][j];
+int fsum = sumfreq(i, j, freq);
+int min_cost = INT_MAX;
+for (int k = i; k <= j; k++) {
+int cost = optimalBST(keys, freq, i, k - 1) + optimalBST(keys, freq, k + 1, j);
+min_cost = min(min_cost, cost);
+}
+return dp[i][j] = min_cost + fsum;
+}
+int optimalSearchTree(int keys[], int freq[], int n)
+{
+memset(dp, -1, sizeof(dp));
+return optimalBST(keys, freq, 0, n - 1);
+}
+};
+
+// { Driver Code Starts.
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int n;
+        cin >> n;
+        int keys[n];
+        for(int i=0;i<n;i++)cin>>keys[i];
+        int freq[n];
+        for(int i=0;i<n;i++)cin>>freq[i];
+        Solution ob;
+        cout<<ob.optimalSearchTree(keys, freq, n)<<endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Partition Equal Subset Sum - GFG/README.md b/Partition Equal Subset Sum - GFG/README.md
new file mode 100644
index 0000000..c2f9f6c
--- /dev/null
+++ b/Partition Equal Subset Sum - GFG/README.md	
@@ -0,0 +1,36 @@
+# Partition Equal Subset Sum
+##  Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array&nbsp;<strong>arr[]</strong> of size&nbsp;<strong>N</strong>, check if&nbsp;it can be partitioned into two parts such that the sum of elements in both parts&nbsp;is the same.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> N = 4
+arr = {1, 5, 11, 5}
+<strong>Output:</strong> YES
+<strong>Explaination:</strong> 
+The two parts are {1, 5, 5} and {11}.</span>
+</pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> N = 3
+arr = {1, 3, 5}
+<strong>Output:</strong> NO
+<strong>Explaination: </strong>This array can never be 
+partitioned into two such parts.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You do not need to read input or print anything. Your task is to complete the function <strong>equalPartition()</strong> which takes the value N and the array as input parameters and returns 1 if the partition is possible. Otherwise, returns 0.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N*sum of elements)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(N*sum of elements)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 100<br>
+1 ≤ arr[i] ≤ 1000</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Partition Equal Subset Sum - GFG/partition-equal-subset-sum.cpp b/Partition Equal Subset Sum - GFG/partition-equal-subset-sum.cpp
new file mode 100644
index 0000000..4c01c3a
--- /dev/null
+++ b/Partition Equal Subset Sum - GFG/partition-equal-subset-sum.cpp	
@@ -0,0 +1,57 @@
+// { Driver Code Starts
+// Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+
+
+class Solution{
+public:
+   int dp[101][10001];
+int subset_sum(int n, int arr[], int tgt) {
+if (n == 0)
+return 0;
+if (tgt == 0)
+return 1;
+if (dp[n][tgt] != -1)
+return dp[n][tgt];
+if (arr[n - 1] <= tgt)
+return dp[n][tgt] = subset_sum(n - 1, arr, tgt - arr[n - 1]) || subset_sum(n - 1, arr, tgt);
+return dp[n][tgt] = subset_sum(n - 1, arr, tgt);
+}
+int equalPartition(int N, int arr[])
+{
+int sum = 0;
+for (int i = 0; i < N; i++ )
+sum += arr[i];
+memset(dp, -1, sizeof(dp));
+if (sum % 2 != 0)
+return 0;
+else
+return subset_sum(N, arr, sum / 2);}
+};
+
+
+// { Driver Code Starts.
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int N;
+        cin>>N;
+        int arr[N];
+        for(int i = 0;i < N;i++)
+            cin>>arr[i];
+        
+        Solution ob;
+        if(ob.equalPartition(N, arr))
+            cout<<"YES\n";
+        else
+            cout<<"NO\n";
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Positive Negative Pair - GFG/README.md b/Positive Negative Pair - GFG/README.md
new file mode 100644
index 0000000..567a619
--- /dev/null
+++ b/Positive Negative Pair - GFG/README.md	
@@ -0,0 +1,40 @@
+# Positive Negative Pair
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array of distinct integers, find all the pairs having both negative and positive values of a number in the array.</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 = 8
+arr[] = {1,3,6,-2,-1,-3,2,7}
+<strong>Output: </strong>-1 1 -3 3 -2 2<strong>
+Explanation: </strong>1, 3 and 2 are present 
+pairwise postive and negative. 6 and 
+7 have no pair.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>n = 3
+arr[] = {3,2,1}
+<strong>Output: </strong>0<strong>
+Explanation: </strong>No such pair exists so the 
+output is 0.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You do not need to read input or print anything. Complete the function <strong>findPairs()</strong> which takes the array A[] and the size of the array, n, as input parameters and returns a&nbsp;list&nbsp;of integers denoting the pairs. The pair that appears first in A[] should appear first in the returning list and within the pair the negative integer should appear before positive integer. Return an empty integer list if no such pair exists. </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;= n&nbsp;&lt;= 10<sup>6</sup><br>
+-10<sup>6</sup> &lt;= arr[i] &lt;= 10<sup>6</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Positive Negative Pair - GFG/positive-negative-pair.cpp b/Positive Negative Pair - GFG/positive-negative-pair.cpp
new file mode 100644
index 0000000..5ee111c
--- /dev/null
+++ b/Positive Negative Pair - GFG/positive-negative-pair.cpp	
@@ -0,0 +1,69 @@
+// { Driver Code Starts
+// Initial function template for C++
+
+#include <bits/stdc++.h>
+#include <unordered_map>
+#include <math.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+// User function template for C++
+
+class Solution{
+  public:
+    //Function to return list containing all the pairs having both
+    //negative and positive values of a number in the array.
+    vector <int> findPairs(int arr[], int n) 
+    {
+         vector <int> ans;
+       unordered_map<int,int> m;
+       for(int i=0;i<n;i++)
+       {
+           int k = -1 * arr[i];
+           if(m.count(k) == 1)
+           {
+               if(k<0)
+               {
+                   ans.push_back(k);
+                   ans.push_back(arr[i]);
+               }
+               else
+               {
+                   ans.push_back(arr[i]);
+                   ans.push_back(k);
+               }
+               
+               
+           }
+           else
+           m[arr[i]]++;
+       }
+       return ans;
+    }
+};
+
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+        int arr[n];
+        for (int i = 0; i < n; i++) cin >> arr[i];
+        Solution obj;
+        vector <int> res = obj.findPairs(arr, n);
+    	if(res.size()!=0)
+    	{
+    		for (int i : res) 
+            	cout << i << " ";
+        	cout << endl;	
+    	}
+    	else
+    		cout<<0<<endl;
+    }
+
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Predecessor and Successor - GFG/README.md b/Predecessor and Successor - GFG/README.md
new file mode 100644
index 0000000..2e59c26
--- /dev/null
+++ b/Predecessor and Successor - GFG/README.md	
@@ -0,0 +1,33 @@
+# Predecessor and Successor
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">There is BST given with root node with key part as integer only.&nbsp;You need to find the inorder successor and predecessor of a given key. In case, if the either of predecessor or successor is not found print -1.</span></p>
+
+<p><span style="font-size:18px"><strong>Input:</strong><br>
+The first line of input contains an integer T denoting the number of test cases. Then T test cases follow. Each test case contains n denoting the number of edges of the BST. The next line contains the edges of the BST. The last line contains the key.</span></p>
+
+<p><span style="font-size:18px"><strong>Output:</strong><br>
+Print the predecessor followed by successor for the given key. If the predecessor or successor is not found print -1.</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1&lt;=T&lt;=100<br>
+1&lt;=n&lt;=100<br>
+1&lt;=data of node&lt;=100<br>
+1&lt;=key&lt;=100</span></p>
+
+<p><span style="font-size:18px"><strong>Example:<br>
+Input:</strong><br>
+2<br>
+6<br>
+50 30 L 30 20 L 30 40 R 50 70 R 70 60 L 70 80 R<br>
+65<br>
+6<br>
+50 30 L 30 20 L 30 40 R 50 70 R 70 60 L 70 80 R<br>
+100</span></p>
+
+<p><span style="font-size:18px"><strong>Output:</strong><br>
+60 70<br>
+80 -1</span><br>
+&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Predecessor and Successor - GFG/predecessor-and-successor.cpp b/Predecessor and Successor - GFG/predecessor-and-successor.cpp
new file mode 100644
index 0000000..1c7c749
--- /dev/null
+++ b/Predecessor and Successor - GFG/predecessor-and-successor.cpp	
@@ -0,0 +1,134 @@
+// { Driver Code Starts
+// C++ program to find predecessor and successor in a BST
+#include <iostream>
+using namespace std;
+
+// BST Node
+struct Node
+{
+	int key;
+	struct Node *left;
+	struct Node *right;
+	
+	Node(int x){
+	    key = x;
+	    left = NULL;
+	    right = NULL;
+	}
+};
+
+int key=0;
+// This function finds predecessor and successor of key in BST.
+// It sets pre and suc as predecessor and successor respectively
+void findPreSuc(Node* root, Node*& pre, Node*& suc, int key);
+
+ void insert(struct Node *root,int n1,int n2,char lr)
+ {
+     if(root==NULL)
+        return;
+     if(root->key==n1)
+     {
+         switch(lr)
+         {
+          case 'L': root->left=new Node(n2);
+                    break;
+          case 'R': root->right=new Node(n2);
+                    break;
+         }
+     }
+     else
+     {
+         insert(root->left,n1,n2,lr);
+         insert(root->right,n1,n2,lr);
+     }
+ }
+// Driver program to test above functions
+int main()
+{
+    /* Let us construct the tree shown in above diagram */
+    int t,k;
+    cin>>t;
+    while(t--)
+    {
+    int n;
+    cin>>n;
+    struct Node *root=NULL;
+    Node *pre=NULL;
+    Node *suc=NULL;
+    while(n--)
+    {
+        char lr;
+        int n1,n2;
+        cin>>n1>>n2;
+        cin>>lr;
+        if(root==NULL)
+        {
+            root=new Node(n1);
+            switch(lr){
+                    case 'L': root->left=new Node(n2);
+                    break;
+                    case 'R': root->right=new Node(n2);
+                    break;
+                    }
+        }
+        else
+        {
+            insert(root,n1,n2,lr);
+        }
+    }
+   // Inorder(root);
+    //Node * target =ptr;
+    //printkdistanceNode(root, target, k);
+    //cout<<endl;
+    cin>>key;
+    findPreSuc(root, pre, suc, key);
+	if (pre != NULL)
+	cout << pre->key;
+	else
+	cout << "-1";
+
+	if (suc != NULL)
+	cout <<" "<<suc->key<<endl;
+	else
+	cout << " "<<"-1"<<endl;
+    }
+	return 0;
+}// } Driver Code Ends
+
+
+/* BST Node
+struct Node
+{
+	int key;
+	struct Node *left, *right;
+};
+*/
+
+// This function finds predecessor and successor of key in BST.
+// It sets pre and suc as predecessor and successor respectively
+void findPreSuc(Node* root, Node*& pre, Node*& suc, int key)
+{
+
+// Your code goes here
+if(!root)
+{
+    return;
+}
+
+if(root->key == key)
+{
+    findPreSuc(root->left,pre,suc,key);
+    findPreSuc(root->right,pre,suc,key);
+}
+else if(root->key > key)
+{
+    suc = root;
+    findPreSuc(root->left,pre,suc,key);
+}
+else
+{
+    pre = root;
+    findPreSuc(root->right,pre,suc,key);
+}
+
+}
\ No newline at end of file
diff --git a/Queries on Strings - GFG/README.md b/Queries on Strings - GFG/README.md
new file mode 100644
index 0000000..1492765
--- /dev/null
+++ b/Queries on Strings - GFG/README.md	
@@ -0,0 +1,35 @@
+# Queries on Strings
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a string <strong>str</strong>&nbsp;you have to answer several queries on that string. In each query you will be provided two values <strong>L</strong> and <strong>R</strong> and you have to find the number of <strong>distinct</strong> characters in the sub string from index <strong>L</strong> to index <strong>R</strong>&nbsp;(inclusive) of the original string.</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>str = "abcbaed",
+Query = {{1,4},{2,4},{1,7}}
+<strong>Output: </strong>{3,2,5}
+<strong>Explanation: </strong>For the first query distinct 
+characters from [1, 4] are a, b and c.
+For the second query distinct characters from
+[2, 4] are b and c.
+For the third query distinct characters from
+[1, 7] are a, b, c, d and e.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read or print anyhting. Your task is to complete the function&nbsp;<strong>SolveQueries()&nbsp;</strong>which takes str and Query as input parameter and returns a list containing answer for each query.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(max(26*length of str, 26 * No of queries))<br>
+<strong>Expected Space Complexity:&nbsp;</strong>O(26 * length of str)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= |str| &lt;= 10<sup>5</sup><br>
+1 &lt;= No of Queries &lt;= 10<sup>4</sup><br>
+1 &lt;= L<sub>i</sub>&nbsp;&lt;= R<sub>i</sub>&nbsp;&lt;= |str|</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Queries on Strings - GFG/queries-on-strings.cpp b/Queries on Strings - GFG/queries-on-strings.cpp
new file mode 100644
index 0000000..d3f431a
--- /dev/null
+++ b/Queries on Strings - GFG/queries-on-strings.cpp	
@@ -0,0 +1,48 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution {
+public:
+	vector<int>SolveQueris(string str, vector<vector<int>>Query){
+	 vector<int> dp[26];
+    for(int i = 0;i<str.size();i++) dp[str[i]-'a'].push_back(i+1);
+    
+    vector<int>res;
+    for(auto a : Query){
+        int ct = 0;
+        for(int i =0;i<26;i++){
+            if(dp[i].size() == 0) continue;
+            auto t = lower_bound(dp[i].begin(), dp[i].end(), a[0]);
+            if(*t >= a[0] && *t <= a[1]) ct++;
+        }
+        res.push_back(ct);
+    }
+    return res;
+	    // Code here
+	}
+};
+
+// { Driver Code Starts.
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		string str;
+		cin >> str;
+		int q;
+		cin >> q;
+		vector<vector<int>>Query;
+		for(int i = 0; i < q; i++){
+			int l, r;
+			cin >> l >> r;
+			Query.push_back({l, r});
+		}
+		Solution obj;
+		vector<int> ans = obj.SolveQueris(str, Query);
+		for(auto i: ans)cout << i << " ";
+		cout << "\n";
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Queue using two Stacks - GFG/README.md b/Queue using two Stacks - GFG/README.md
new file mode 100644
index 0000000..dd8eeef
--- /dev/null
+++ b/Queue using two Stacks - GFG/README.md	
@@ -0,0 +1,57 @@
+# Queue using two Stacks
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Implement a Queue using 2 stacks<strong> s1</strong> and<strong> s2</strong> .<br>
+A Query <strong>Q</strong> is of 2 Types<br>
+<strong>(i)</strong> 1 x (a query of this type means&nbsp;&nbsp;pushing <strong>'x'</strong> into the queue)<br>
+<strong>(ii)</strong> 2 &nbsp; (a query of this type means to pop&nbsp;element from queue and print the poped element)</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">5
+1 2 1 3 2 1 4 2
+
+<strong>Output: 
+</strong>2&nbsp;3
+<strong>
+Explanation: 
+</strong>In the first testcase
+1 2 the queue will be {2}
+1 3 the queue will be {2 3}
+2 &nbsp; poped element will be 2 the queue 
+&nbsp;   will be {3}
+1 4 the queue will be {3 4}
+2 &nbsp; poped element will be 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
+1 2 2 2 1 4
+
+<strong>Output: 
+</strong>2&nbsp;-1
+<strong>
+Explanation: 
+</strong>In the second testcase&nbsp;
+1 2&nbsp;the queue will be {2}
+2&nbsp; &nbsp;poped element will be 2 and 
+&nbsp;   then the queue will be empty
+2&nbsp; &nbsp;the queue is empty and hence -1
+1 4&nbsp;the queue will be {4}.</span></pre>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong><br>
+<span style="font-size:18px">You are required to complete the two methods <strong>push</strong> which take one argument an integer <strong>'x'</strong>&nbsp;to be pushed into the queue and <strong>pop</strong> which returns a integer&nbsp;poped out from other queue(-1 if the queue is empty).&nbsp;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</strong> : O(1) for&nbsp;<strong>push()&nbsp;</strong>and&nbsp;O(N) for&nbsp;<strong>pop() </strong>or&nbsp;O(N) for&nbsp;<strong>push()&nbsp;</strong>and&nbsp;O(1) for&nbsp;<strong>pop() </strong>&nbsp;<br>
+<strong>Expected Auxilliary Space </strong>:&nbsp;O(1).</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;=<strong> </strong>Q &lt;= 100<br>
+1 &lt;= x &lt;= 100</span></p>
+
+<p><span style="font-size:18px">Note: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.</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Queue using two Stacks - GFG/queue-using-two-stacks.cpp b/Queue using two Stacks - GFG/queue-using-two-stacks.cpp
new file mode 100644
index 0000000..adad3f5
--- /dev/null
+++ b/Queue using two Stacks - GFG/queue-using-two-stacks.cpp	
@@ -0,0 +1,82 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+
+using namespace std;
+
+class StackQueue{
+private:
+    stack<int> s1;
+    stack<int> s2;
+public:
+    void push(int B);
+    int pop();
+
+};
+int main()
+{
+
+    int T;
+    cin>>T;
+    while(T--)
+    {
+        StackQueue *sq = new StackQueue();
+
+        int Q;
+        cin>>Q;
+        while(Q--){
+        int QueryType=0;
+        cin>>QueryType;
+        if(QueryType==1)
+        {
+            int a;
+            cin>>a;
+            sq->push(a);
+        }else if(QueryType==2){
+            cout<<sq->pop()<<" ";
+
+        }
+        }
+        cout<<endl;
+    }
+
+
+}
+// } Driver Code Ends
+
+
+/* The structure of the class is
+class StackQueue{
+private:   
+    // These are STL stacks ( http://goo.gl/LxlRZQ )
+    stack<int> s1;
+    stack<int> s2;
+public:
+    void push(int);
+    int pop();
+}; */
+
+//Function to push an element in queue by using 2 stacks.
+void StackQueue :: push(int x)
+{
+    s1.push(x);
+    return;
+}
+
+//Function to pop an element from queue by using 2 stacks.
+int StackQueue :: pop()
+{
+    if(s1.empty()){
+        return -1;
+    }
+    while(s1.empty() == false){
+        s2.push(s1.top());
+        s1.pop();
+    }
+    int val = s2.top();
+    s2.pop();
+    while(s2.empty() == false){
+        s1.push(s2.top());
+        s2.pop();
+    }
+    return val;
+}
\ No newline at end of file
diff --git a/Rank The Permutations - GFG/README.md b/Rank The Permutations - GFG/README.md
new file mode 100644
index 0000000..a55029a
--- /dev/null
+++ b/Rank The Permutations - GFG/README.md	
@@ -0,0 +1,44 @@
+# Rank The Permutations
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a string, find the rank of the string amongst its permutations sorted lexicographically.&nbsp;</span><br>
+<br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+S = "abc"</span>
+<span style="font-size:18px"><strong>Output:</strong>
+1</span>
+<strong><span style="font-size:18px">Explanation:</span></strong>
+<span style="font-size:18px">The order permutations with letters 
+'a', 'c', and 'b' : 
+abc
+acb
+bac
+bca
+cab
+cba</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+S = "acb"</span>
+<span style="font-size:18px"><strong>Output:</strong>
+2</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&nbsp;task is to complete the function&nbsp;<strong>findRank()</strong>&nbsp;which takes the string&nbsp;<strong>S</strong>&nbsp;as input parameter&nbsp;and returns the rank of the string amongst its permutations.</span><br>
+<span style="font-size:18px">It is guaranteed no characters are repeated in the string.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(|S|*26)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(|S|)</span><br>
+<span style="font-size:18px"><strong>Note:</strong>&nbsp;|S| represents the length of string S.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong></span><br>
+<span style="font-size:18px">1 ≤ |S| ≤ 18</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Rank The Permutations - GFG/rank-the-permutations.cpp b/Rank The Permutations - GFG/rank-the-permutations.cpp
new file mode 100644
index 0000000..d740a81
--- /dev/null
+++ b/Rank The Permutations - GFG/rank-the-permutations.cpp	
@@ -0,0 +1,49 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function template for C++
+
+class Solution{
+  public:
+   long long findRank(string str)
+   {
+      long long fact[19];
+      fact[0]=1;
+      fact[1]=1;
+      long long n=str.size(),ans=0;
+      
+      for(int i=2;i<=18;i++)
+      {
+          fact[i]=i*fact[i-1];
+      }
+      
+      for(int i=0;i<n;i++)
+      {
+          int count=0;
+          for(int j=i+1;j<n;j++)
+          {
+              if(str[i]>str[j])
+              count++;
+          }
+          
+          ans+=count*fact[n-1-i];
+      }
+      
+      return ans+1;
+   }
+};
+
+// { Driver Code Starts.
+int main(){
+    int T;
+    cin>>T;
+    while(T--){
+        string s;
+        cin>>s;
+        Solution obj;
+        long long ans = obj.findRank(s);
+        cout<<ans<<endl;
+    }
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Rat in a Maze Problem - I - GFG/README.md b/Rat in a Maze Problem - I - GFG/README.md
new file mode 100644
index 0000000..ebd8a07
--- /dev/null
+++ b/Rat in a Maze Problem - I - GFG/README.md	
@@ -0,0 +1,47 @@
+# Rat in a Maze Problem - I
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Consider a rat placed at <strong>(0, 0)</strong> in a square matrix<strong> </strong>of order <strong>N * N</strong>. It has to reach the destination at <strong>(N - 1, N - 1)</strong>. Find all possible paths that the rat can take to reach from source to destination. The directions in which the rat can move are <strong>'U'(up)</strong>, <strong>'D'(down)</strong>, <strong>'L' (left)</strong>, <strong>'R' (right)</strong>. Value 0 at a cell in the matrix represents that it is blocked and rat cannot move to it while value 1 at a cell in the matrix represents that&nbsp;rat&nbsp;can be travel&nbsp;through it.<br>
+<strong>Note</strong>: In a path, no cell can be visited more than one time.</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
+m[][] = {{1, 0, 0, 0},
+         {1, 1, 0, 1}, 
+         {1, 1, 0, 0},
+         {0, 1, 1, 1}}
+<strong>Output:</strong>
+DDRDRR DRDDRR</span>
+<span style="font-size:18px"><strong>Explanation</strong>:
+The rat can reach the destination at 
+(3, 3) from (0, 0) by two paths - DRDDRR 
+and DDRDRR, when printed in sorted order 
+we get DDRDRR DRDDRR.</span></pre>
+
+<div><span style="font-size:18px"><strong>Example 2:</strong></span></div>
+
+<pre><span style="font-size:18px"><strong>Input</strong>:
+N = 2
+m[][] = {{1, 0},
+         {1, 0}}
+<strong>Output:</strong>
+-1</span>
+<span style="font-size:18px"><strong>Explanation</strong>:
+No path exists and destination cell is 
+blocked.</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. Complete the function <strong>printPath()&nbsp;</strong>which takes <strong>N </strong>and 2D&nbsp;array<strong> m[ ][ ]</strong><strong> </strong>as input parameters and returns the list of&nbsp;paths in lexicographically increasing order.</span>&nbsp;<br>
+<span style="font-size:18px"><strong>Note:</strong>&nbsp;In case of no path, return an empty list. The driver will output <strong>"-1"</strong> automatically.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O((3<sup>N</sup><sup>^2</sup>)).<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(L * X), L = length of the path, X = number of paths.</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+2 ≤ N ≤ 5<br>
+0 ≤ m[i][j] ≤ 1</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Rat in a Maze Problem - I - GFG/rat-in-a-maze-problem-i.cpp b/Rat in a Maze Problem - I - GFG/rat-in-a-maze-problem-i.cpp
new file mode 100644
index 0000000..ce31e96
--- /dev/null
+++ b/Rat in a Maze Problem - I - GFG/rat-in-a-maze-problem-i.cpp	
@@ -0,0 +1,97 @@
+// { Driver Code Starts
+// Initial template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+// User function template for C++
+
+class Solution{
+    public:
+    
+    void solve(vector<string>& ans,int row,int col,vector<vector<int>> &m, int n,string a)
+    {
+        if(row == n-1 && col == n-1 && m[row][col] == 1)
+        {
+            ans.push_back(a);
+            return;
+        }
+        
+        if(row>=0 && row<n && col>=0 && col<n && m[row][col] == 1)
+        {
+            m[row][col] = -1;
+            
+             if(row < n-1 && m[row+1][col] == 1)
+            {
+                a += "D";
+                solve(ans,row+1,col,m,n,a);
+                a.pop_back();
+            }
+             if(col>0 && m[row][col-1] == 1)
+            {
+                a += "L";
+                solve(ans,row,col-1,m,n,a);
+                a.pop_back();
+            }
+           
+            if(col < n-1 && m[row][col+1] == 1)
+            {
+                a += "R";
+                solve(ans,row,col+1,m,n,a);
+                a.pop_back();
+            }
+             if(row>0 &&m[row-1][col] == 1)
+            {
+                a += "U";
+                solve(ans,row-1,col,m,n,a);
+                a.pop_back();
+            }
+           
+           
+            
+            m[row][col] = 1;
+        }
+    
+    }
+    
+    
+    
+    vector<string> findPath(vector<vector<int>> &m, int n) {
+        // Your code goes here
+        vector<string> ans;
+        string a = "";
+        solve(ans,0,0,m,n,a);
+     //   sort(ans.begin(),ans.end());
+        return ans;
+    }
+};
+
+    
+
+
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+        vector<vector<int>> m(n, vector<int> (n,0));
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                cin >> m[i][j];
+            }
+        }
+        Solution obj;
+        vector<string> result = obj.findPath(m, n);
+        if (result.size() == 0)
+            cout << -1;
+        else
+            for (int i = 0; i < result.size(); i++) cout << result[i] << " ";
+        cout << endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Rearrange Geek and his Classmates - GFG/README.md b/Rearrange Geek and his Classmates - GFG/README.md
new file mode 100644
index 0000000..be1d414
--- /dev/null
+++ b/Rearrange Geek and his Classmates - GFG/README.md	
@@ -0,0 +1,46 @@
+# Rearrange Geek and his Classmates
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Geek and his classmates are playing a prank on their Computer Science teacher. They change places every time the teacher turns to look at the blackboard.&nbsp;</span></p>
+
+<p><span style="font-size:18px">Each of the <strong>N</strong> students in the class can be identified by a unique roll number <strong>X </strong>and each desk has a number <strong>i </strong>associated with it. Only one student can sit on one desk.&nbsp;<br>
+Each time the teacher turns her back, a student with roll number X sitting on desk number i gets up and takes the place of the student with roll number i.</span></p>
+
+<p><span style="font-size:18px">If the current position of <strong>N</strong> students in the class is given to you in an array, such that<strong> i</strong> is the desk number and <strong>a[i]</strong> is the roll number of the student sitting on the desk, can you modify <strong>a[ ] </strong>to represent the next position of all the students ?&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 = 6
+a[] = {0, 5, 1, 2, 4, 3}
+<strong>Output: </strong>0 3 5 1 4 2
+<strong>Explanation: </strong>After reshuffling, the modified 
+position of all the students would be 
+{</span><span style="font-size:18px">0, 3, 5, 1, 4, 2}.</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
+a[] = {4, 3, 2, 1, 0}
+<strong>Output:</strong> 0 1 2 3 4 
+<strong>Explanation:</strong> </span><span style="font-size:18px">After reshuffling, the modified 
+position of all the students would be 
+{</span><span style="font-size:18px">0, 1, 2, 3, 4}.</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>prank() </strong>which takes the array <strong>a[ ]</strong> and its size <strong>N</strong> as input parameters and modifies the array in-place to reflect the new arrangement.</span></p>
+
+<p><br>
+<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><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>5</sup><br>
+0 ≤ a[i] ≤ N-1</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Rearrange Geek and his Classmates - GFG/rearrange-geek-and-his-classmates.cpp b/Rearrange Geek and his Classmates - GFG/rearrange-geek-and-his-classmates.cpp
new file mode 100644
index 0000000..985ed45
--- /dev/null
+++ b/Rearrange Geek and his Classmates - GFG/rearrange-geek-and-his-classmates.cpp	
@@ -0,0 +1,49 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function template for C++
+
+
+class Solution {
+  public:
+    void prank(long long a[], int n){
+       
+       int ar2[n]; 
+       for(int i=0;i<n;i++)
+       {
+           ar2[i] = a[a[i]];
+       }
+       
+       for(int i=0;i<n;i++)
+       {
+           a[i] = ar2[i];
+       }
+    }
+};
+
+// { Driver Code Starts.
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        long long a[n];
+        for(int i = 0 ;i<n;i++){
+            cin>>a[i];
+        }
+        Solution ob;
+        ob.prank(a,n);
+
+        for(int i = 0;i<n;i++)
+            cout<<a[i]<<" ";
+        cout<<"\n";
+    }
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Remove leading zeros from an IP address - GFG/README.md b/Remove leading zeros from an IP address - GFG/README.md
new file mode 100644
index 0000000..3c5a0fc
--- /dev/null
+++ b/Remove leading zeros from an IP address - GFG/README.md	
@@ -0,0 +1,38 @@
+# Remove leading zeros from an IP address
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an IP address, remove leading zeros from the IP address. Note that our IP address here can be a little different. It can have numbers greater than 255. Also, it does not necessarily have 4 numbers. The count can be lesser/more.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+S = "100.020.003.400"
+<strong>Output:</strong> 100.20.3.400</span><span style="font-size:18px">
+<strong>Explanation</strong>: The leading zeros are removed
+from 20 and 3.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong>: 
+S = "100.000.010.0999"
+<strong>Output:</strong> 100.0.10.999
+<strong>Explanation</strong>: The leading zeros are removed
+from 0, 10 and 999.</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>newIPAdd()&nbsp;</strong>which takes the string S representing the IP address as input and returns a&nbsp;string representing the resultant IP address.&nbsp;</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(|S|).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(|S|).</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1&lt;=|S|&lt;=1000</span></p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Remove leading zeros from an IP address - GFG/remove-leading-zeros-from-an-ip-address.cpp b/Remove leading zeros from an IP address - GFG/remove-leading-zeros-from-an-ip-address.cpp
new file mode 100644
index 0000000..f7045ce
--- /dev/null
+++ b/Remove leading zeros from an IP address - GFG/remove-leading-zeros-from-an-ip-address.cpp	
@@ -0,0 +1,58 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+
+class Solution
+{
+ public:
+ void solve(string &temp)
+ {
+     while(temp.size()!=1)
+     {
+         if(temp[0]=='0')
+         temp.erase(temp.begin());
+         else
+         break;
+     }
+ }
+   string newIPAdd (string s)
+   {
+       int left=0;
+       int right=0;
+       string ans="";
+       while(right<s.size())
+       {
+           if(s[right]!='.')
+           right++;
+           else
+           {
+               string temp= s.substr(left,right-left);
+               solve(temp);
+               ans+=temp;
+               ans+=".";
+               left=right+1;
+               right++;
+           }
+       }
+       string temp= s.substr(left,right-left);
+       solve(temp);
+       ans+=temp;
+       return ans;
+   }
+};
+// { Driver Code Starts.
+int main()
+{
+    int t; cin >> t;
+    while (t--)
+    {
+        string s; cin >> s;
+        Solution ob;
+        cout <<ob.newIPAdd (s) << endl;
+    }
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Return two prime numbers - GFG/README.md b/Return two prime numbers - GFG/README.md
new file mode 100644
index 0000000..925099b
--- /dev/null
+++ b/Return two prime numbers - GFG/README.md	
@@ -0,0 +1,33 @@
+# Return two prime numbers
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an even number <strong>N </strong>(greater than 2), return two prime numbers whose sum will be equal to given number. There are several combinations possible. Print only the pair whose&nbsp;minimum value is the&nbsp;smallest among all the minimum values of pairs and print the minimum element first.</span></p>
+
+<p><span style="font-size:18px"><strong>NOTE:</strong>&nbsp;A solution will always exist,&nbsp;read&nbsp;<a href="https://en.wikipedia.org/wiki/Goldbach%27s_conjecture" rel="nofollow" target="_blank">Goldbachs conjecture</a>.</span><span style="font-size:18px">&nbsp;</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> N = 74
+<strong>Output:</strong> 3 71
+<strong>Explaination:</strong> There are several possibilities 
+like 37 37. But the minimum value of this pair 
+is 3 which is smallest among all possible 
+minimum values of all the pairs.</span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> 4
+<strong>Output:</strong> 2 2
+<strong>Explaination:</strong> This is the only possible 
+prtitioning of 4.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You do not need to read input or print anything. Your task is to complete the function <strong>primeDivision()</strong> which takes N as input parameter and returns the partition satisfying the condition.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N*log(logN))<br>
+<strong>Expected Auxiliary Space: </strong>O(N)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>4</sup>&nbsp;&nbsp;</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Return two prime numbers - GFG/return-two-prime-numbers.cpp b/Return two prime numbers - GFG/return-two-prime-numbers.cpp
new file mode 100644
index 0000000..2b6ebf1
--- /dev/null
+++ b/Return two prime numbers - GFG/return-two-prime-numbers.cpp	
@@ -0,0 +1,46 @@
+// { Driver Code Starts
+// Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+class Solution{
+public:
+   bool prime(int a)
+   {
+       int k=sqrt(a);
+       for(int i=2;i<=k;i++)
+       {
+           if(a%i==0)
+           return false;
+       }
+       return true;
+   }
+   vector<int> primeDivision(int N){
+       for(int i=2;i<=N-2;i++)
+       {
+           if(prime(i) && prime(N-i))
+           {
+               return {i,N-i};
+           }
+       }
+       return {};
+   }
+};
+// { Driver Code Starts.
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int N;
+        cin>>N;
+        
+        Solution ob;
+        vector<int> ans = ob.primeDivision(N);
+        cout<<ans[0]<<" "<<ans[1]<<"\n";
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Reverse First K elements of Queue - GFG/README.md b/Reverse First K elements of Queue - GFG/README.md
new file mode 100644
index 0000000..dd08643
--- /dev/null
+++ b/Reverse First K elements of Queue - GFG/README.md	
@@ -0,0 +1,57 @@
+# Reverse First K elements of Queue
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an integer <strong>K </strong>and a&nbsp;<a href="http://www.geeksforgeeks.org/queue-data-structure/" target="_blank">queue</a>&nbsp;of integers, we need to reverse the order of the first<strong> K</strong> elements of the queue, leaving the other elements in the same relative order.</span></p>
+
+<p><span style="font-size:18px">Only following standard operations are allowed on queue.</span></p>
+
+<ul>
+	<li><span style="font-size:18px">enqueue(x) : Add an item x to rear of queue</span></li>
+	<li><span style="font-size:18px">dequeue() : Remove an item from front of queue</span></li>
+	<li><span style="font-size:18px">size() : Returns number of elements in queue.</span></li>
+	<li><span style="font-size:18px">front() : Finds front item.</span></li>
+</ul>
+
+<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">5 3
+1 2 3 4 5
+
+<strong>Output: 
+</strong>3 2 1 4 5
+<strong>
+Explanation: 
+</strong>After reversing the given
+input from the 3rd position the resultant
+output will be 3 2 1 4 5.
+</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 4
+4 3 2 1
+
+<strong>Output: 
+</strong>1 2 3 4
+<strong>
+Explanation: 
+</strong>After reversing the given
+input from the 4th position the resultant
+output will be 1 2 3 4.</span></pre>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong><br>
+<span style="font-size:18px"><strong>Complete </strong>the <strong>provided function</strong> <strong>modifyQueue </strong>that takes <strong>queue and k</strong> as <strong>parameters </strong>and <strong>returns </strong>a <strong>modified </strong>queue. 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</strong> : O(n)<br>
+<strong>Expected Auxilliary Space </strong>: O(n)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 1000<br>
+1 &lt;= K &lt;= N</span></p>
+
+<p><span style="font-size:18px"><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.</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Reverse First K elements of Queue - GFG/reverse-first-k-elements-of-queue.cpp b/Reverse First K elements of Queue - GFG/reverse-first-k-elements-of-queue.cpp
new file mode 100644
index 0000000..f9e3514
--- /dev/null
+++ b/Reverse First K elements of Queue - GFG/reverse-first-k-elements-of-queue.cpp	
@@ -0,0 +1,55 @@
+// { Driver Code Starts
+// Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+queue<int> modifyQueue(queue<int> q, int k);
+int main() {
+    int t;
+    cin >> t;
+    while (t-- > 0) {
+        int n, k;
+        cin >> n >> k;
+        queue<int> q;
+        while (n-- > 0) {
+            int a;
+            cin >> a;
+            q.push(a);
+        }
+        queue<int> ans = modifyQueue(q, k);
+        while (!ans.empty()) {
+            int a = ans.front();
+            ans.pop();
+            cout << a << " ";
+        }
+        cout << endl;
+    }
+}// } Driver Code Ends
+
+
+// User function Template for C++
+
+// Function to reverse first k elements of a queue.
+queue<int> modifyQueue(queue<int> q, int k) {
+    // add code here.
+    if(k > q.size()) return q;
+    stack<int> s;
+    queue<int> q1;
+    for(int i = 0 ; i < k ; i++){
+        s.push(q.front());
+        q.pop();
+    }
+    while(!q.empty()){
+        q1.push(q.front());
+        q.pop();
+    }
+    while(!s.empty()){
+        q.push(s.top());
+        s.pop();
+    }
+    while(!q1.empty()){
+        q.push(q1.front());
+        q1.pop();
+    }
+    return q;
+}
\ No newline at end of file
diff --git a/Reverse words in a given string - GFG/README.md b/Reverse words in a given string - GFG/README.md
new file mode 100644
index 0000000..a0dc126
--- /dev/null
+++ b/Reverse words in a given string - GFG/README.md	
@@ -0,0 +1,41 @@
+# Reverse words in a given string
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a String&nbsp;S, reverse the&nbsp;string without reversing its&nbsp;individual words. Words are separated by&nbsp;dots.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>S = i.like.this.program.very.much
+<strong>Output: </strong>much.very.program.this.like.i<strong>
+Explanation: </strong>After reversing the whole
+string(not individual words), the input
+string becomes
+much.very.program.this.like.i</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>S = pqr.mno
+<strong>Output: </strong>mno.pqr<strong>
+Explanation: </strong>After reversing the whole
+string , the input string becomes
+mno.pqr</span>
+</pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You dont need to read input or print anything. Complete the function<strong>&nbsp;reverseWords()</strong> which takes string S as input parameter and returns a string containing the words in reversed order. Each word in the returning string should also be separated by '.'&nbsp;</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(|S|)<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(|S|)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= |S| &lt;= 2000</span></p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Reverse words in a given string - GFG/reverse-words-in-a-given-string.cpp b/Reverse words in a given string - GFG/reverse-words-in-a-given-string.cpp
new file mode 100644
index 0000000..48717b0
--- /dev/null
+++ b/Reverse words in a given string - GFG/reverse-words-in-a-given-string.cpp	
@@ -0,0 +1,48 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+
+class Solution
+{
+   public:
+   string reverseWords(string S) 
+   { 
+       vector<string> p;
+       string temp="";
+       for(int i=0;i<S.length();i++){
+           if(S[i]=='.'){
+               p.push_back(temp);
+               temp="";
+               continue;
+           }
+           else{
+               temp+=S[i];
+           }
+       }
+       p.push_back(temp);
+       string a="";
+       reverse(p.begin(),p.end());
+       for(auto i : p){
+           a+=i;
+           a+='.';
+       }
+       a.pop_back();
+       return a;
+   } 
+};
+
+// { Driver Code Starts.
+int main() 
+{
+    int t;
+    cin >> t;
+    while (t--) 
+    {
+        string s;
+        cin >> s;
+        Solution obj;
+        cout<<obj.reverseWords(s)<<endl;
+    }
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Rotate by 90 degree - GFG/README.md b/Rotate by 90 degree - GFG/README.md
new file mode 100644
index 0000000..3a07792
--- /dev/null
+++ b/Rotate by 90 degree - GFG/README.md	
@@ -0,0 +1,31 @@
+# Rotate by 90 degree
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a<strong> </strong>square&nbsp;<strong>matrix[][]</strong> of size <strong>N x N</strong>. The task is to rotate it by<strong> 90 degrees in an anti-clockwise</strong> direction without using any extra space.</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
+matrix[][] = [[1 2 3],
+&nbsp;             [4 5 6],
+&nbsp;             [7 8 9]]
+<strong>Output:</strong>
+3 6 9&nbsp;
+2 5 8&nbsp;
+1 4 7</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You only need to implement the given function <strong>rotate()</strong>. Do not read input, instead use the arguments given in the function.&nbsp;</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N*N)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 50<br>
+1 &lt;= matrix[][] &lt;= 100</span></p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Rotate by 90 degree - GFG/rotate-by-90-degree.cpp b/Rotate by 90 degree - GFG/rotate-by-90-degree.cpp
new file mode 100644
index 0000000..a520284
--- /dev/null
+++ b/Rotate by 90 degree - GFG/rotate-by-90-degree.cpp	
@@ -0,0 +1,67 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include<bits/stdc++.h>
+using namespace std;
+void rotate (vector<vector<int> >& matrix);
+
+
+ // } Driver Code Ends
+//User function template for C++
+
+/* matrix : given input matrix, you are require 
+ to change it in place without using extra space */
+void rotate (vector<vector<int> >& matrix);
+
+
+ // } Driver Code Ends
+//User function template for C++
+
+/* matrix : given input matrix, you are require 
+ to change it in place without using extra space */
+void rotate(vector<vector<int> >& matrix)
+{
+int n = (int) matrix.size();
+int m = (int) matrix[0].size();
+for(int i = 0; i < n; i++){
+
+reverse(matrix[i].begin(), matrix[i].end());
+}
+for(int i = 0; i < n; i++){
+for(int j = i; j < m; j++){
+swap(matrix[i][j], matrix[j][i]);
+}
+
+}
+}
+
+
+// { Driver Code Starts.
+
+int main()
+{
+    int t;
+    cin>>t; 
+    while(t--)
+    {
+        int n;
+        cin>>n; 
+        vector<vector<int> > matrix(n);
+        for(int i=0; i<n; i++)
+        {
+            matrix[i].resize(n);
+            for(int j=0; j<n; j++)
+                cin>>matrix[i][j]; 
+        }
+        rotate(matrix);
+        for (int i = 0; i < n; ++i)
+        {
+            for(int j=0; j<n; j++)
+                cout<<matrix[i][j]<<" ";
+            cout<<"\n";
+        }
+    }
+    return 0;
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Search Pattern (Z-algorithm) - GFG/README.md b/Search Pattern (Z-algorithm) - GFG/README.md
new file mode 100644
index 0000000..6b71d49
--- /dev/null
+++ b/Search Pattern (Z-algorithm) - GFG/README.md	
@@ -0,0 +1,39 @@
+# Search Pattern (Z-algorithm)
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given two strings, one is a text string and other is a pattern string. The task is to print the indexes of all the occurences of pattern&nbsp;string in the text string. For printing, Starting Index of a string should be taken as&nbsp;1.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+S = "batmanandrobinarebat", pat = "bat"
+<strong>Output:</strong> 1 18
+<strong>Explanation</strong>: The string "bat" occurs twice
+in S, one starts are index 1 and the other
+at index 18. </span>
+</pre>
+
+<p><span style="font-size:18px">​<strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input</strong>: 
+S = "abesdu", pat = "edu"
+<strong>Output:</strong> -1
+<strong>Explanation</strong>: There's not substring "edu"
+present in S.</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>search()&nbsp;</strong>which takes the string S and the string pat as inputs and returns an array denoting the start indices (1-based)&nbsp;of substring pat in the string S.&nbsp;<br>
+<strong>Note: </strong>You don't need to return -1 yourself when there are no possible answers, just return an empty list.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(|S|).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(|S|).</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ |S| ≤ 10<sup>5</sup><br>
+1 ≤ |pat| ≤ |S|</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Search Pattern (Z-algorithm) - GFG/search-pattern-zalgorithm.cpp b/Search Pattern (Z-algorithm) - GFG/search-pattern-zalgorithm.cpp
new file mode 100644
index 0000000..cc60796
--- /dev/null
+++ b/Search Pattern (Z-algorithm) - GFG/search-pattern-zalgorithm.cpp	
@@ -0,0 +1,56 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+class Solution
+{
+    public:
+      vector <int> search(string pat, string txt){
+        string s = pat + "#" + txt;
+        int n = s.length();
+        vector<int> lps(n);
+        for(int i=1;i<n;i++){
+            int j = lps[i-1];
+            while(j>0 and s[j]!=s[i]){
+                j = lps[j-1];
+            }
+            if(s[i]==s[j]){
+                j++;
+            }
+            lps[i] = j;
+        }
+        vector<int> ans;
+        for(int i=pat.length()+1;i<n;i++){
+            if(lps[i]==pat.length()){
+                ans.push_back(i-pat.length()-pat.length()+1);
+            }
+        }
+        return ans;
+    }
+     
+};
+
+// { Driver Code Starts.
+int main()
+{
+    int t;
+    cin >> t;
+    while (t--)
+    {
+        string S, pat;
+        cin >> S >> pat;
+        Solution ob;
+        vector <int> res = ob.search(pat, S);
+        if(res.size()==0)
+            cout<<"-1 ";
+        else
+            for (int i : res)
+                cout << i << " ";
+        cout << endl;
+    }
+    return 0;
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Search a node in BST - GFG/README.md b/Search a node in BST - GFG/README.md
new file mode 100644
index 0000000..9414a35
--- /dev/null
+++ b/Search a node in BST - GFG/README.md	
@@ -0,0 +1,49 @@
+# Search a node in BST
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a <strong>Binary Search Tree </strong>and a node value X, find if the node with value X is present in the BST or not.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>         2
+                \
+&nbsp;                81 
+&nbsp;              /    \ 
+&nbsp;            42      87 
+&nbsp;             \       \ 
+&nbsp;              66      90 
+&nbsp;             / 
+&nbsp;           45
+X = 87
+<strong>Output: </strong>1
+<strong>Explanation: </strong>As 87 is present in the
+given nodes , so the output will be
+1.</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>      6
+&nbsp;            \ 
+&nbsp;             8 
+&nbsp;            / \ 
+&nbsp;           7   9
+X = 11
+<strong>Output: </strong>0
+<strong>Explanation: </strong>As 11 is not present in 
+the given nodes , so the output will
+be 0.</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>search()</strong>which returns <strong>true </strong>if the node with <strong>value x</strong> is <strong>present </strong>in the BST<strong>else returns false</strong>.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(Height of the BST)<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1).</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= Number of nodes &lt;= 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Search a node in BST - GFG/search-a-node-in-bst.cpp b/Search a node in BST - GFG/search-a-node-in-bst.cpp
new file mode 100644
index 0000000..cba34d4
--- /dev/null
+++ b/Search a node in BST - GFG/search-a-node-in-bst.cpp	
@@ -0,0 +1,68 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+
+using namespace std;
+
+struct Node {
+    int data;
+    Node *right;
+    Node *left;
+
+    Node(int x) {
+        data = x;
+        right = NULL;
+        left = NULL;
+    }
+};
+
+bool search(Node *root, int x);
+
+Node *insert(Node *tree, int val) {
+    Node *temp = NULL;
+    if (tree == NULL) return new Node(val);
+
+    if (val < tree->data) {
+        tree->left = insert(tree->left, val);
+    } else if (val > tree->data) {
+        tree->right = insert(tree->right, val);
+    }
+
+    return tree;
+}
+
+int main() {
+    int T;
+    cin >> T;
+    while (T--) {
+        Node *root = NULL;
+
+        int N;
+        cin >> N;
+        for (int i = 0; i < N; i++) {
+            int k;
+            cin >> k;
+            root = insert(root, k);
+        }
+
+        int s;
+        cin >> s;
+
+        cout << search(root, s);
+        cout << endl;
+    }
+}
+// } Driver Code Ends
+
+
+// Function to search a node in BST.
+bool search(Node* root, int x) {
+    // Your code here
+    if(!root)return false;
+    if(root->data == x)return true;
+    if(x > root->data)
+    {
+        return search(root->right,x);
+    }
+    else
+        return search(root->left,x);
+}
diff --git a/Shortest Path between Cities - GFG/README.md b/Shortest Path between Cities - GFG/README.md
new file mode 100644
index 0000000..1191240
--- /dev/null
+++ b/Shortest Path between Cities - GFG/README.md	
@@ -0,0 +1,51 @@
+# Shortest Path between Cities
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Geek lives in a special city where houses are arranged in a hierarchial manner. Starting from house number 1, each house leads to two more houses. &nbsp;<br>
+1 leads to 2 and 3.&nbsp;<br>
+2 leads to 4 and 5.&nbsp;<br>
+3 leads to 6 and 7. and so on.&nbsp;<br>
+Given the house numbers on two houses x and y, find the length of the shortest path between them.&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>
+x = 2, y = 6
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+              1
+          /      \
+        /          \
+       2             3
+     /   \         /   \
+    4     5       6     7         
+   / \   / \     / \   / \
+  8  9  10 11   12 13 14 15</span>
+<span style="font-size:18px">
+The length of the shortest path between 2 
+and 6 is 3. ie </span><span style="font-size:18px">2-&gt; 1-&gt; 3-&gt; 6.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+x = 8, y = 10
+<strong>Output: </strong>4
+<strong>Explanation: </strong>8-&gt; 4-&gt; 2-&gt; 5-&gt; 10
+The length of the shortest path between 8 
+and 10 is 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. Complete the function <strong>shortestPath()</strong> which takes integers x and y as input parameters and returns the length of the shortest path from x to y.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(log(max(x,y)))<br>
+<strong>Expected Auxiliary Space: </strong>O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:&nbsp;</strong><br>
+1 &lt;= x,y &lt;= 10<sup>9</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Shortest Path between Cities - GFG/shortest-path-between-cities.cpp b/Shortest Path between Cities - GFG/shortest-path-between-cities.cpp
new file mode 100644
index 0000000..2a93b12
--- /dev/null
+++ b/Shortest Path between Cities - GFG/shortest-path-between-cities.cpp	
@@ -0,0 +1,35 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include<bits/stdc++.h> 
+using namespace std; 
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution{   
+public:
+    int shortestPath( int x, int y){
+       int ans=0;
+       while(x!=y){
+           ans++;
+           x>y?x/=2:y/=2;
+       }
+       return ans;
+   }
+};
+
+// { Driver Code Starts.
+int main() 
+{ 
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int x,y;
+        cin>>x>>y;
+        Solution ob;
+        cout<< ob.shortestPath(x,y) << endl;
+    }
+    return 0; 
+}   // } Driver Code Ends
\ No newline at end of file
diff --git a/Shortest Unique prefix for every word - GFG/README.md b/Shortest Unique prefix for every word - GFG/README.md
new file mode 100644
index 0000000..8b22e46
--- /dev/null
+++ b/Shortest Unique prefix for every word - GFG/README.md	
@@ -0,0 +1,47 @@
+# Shortest Unique prefix for every word
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array of words, find all shortest unique prefixes to represent each word in the given array. Assume that no word is prefix of another.</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
+arr[] = {"zebra", "dog", "duck", "dove"}
+<strong>Output: </strong>z dog du dov
+<strong>Explanation: </strong>
+z =&gt; zebra 
+dog =&gt; dog 
+duck =&gt; du 
+dove =&gt; dov </span>
+</pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input: 
+</strong>N = 3
+arr[] =  {"geeksgeeks", "geeksquiz",
+                       "geeksforgeeks"};
+<strong>Output: </strong>geeksg geeksq geeksf
+<strong>Explanation: </strong>
+geeksgeeks =&gt; geeksg 
+geeksquiz =&gt; geeksq 
+geeksforgeeks =&gt; geeksf</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>findPrefixes()</strong> which takes the array of strings and it's size N as input and returns a list of shortest unique prefix for each word </span></div>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N*length of each word)</span></div>
+
+<div><span style="font-size:18px"><strong>Expected Auxiliary Space:&nbsp;</strong>O(N*length of each word)</span></div>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Constraints:</strong></span></div>
+
+<div><span style="font-size:18px">1 ≤ N, Length of each word ≤ 1000</span></div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Shortest Unique prefix for every word - GFG/shortest-unique-prefix-for-every-word.cpp b/Shortest Unique prefix for every word - GFG/shortest-unique-prefix-for-every-word.cpp
new file mode 100644
index 0000000..dc7dc91
--- /dev/null
+++ b/Shortest Unique prefix for every word - GFG/shortest-unique-prefix-for-every-word.cpp	
@@ -0,0 +1,106 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function Template for C++
+
+struct Node{
+    Node* links[26];
+    bool flag=false;
+    int cnt=0;
+
+    bool containskey(char ch){
+        return links[ch-'a']!=NULL;
+    }
+    void put(char ch,Node* node){
+        links[ch-'a']=node;
+    }
+    Node* get(char ch){
+        return links[ch-'a'];
+    }
+    void setEnd(){
+        flag=true;
+    }
+    bool isEnd(){
+        return flag;
+    }
+};
+class Trie{
+    private:
+    Node* root;
+    public:
+    Trie(){
+        root=new Node();
+    }
+    void insert(string word){
+        Node* node=root;
+        for(int i=0;i<word.length();i++){
+            if(!node->containskey(word[i])){
+                node->put(word[i],new Node());
+            }
+            node=node->get(word[i]);
+            node->cnt++;
+        }
+        node->setEnd();
+    }
+    string un_prefix(string word){
+        Node* node=root;
+        string pre="";
+        for(int i=0;i<word.length();i++){
+            if(node->cnt==1)break;
+            pre+=word[i];
+            node=node->get(word[i]);
+        }
+        return pre;
+    }
+};
+class Solution
+{
+    public:
+    vector<string> findPrefixes(string arr[], int n)
+    {
+        //code here
+        Trie* trie=new Trie();
+        vector<string>ans(n);
+        for(int i=0;i<n;i++){
+            trie->insert(arr[i]);
+        }
+        for(int i=0;i<n;i++){
+            ans[i]=trie->un_prefix(arr[i]);
+        }
+        return ans;
+    }   
+};
+
+// { Driver Code Starts.
+
+int main()
+{
+    int t;
+    cin >> t;
+    while (t--)
+    {
+        int n;
+        cin >> n;
+
+        string arr[n];
+        for (int i = 0; i < n; i++)
+            cin >> arr[i];
+            
+        Solution ob;
+        vector<string> ans = ob.findPrefixes(arr, n);
+        
+        for (int i = 0; i < ans.size(); i++)
+            cout << ans[i] <<" ";
+
+
+        cout << "\n";
+
+    }
+
+    return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Smallest Absolute Difference - GFG/README.md b/Smallest Absolute Difference - GFG/README.md
new file mode 100644
index 0000000..5f6d27d
--- /dev/null
+++ b/Smallest Absolute Difference - GFG/README.md	
@@ -0,0 +1,47 @@
+# Smallest Absolute Difference
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array of size <strong>N</strong> containing positive integers n and a number <strong>k</strong>,The absolute difference between values at indices i and j is <strong>|a[i] – a[j]|</strong>. There are <strong>n*(n-1)/2</strong> such pairs and you have to&nbsp;print the <strong>k<sub>th</sub></strong> <strong>smallest</strong> <strong>absolute</strong> <strong>difference</strong> among all these pairs.</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>
+N = 4
+A[] = {1, 2, 3, 4}
+k = 3<strong>
+Output : </strong>
+1 <strong>
+Explanation :</strong>
+The possible absolute differences are :
+{1, 2, 3, 1, 2, 1}.
+The 3rd smallest value among these is 1.</span></pre>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Example 2:</strong></span></div>
+
+<pre><span style="font-size:18px"><strong>Input : </strong>
+N = 2
+A[] = {10, 10}
+k = 1
+<strong>Output :</strong>
+0</span></pre>
+
+<p><br>
+<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>kthDiff()</strong>&nbsp;which takes the array <strong>A[]</strong>, its size <strong>N </strong>and an integer <strong>k </strong>as inputs and returns the <strong>k<sub>th</sub></strong> smallest absolute difference among all these pairs.</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O( N. (Log(N))<sup>2</sup> )<br>
+<strong>Expected Auxiliary Space:</strong> O(Log(N))</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1&lt;=N&lt;=10<sup>5</sup><br>
+1&lt;=a[i]&lt;=10<sup>5</sup><br>
+1 &lt;= k &lt;= n*(n-1)/2</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Smallest Absolute Difference - GFG/smallest-absolute-difference.cpp b/Smallest Absolute Difference - GFG/smallest-absolute-difference.cpp
new file mode 100644
index 0000000..e8e3ae6
--- /dev/null
+++ b/Smallest Absolute Difference - GFG/smallest-absolute-difference.cpp	
@@ -0,0 +1,52 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+int kthDiff(int a[], int n, int k);
+
+// Driver code
+int main() {
+    int t, i;
+    int k;
+    cin >> t;
+    while (t--) {
+        int n;
+        cin >> n;
+        int a[n];
+        for (i = 0; i < n; i++) {
+            cin >> a[i];
+        }
+        cin >> k;
+
+        cout << kthDiff(a, n, k) << endl;
+    }
+    return 0;
+}
+// } Driver Code Ends
+
+int count(int a[], int n, int mid)
+{
+   int number=0;
+   for(int i=0;i<n;i++){
+       number+=upper_bound(a+i,a+n,a[i]+mid)-(a+i+1);
+   }
+   return number;
+}
+int kthDiff(int a[], int n, int k)
+{
+   sort(a,a+n);
+   int low=a[1]-a[0];
+   for(int i=0;i<n-1;i++){
+       low=min(low,a[i+1]-a[i]);
+   }
+   int high=a[n-1]-a[0];
+   while(low<high){
+       int mid=(low+high)/2;
+       if(count(a,n,mid)<k){
+           low=mid+1;
+       }else{
+           high=mid;
+       }
+   }
+   return low;
+}
\ No newline at end of file
diff --git a/Smallest greater elements in whole array - GFG/README.md b/Smallest greater elements in whole array - GFG/README.md
new file mode 100644
index 0000000..20d0d1d
--- /dev/null
+++ b/Smallest greater elements in whole array - GFG/README.md	
@@ -0,0 +1,43 @@
+# Smallest greater elements in whole array
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array <strong>A</strong> of <strong>N</strong> length. We need to calculate the next greater element for each element in a given array. If the next greater element is not available in a given array then we need to fill <strong>-10000000</strong> at that index place.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input :</strong> arr[] = {13, 6, 7, 12}
+<strong>Output :</strong> _ 7 12 13 
+<strong>Explanation:</strong>
+Here, at index 0, 13 is the greatest value 
+in given array and no other array element 
+is greater from 13. So at index 0 we fill 
+'-10000000'.
+</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input :</strong> arr[] = {6, 3, 9, 8, 10, 2, 1, 15, 7} <strong>
+Output :</strong>  7 6 10 9 15 3 2 _ 8
+<strong>Explanation:</strong> Here, at index 7, 15 is the greatest
+value in given array and no other array element is
+greater from 15. So at index 7 we fill '-10000000'.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+This is a function problem. The input is already taken care of by the driver code. You only need to complete the function <strong>greaterElement()</strong> that takes an array <strong>(arr)</strong>, sizeOfArray <strong>(n)</strong>, and return an&nbsp;array that displays the next greater element to element at that index.&nbsp;The driver code takes care of the printing.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(N*LOG(N)).<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(N).</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>5</sup><br>
+-10<sup>6</sup> ≤ A<sub>i</sub> ≤ 10<sup>6</sup></span></p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Smallest greater elements in whole array - GFG/smallest-greater-elements-in-whole-array.cpp b/Smallest greater elements in whole array - GFG/smallest-greater-elements-in-whole-array.cpp
new file mode 100644
index 0000000..a2555b0
--- /dev/null
+++ b/Smallest greater elements in whole array - GFG/smallest-greater-elements-in-whole-array.cpp	
@@ -0,0 +1,52 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+int* greaterElement(int arr[], int n);
+
+int main()
+{
+    int t,n;
+    cin>>t;
+    while(t--)
+    {
+        cin>>n;
+        int arr[n];
+        for(int i=0;i<n;i++)
+        {
+            cin>>arr[i];
+        }
+        int *b;
+        b = greaterElement(arr, n);
+        for(int i=0;i<n;i++){
+            if(b[i] == -10000000)
+                cout << "_ ";
+            else
+                cout << b[i] << " ";
+        }
+        cout<<endl;   
+        
+    }
+    return 0;
+}
+// } Driver Code Ends
+
+
+int* greaterElement(int arr[], int n)
+{    
+   set<int>s;
+   for(int i=0;i<n;i++){
+       s.insert(arr[i]);
+   }
+   
+   for(int i=0;i<n;i++){
+ auto it= s.upper_bound(arr[i]);
+  if(it==s.end()){
+    arr[i]=-10000000;
+
+  }
+  else
+   {arr[i]=*it;}
+   }
+   return arr; 
+}
diff --git a/Smallest window containing 0, 1 and 2 - GFG/README.md b/Smallest window containing 0, 1 and 2 - GFG/README.md
new file mode 100644
index 0000000..fd28c92
--- /dev/null
+++ b/Smallest window containing 0, 1 and 2 - GFG/README.md	
@@ -0,0 +1,39 @@
+# Smallest window containing 0, 1 and 2
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a string S consisting of the characters 0, 1 and 2. Your task is to find the length of the smallest substring of string S that contains all the three characters 0, 1 and 2. If no such substring exists, then return -1.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+S = "01212"
+<strong>Output:</strong>
+3
+<strong>Explanation:</strong>
+The substring 012 is the smallest substring
+that contains the characters 0, 1 and 2.
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>
+S = "12121"
+<strong>Output:</strong>
+-1
+<strong>Explanation: </strong>
+As the character 0 is not present in the
+string S, therefor no substring containing
+all the three characters 0, 1 and 2
+exists. Hence, the answer is -1 in this case.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+Complete the function <strong>smallestSubstring()</strong> which takes the string <strong>S</strong> as input, and returns the length of the smallest substring of string S that contains all the three characters 0, 1 and 2.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(|S|)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(1)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ |S|&nbsp;≤ 10<sup>5</sup><br>
+All the characters of String S lies in the set {'0', '1', '2'}</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Smallest window containing 0, 1 and 2 - GFG/smallest-window-containing-0-1-and-2.cpp b/Smallest window containing 0, 1 and 2 - GFG/smallest-window-containing-0-1-and-2.cpp
new file mode 100644
index 0000000..db5c8ce
--- /dev/null
+++ b/Smallest window containing 0, 1 and 2 - GFG/smallest-window-containing-0-1-and-2.cpp	
@@ -0,0 +1,52 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+// User function Template for C++
+
+class Solution {
+  public:
+   int smallestSubstring(string S) {
+        if(S.size() < 3){
+            return -1;
+        }
+        int arr[3] = {0, 0, 0};
+        int i = 0;
+        int j = 1;
+        arr[S[i] - '0']++;
+        int ans = INT_MAX;
+        int n = S.size();
+        while(j < n){
+            arr[S[j] - '0']++;
+            while(arr[S[i] - '0'] > 1 && i < j){
+                arr[S[i] - '0']--;
+                i++;
+            }
+            if(arr[0] > 0 && arr[1] > 0 && arr[2] > 0){
+                ans = min(ans, (arr[0] + arr[1] + arr[2]));
+            }
+            j++;
+        }
+       if(ans == INT_MAX){
+           return -1;
+       }
+       return ans;
+    }
+};
+
+
+// { Driver Code Starts.
+
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        string S;
+        cin >> S;
+        Solution ob;
+        cout << ob.smallestSubstring(S);
+        cout << endl;
+    }
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Sort a stack - GFG/README.md b/Sort a stack - GFG/README.md
new file mode 100644
index 0000000..c545817
--- /dev/null
+++ b/Sort a stack - GFG/README.md	
@@ -0,0 +1,30 @@
+# Sort a stack
+## Easy 
+<div class="problem-statement">
+                <p><a onclick="gtagHelperFunction('clickopen','salesevent_gsc_problemspage_promobanner')" href="https://practice.geeksforgeeks.org/summer-carnival-2022?utm_source=practiceproblems&amp;utm_medium=problemspromobanner&amp;utm_campaign=gsc22" target="_blank"></a></p><div style="margin: 14px 0px !important;" class="row"><a onclick="gtagHelperFunction('clickopen','salesevent_gsc_problemspage_promobanner')" href="https://practice.geeksforgeeks.org/summer-carnival-2022?utm_source=practiceproblems&amp;utm_medium=problemspromobanner&amp;utm_campaign=gsc22" target="_blank">             <div class="col-md-12" style="cursor:pointer;background: #EFF8F3 0% 0% no-repeat padding-box; display: flex; align-items: center; position:                 relative; padding: 1.5%; border-radius: 10px; display: inline-block; text-align: center; font-weight: 600; color: #333"> <img src="https://media.geeksforgeeks.org/img-practice/gcs2022thumbnail-1649059370.png" alt="Lamp" width="46" height="40" style="background: transparent 0% 0% no-repeat padding-box;opacity: 1; margin: 0 16px;" class="img-responsive"> Geeks Summer Carnival is LIVE NOW &nbsp; <i class="fa fa-external-link" aria-hidden="true"></i> </div></a></div><p><span style="font-size:18px">Given a stack, the task is to sort&nbsp;it such that the top of the stack has the greatest&nbsp;element.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>Stack: 3 2 1
+<strong>Output: </strong>3 2 1</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>Stack: 11 2 32 3 41
+<strong>Output: </strong>41 32 11 3 2</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:&nbsp;</strong><br>
+You don't have to read input or print anything. Your task is to complete the function&nbsp;<strong>sort()&nbsp;</strong>which sorts the elements present in the given stack. (The sorted stack is printed by the driver's code by popping the elements of the stack.)</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity</strong>: O(N*N)<br>
+<strong>Expected Auxilliary Space</strong>: O(N) recursive.</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1&lt;=N&lt;=100<br>
+<br>
+<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.</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Sort a stack - GFG/sort-a-stack.cpp b/Sort a stack - GFG/sort-a-stack.cpp
new file mode 100644
index 0000000..89ed936
--- /dev/null
+++ b/Sort a stack - GFG/sort-a-stack.cpp	
@@ -0,0 +1,74 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+class SortedStack{
+public:
+	stack<int> s;
+	void sort();
+};
+
+void printStack(stack<int> s)
+{
+    while (!s.empty())
+    {
+        printf("%d ", s.top());
+       	s.pop();
+    }
+    printf("\n");
+}
+
+int main()
+{
+int t;
+cin>>t;
+while(t--)
+{
+	SortedStack *ss = new SortedStack();
+	int n;
+	cin>>n;
+	for(int i=0;i<n;i++)
+	{
+	int k;
+	cin>>k;
+	ss->s.push(k);
+	}
+	ss->sort();
+	printStack(ss->s);
+}
+}// } Driver Code Ends
+
+
+/*The structure of the class is
+class SortedStack{
+public:
+	stack<int> s;
+	void sort();
+};
+*/
+
+/* The below method sorts the stack s 
+you are required to complete the below method */
+void SortedStack :: sort()
+{
+  //Your code here
+  priority_queue<int> pq;
+  stack<int> s1;
+  while(!s.empty())
+   {
+       pq.push(s.top());
+       s.pop();
+   }  
+   while(!pq.empty())
+   {
+       s1.push(pq.top());
+       pq.pop();
+       
+   }
+   while(!s1.empty())
+   {
+       s.push(s1.top());
+       s1.pop();
+   }
+}
+
diff --git a/Sort an array of 0s, 1s and 2s - GFG/README.md b/Sort an array of 0s, 1s and 2s - GFG/README.md
new file mode 100644
index 0000000..721ba5b
--- /dev/null
+++ b/Sort an array of 0s, 1s and 2s - GFG/README.md	
@@ -0,0 +1,42 @@
+# Sort an array of 0s, 1s and 2s
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array of size N containing only 0s, 1s, and 2s; sort the array in ascending order.</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 2 1 2 0}
+<strong>Output:</strong>
+0 0 1 2 2
+<strong>Explanation:</strong>
+0s 1s and 2s are segregated 
+into ascending order.</span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>
+N = 3
+arr[] = {0 1 0}
+<strong>Output:</strong>
+0 0 1
+<strong>Explanation:</strong>
+0s 1s and 2s are segregated 
+into ascending order.</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>sort012() </strong>that takes an array arr and N as input parameters and <strong>sorts the array in-place. </strong></span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity: </strong>O(N)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 10^6<br>
+0 &lt;= A[i] &lt;= 2</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Sort an array of 0s, 1s and 2s - GFG/sort-an-array-of-0s-1s-and-2s.cpp b/Sort an array of 0s, 1s and 2s - GFG/sort-an-array-of-0s-1s-and-2s.cpp
new file mode 100644
index 0000000..b16a3df
--- /dev/null
+++ b/Sort an array of 0s, 1s and 2s - GFG/sort-an-array-of-0s-1s-and-2s.cpp	
@@ -0,0 +1,48 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+
+
+ // } Driver Code Ends
+class Solution
+{
+    public:
+    void sort012(int a[], int n)
+    {
+        // coode here
+        sort(a,a+n);
+        return ;
+    }
+    
+};
+
+// { Driver Code Starts.
+int main() {
+
+    int t;
+    cin >> t;
+
+    while(t--){
+        int n;
+        cin >>n;
+        int a[n];
+        for(int i=0;i<n;i++){
+            cin >> a[i];
+        }
+
+        Solution ob;
+        ob.sort012(a, n);
+
+        for(int i=0;i<n;i++){
+            cout << a[i]  << " ";
+        }
+
+        cout << endl;
+        
+        
+    }
+    return 0;
+}
+
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Sort by Set Bit Count - GFG/README.md b/Sort by Set Bit Count - GFG/README.md
new file mode 100644
index 0000000..1b6f63a
--- /dev/null
+++ b/Sort by Set Bit Count - GFG/README.md	
@@ -0,0 +1,63 @@
+# Sort by Set Bit Count
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given an array of integers, sort the array (in descending order) according to count of set bits in binary representation of array elements.&nbsp; </span></p>
+
+<p><span style="font-size:18px"><strong>Note:</strong> For integers having same number of set bits in their binary representation, sort according to their position in the original array i.e., a stable sort.</span></p>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Example 1:</strong></span></div>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>
+arr[] = {5, 2, 3, 9, 4, 6, 7, 15, 32};
+<strong>Output:</strong>
+15 7 5 3 9 6 2 4 32
+<strong>Explanation:</strong>
+The integers in their binary
+representation are:
+15 - 1111
+7  - 0111
+5  - 0101
+3  - 0011
+9  - 1001
+6  - 0110
+2  - 0010
+4  - 0100
+32 - 10000
+hence the non-increasing sorted order is:
+{15}, {7}, {5, 3, 9, 6}, {2, 4, 32}</span></pre>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Example 2:</strong></span></div>
+
+<pre><span style="font-size:18px"><strong>Input: 
+</strong>arr[] = {1, 2, 3, 4, 5, 6};
+<strong>Output:</strong> 
+3 5 6 1 2 4
+<strong>Explanation:</strong>
+3  - 0011
+5  - 0101
+6  - 0110
+1  - 0001
+2  - 0010
+4  - 0100
+hence the non-increasing sorted order is
+{3, 5, 6}, {1, 2, 4}</span></pre>
+
+<p><br>
+<br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to print anything, printing is done by the driver code itself. You just need to complete the function <strong>sortBySetBitCount() </strong>which takes the array <strong>arr[]</strong> and its size <strong>N</strong><strong> </strong>as inputs and sort the array <strong>arr[]</strong> inplace. Use of extra space is prohibited.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity: </strong>O(N.log(N))<br>
+<strong>Expected Auxiliary Space: </strong>O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N ≤ 10<sup>5</sup><br>
+1 ≤ A[i] ≤ 10<sup>6</sup> </span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Sort by Set Bit Count - GFG/sort-by-set-bit-count.cpp b/Sort by Set Bit Count - GFG/sort-by-set-bit-count.cpp
new file mode 100644
index 0000000..2aec93d
--- /dev/null
+++ b/Sort by Set Bit Count - GFG/sort-by-set-bit-count.cpp	
@@ -0,0 +1,54 @@
+// { Driver Code Starts
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+class Solution{
+    public:
+    static bool compare(const int &a, const int &b)
+   {
+       int ca=0;
+       int cb=0;
+       int A=a,B=b;
+       while(A)
+       {
+           A=A&(A-1);
+           ca++;
+       }
+       while(B)
+       {
+           B=B&(B-1);
+           cb++;
+       }
+       return ca>cb;
+       
+   }
+   void sortBySetBitCount(int arr[], int n)
+   {
+       stable_sort(arr,arr+n,compare);
+   }
+};
+
+// { Driver Code Starts.
+
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        cin>>n;
+        int arr[n];
+        for(int i=0;i<n;i++){
+            cin>>arr[i];
+        }
+        Solution ob;
+        ob.sortBySetBitCount(arr, n);
+        for (int i = 0; i < n; i++)
+            cout << arr[i] << " ";
+        cout << endl;
+    }
+    return 0;
+}
+  // } Driver Code Ends
\ No newline at end of file
diff --git a/Special Matrix - GFG/README.md b/Special Matrix - GFG/README.md
new file mode 100644
index 0000000..40682dd
--- /dev/null
+++ b/Special Matrix - GFG/README.md	
@@ -0,0 +1,40 @@
+# Special Matrix
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">You are given a matrix having <strong>n</strong> rows and <strong>m</strong> columns. The special property of this matrix is that some of the cells of this matrix are <strong>blocked&nbsp;</strong>i.e. they cannot be reached. Now you have to start from the cell <strong>(1,1)</strong> and reach the end <strong>(n,m)</strong> provided during the journey you can move horizontally <strong>right</strong> from the current cell or vertically <strong>down</strong> from the current cell. Can you answer the <strong>number of ways</strong> you can traverse the matrix obeying the above constraints starting from <strong>(1,1)</strong> and ending at <strong>(n,m)</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>n = 3, m = 3, k = 2,
+blocked_cells = {{1,2},{3,2}}.
+<strong>Output: </strong>1
+<strong>Explanation: </strong>There is only one path from
+(1,1) to(3,3) which is (1,1)-&gt;(2,1)-&gt;(2,2)-&gt;
+(2,3)-&gt;(3,3).</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, m = 5, k = 1,
+blocked_cells = {{5,5}}
+<strong>Output: </strong>0
+<strong>Explanation: </strong>There is no path to reach at 
+(5,5) beacuse (5,5) is blocked.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read or print anything, Your task is to complete the function&nbsp;<strong>FindWays()&nbsp;</strong>which takes n, m and blocked_cells as input parameter and returns total number of ways to reach at (n, m) modulo 10<sup>9</sup>&nbsp;+ 7.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(n*m)<br>
+<strong>Expected Space Complexity:&nbsp;</strong>O(n*m)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= n, m &lt;= 500<br>
+1 &lt;= k &lt;= n*m&nbsp;</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Special Matrix - GFG/special-matrix.cpp b/Special Matrix - GFG/special-matrix.cpp
new file mode 100644
index 0000000..1cb621c
--- /dev/null
+++ b/Special Matrix - GFG/special-matrix.cpp	
@@ -0,0 +1,53 @@
+// { Driver Code Starts
+
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+
+class Solution {
+private:
+    int mod = 1000000007;
+    int dp[1000][1000];
+public:
+    int FindWaysHelper(int n, int m, vector<vector<int>> grid, int i, int j)
+    {
+        if(i < 0 || i >= n || j < 0 || j >= m || grid[i][j] == 1) return 0;
+        if(i == n-1 && j == m-1) return 1;
+        grid[i][j] = 1;
+        if(dp[i][j] != -1) return dp[i][j];
+        return dp[i][j] = (FindWaysHelper(n, m, grid, i, j+1) + FindWaysHelper(n, m, grid, i+1, j))%mod;
+    }
+    
+    
+	int FindWays(int n, int m, vector<vector<int>>blocked_cells){
+	    vector<vector<int>> grid(n, vector<int> (m, 0));
+	    memset(dp, -1, sizeof(dp));
+	    for(int i = 0; i < blocked_cells.size(); i++)
+	    {
+	        grid[blocked_cells[i][0] - 1][blocked_cells[i][1] - 1] = 1;
+	    }
+	    int result = FindWaysHelper(n, m, grid, 0, 0);
+	    return result;
+	}
+};
+
+// { Driver Code Starts.
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		int n, m, k;
+		cin >> n >> m >> k;
+		vector<vector<int>>blocked_cells;
+		for(int i = 0; i < k; i++){
+			int x, y;
+			cin >> x >> y;
+			blocked_cells.push_back({x, y});
+		}
+		Solution obj;
+		int ans = obj.FindWays(n, m, blocked_cells);
+		cout << ans <<'\n';
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Spidey Sense - GFG/README.md b/Spidey Sense - GFG/README.md
new file mode 100644
index 0000000..fbfc8c9
--- /dev/null
+++ b/Spidey Sense - GFG/README.md	
@@ -0,0 +1,52 @@
+# Spidey Sense
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Spiderman is stuck in a difficult situation. His arch-enemy the Green Goblin has planted several of his infamous Pumpkin Bombs in various locations in a building. Help Spiderman activate his Spidey Sense and identify the impact zones.&nbsp;<br>
+He has a blueprint of the building which is a M x N matrix that is filled with the characters O, B, and W where:&nbsp;<br>
+O represents an open space.<br>
+B represents a bomb.<br>
+W represents a wall.<br>
+You have to replace all of the Os (open spaces) in the matrix with their shortest distance from a bomb without being able to go through any walls. Also, replace the bombs with 0 and walls with -1 in the resultant matrix. If no path exists between a bomb and an open space replace the corresponding 'O' with -1.</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 = 3
+A[] = {</span><span style="font-size:18px">{O, O, O}, 
+       {W, B, B},&nbsp;
+       {W, O, O</span><span style="font-size:18px">}}</span>
+<span style="font-size:18px"><strong>Output:</strong> {</span><span style="font-size:18px">{2, 1, 1}, 
+         {-1, 0, 0},&nbsp; 
+         {-1, 1, 1</span><span style="font-size:18px">}}</span>
+<span style="font-size:18px"><strong>Explanation: </strong></span><span style="font-size:18px">The walls at (1,0) and (2,0) 
+are replaced by -1.</span><span style="font-size:18px"> The bombs at (1,1) and 
+(1,2) are replaced by 0.</span><span style="font-size:18px"><strong> The impact zone 
+for the bomb at (1,1)</strong> includes open spaces 
+at index (0,0), (0,1) and (2,1) with distance 
+from bomb calculated as 2,1,1 respectively.</span>
+<span style="font-size:18px"><strong>The impact zone for the bomb at (1,2)</strong> 
+includes open spaces at index (0,3) and (2,2) 
+with distance from bomb calculated as 1,1 
+respectively.</span>
+</pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>IInput: </strong>N = 2, M = 2
+A[] = {</span><span style="font-size:18px">{O, O},
+       {O, O}</span><span style="font-size:18px">}</span> 
+<span style="font-size:18px"><strong>Output:</strong> {{-1, -1}
+         {-1, -1}
+</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task: </strong>&nbsp;<br>
+You don't need to read input or print anything. Complete the function <strong>findDistance()</strong> which takes the matrix A[], M, and N as input parameters and the resultant matrix</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(M*N)<br>
+<strong>Expected Auxiliary Space:</strong> O(M*N)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ N*M ≤ 10<sup>6</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Spidey Sense - GFG/spidey-sense.cpp b/Spidey Sense - GFG/spidey-sense.cpp
new file mode 100644
index 0000000..e731c61
--- /dev/null
+++ b/Spidey Sense - GFG/spidey-sense.cpp	
@@ -0,0 +1,78 @@
+// { Driver Code Starts
+
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution{
+
+    public:
+ vector<vector<int> > findDistance(vector<vector<char> >& matrix, int M, int N) 
+    { 
+        // Your code goes here
+        int di[] = {0,0,-1,1};
+        int dj[] = {-1,1,0,0};
+        queue<pair<int,int>> q;
+        vector<vector<int>> ans(M,vector<int> (N,-1));//filling with -1 reduces steps at last
+        for(int i=0; i<M; i++){
+            for(int j=0; j<N; j++){
+                if(matrix[i][j] == 'B'){
+                    q.push({i,j});
+                    ans[i][j] = 0;
+                }
+            }
+        }
+        int level = 1;
+        while(!q.empty()){
+            int q_size = q.size();
+            while(q_size-- > 0){
+                int i = q.front().first, j = q.front().second; q.pop();
+                for(int idx=0; idx<4; idx++){
+                    int next_i = i+di[idx],next_j = j+dj[idx];
+                    if(next_i>=0 && next_j >=0 && next_i<M && next_j<N && matrix[next_i][next_j] == 'O' && ans[next_i][next_j] == -1){
+                        q.push({next_i,next_j});
+                        ans[next_i][next_j] = level;
+                    }
+                }
+            }
+            level += 1;
+        }
+        return ans;
+    } 
+};
+
+// { Driver Code Starts.
+
+
+int main()
+{
+
+    int t;
+    cin >> t;
+    while(t--)
+    {
+    	int M,N;
+        cin>>M;
+        cin>>N;
+
+        vector<vector<char> > matrix(M);
+        for(int i=0; i<M; ++i)
+        {
+            matrix[i].resize(N);
+            for (int j = 0; j < N; ++j)
+                cin>>matrix[i][j];
+        }
+
+        vector<vector<int> >result;
+        Solution obj;
+        result = obj.findDistance(matrix, M,N); 
+        for(int i=0; i<M; ++i)
+        {
+            for (int j = 0; j < N; ++j)
+                cout<<result[i][j]<<" ";
+            cout<<"\n";
+        }
+    }
+
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Stack using two queues - GFG/README.md b/Stack using two queues - GFG/README.md
new file mode 100644
index 0000000..56b2367
--- /dev/null
+++ b/Stack using two queues - GFG/README.md	
@@ -0,0 +1,44 @@
+# Stack using two queues
+## Easy 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Implement a Stack&nbsp;using two queues<strong>&nbsp;q1</strong>&nbsp;and<strong>&nbsp;q2</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><span style="font-size:18px">push(2)
+push(3)
+pop()
+push(4)
+pop()</span><strong><span style="font-size:18px">
+Output: </span></strong><span style="font-size:18px">3 4
+</span><strong><span style="font-size:18px">Explanation:
+</span></strong><span style="font-size:18px">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&nbsp;will be {2}
+push(4)&nbsp;the stack&nbsp;will be {2 4}
+pop() &nbsp; poped element will be 4 &nbsp;</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">push(2)
+pop()
+pop()
+push(3)</span><strong><span style="font-size:18px">
+Output: </span></strong><span style="font-size:18px">2 -1</span></pre>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong></p>
+
+<p><span style="font-size:18px">Since this is a function problem, you don't need to take inputs. You are required to complete the two methods&nbsp;<strong>push()</strong>&nbsp;which takes&nbsp;an integer <strong>'x'</strong>&nbsp;as input&nbsp;denoting the element to be pushed into the stack and&nbsp;<strong>pop()</strong>&nbsp;which returns the&nbsp;integer&nbsp;poped out from the stack(<strong>-1</strong>&nbsp;if the stack&nbsp;is empty).</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(1) for&nbsp;<strong>push()&nbsp;</strong>and O(N) for&nbsp;<strong>pop()&nbsp;</strong>(or vice-versa).<br>
+<strong>Expected Auxiliary Space:&nbsp;</strong>O(1) for both&nbsp;<strong>push()&nbsp;</strong>and&nbsp;<strong>pop()</strong>.</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;=<strong>&nbsp;</strong>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/Stack using two queues - GFG/stack-using-two-queues.cpp b/Stack using two queues - GFG/stack-using-two-queues.cpp
new file mode 100644
index 0000000..f80c893
--- /dev/null
+++ b/Stack using two queues - GFG/stack-using-two-queues.cpp	
@@ -0,0 +1,79 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+class QueueStack{
+private:
+    queue<int> q1;
+    queue<int> q2;
+public:
+    void push(int);
+    int pop();
+};
+
+
+int main()
+{
+    int T;
+    cin>>T;
+    while(T--)
+    {
+        QueueStack *qs = new QueueStack();
+
+        int Q;
+        cin>>Q;
+        while(Q--){
+        int QueryType=0;
+        cin>>QueryType;
+        if(QueryType==1)
+        {
+            int a;
+            cin>>a;
+            qs->push(a);
+        }else if(QueryType==2){
+            cout<<qs->pop()<<" ";
+
+        }
+        }
+        cout<<endl;
+    }
+}
+// } Driver Code Ends
+
+
+/* The structure of the class is
+class QueueStack{
+private:
+    queue<int> q1;
+    queue<int> q2;
+public:
+    void push(int);
+    int pop();
+};
+ */
+
+//Function to push an element into stack using two queues.
+void QueueStack :: push(int x)
+{
+        // Your Code
+        q1.push(x);
+        int rem = q1.size()-1;
+        while(rem--)
+        {
+            q1.push(q1.front());
+            q1.pop();
+        }
+}
+
+//Function to pop an element from stack using two queues. 
+int QueueStack :: pop()
+{
+        // Your Code     
+        if(!q1.empty())
+        {
+            int ans = q1.front();
+            q1.pop();
+            return ans;
+        }
+        return -1;
+}
diff --git a/Subset Sums - GFG/README.md b/Subset Sums - GFG/README.md
new file mode 100644
index 0000000..1741c2c
--- /dev/null
+++ b/Subset Sums - GFG/README.md	
@@ -0,0 +1,43 @@
+# Subset Sums
+## Basic 
+<div class="problem-statement">
+                <p></p><div class="entry-content">
+<p><span style="font-size:18px">Given a&nbsp;list <strong>arr</strong>&nbsp;of <strong>N</strong> integers, print sums of all subsets in it.</span></p>
+
+<p><span style="font-size:18px"><strong>Note:</strong> Return all the element is increasing order.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 2
+arr[] = {2, 3}</span>
+<span style="font-size:18px"><strong>Output:</strong>
+0 2 3 5</span>
+<span style="font-size:18px"><strong>Explanation:</strong>
+When no elements is taken then Sum = 0.
+When only 2 is taken then Sum = 2.
+When only 3 is taken then Sum = 3.
+When element 2 and 3 are taken then 
+Sum = 2+3 = 5.</span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+N = 3
+arr = {5, 2, 1}</span>
+<span style="font-size:18px"><strong>Output:</strong>
+0 1 2 3 5 6 7 8</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong>&nbsp;&nbsp;<br>
+You don't need to read input or print anything. Your task is to complete the function&nbsp;<strong>subsetSums</strong>()&nbsp;which takes a list/vector and an integer <strong>N</strong> as an input parameter and return the list/vector of all the subset sums.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong>&nbsp;O(2<sup>N</sup>)<br>
+<strong>Expected Auxiliary Space:</strong>&nbsp;O(2<sup>N</sup>)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= N &lt;= 15<br>
+0 &lt;= arr[i] &lt;= 10<sup>4</sup></span></p>
+</div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Subset Sums - GFG/subset-sums.cpp b/Subset Sums - GFG/subset-sums.cpp
new file mode 100644
index 0000000..48f4180
--- /dev/null
+++ b/Subset Sums - GFG/subset-sums.cpp	
@@ -0,0 +1,52 @@
+// { Driver Code Starts
+#include<bits/stdc++.h> 
+using namespace std; 
+
+ // } Driver Code Ends
+class Solution
+{
+public:
+    void helper(vector<int> arr,vector<int>& ans,int N,int i,int sum)
+    {
+        if(i>=N)
+        {
+            ans.push_back(sum);
+            return;
+        }
+        
+        helper(arr,ans,N,i+1,sum+arr[i]);
+        helper(arr,ans,N,i+1,sum);
+    }
+
+    vector<int> subsetSums(vector<int> arr, int N)
+    {
+        vector<int> ans;
+        helper(arr,ans,N,0,0);
+        sort(ans.begin(),ans.end());
+        return ans;
+    }
+};
+
+// { Driver Code Starts.
+int main()
+{
+    int t;
+    cin >> t;
+    while (t--)
+    {
+        int N;
+        cin>>N;
+        vector<int> arr(N);
+        for(int i = 0 ; i < N ; i++){
+            cin >> arr[i];
+        }
+        Solution ob;
+        vector<int> ans = ob.subsetSums(arr,N);
+        sort(ans.begin(),ans.end());
+        for(auto sum : ans){
+            cout<< sum<<" ";
+        }
+        cout<<endl;
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Subsets - GFG/README.md b/Subsets - GFG/README.md
new file mode 100644
index 0000000..032b644
--- /dev/null
+++ b/Subsets - GFG/README.md	
@@ -0,0 +1,54 @@
+# Subsets
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a set of positive integers, find all its subsets.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1 :</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input :</strong> </span>
+<span style="font-size:18px">array = {1, 2, 3}</span>
+<strong><span style="font-size:18px">Output :</span></strong>
+<span style="font-size:18px">// this space denotes null element. 
+1
+1 2
+1 2 3
+1 3
+2
+2 3
+3</span>
+<strong><span style="font-size:18px">Explanation: </span></strong>
+<span style="font-size:18px">The following are the subsets 
+of the array {1, 2, 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">array = {1, 2}</span>
+<strong><span style="font-size:18px">Output :
+</span></strong><span style="font-size:18px">
+1 
+1 2
+2</span>
+<strong><span style="font-size:18px">Explanation :</span></strong>
+<span style="font-size:18px">The following are the 
+subsets of {1, 2}.</span></pre>
+
+<div><strong><span style="font-size:18px">Your task :</span></strong></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>subsets()</strong> which takes the array of integers as input and returns the list of list containing the subsets of the given set of numbers in lexicographical order.</span></div>
+
+<div>&nbsp;</div>
+
+<div><span style="font-size:18px"><strong>Expected Time Complexity :</strong> O(2^n)))</span></div>
+
+<div><span style="font-size:18px"><strong>Expected Auxiliary Space :</strong> O(2^n*length of each subset)</span></div>
+
+<div>&nbsp;</div>
+
+<div><strong><span style="font-size:18px">Constraints :</span></strong></div>
+
+<div><span style="font-size:18px">1 &lt;= n &lt;= 20</span></div>
+
+<div><span style="font-size:18px">1 &lt;= arr[i] &lt;=10</span></div>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Subsets - GFG/subsets.cpp b/Subsets - GFG/subsets.cpp
new file mode 100644
index 0000000..31def1e
--- /dev/null
+++ b/Subsets - GFG/subsets.cpp	
@@ -0,0 +1,76 @@
+// { Driver Code Starts
+//Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+//User function Template for C++
+
+class Solution
+{
+   vector<vector<int>> subsetsRes; //global vector declaration
+
+ 
+
+   //recursive helper function
+   void generate(vector<int>& A, int i, vector<int>& nums){
+   
+       if(i==A.size()){
+           subsetsRes.push_back(nums);
+           return;
+       }    // base case 
+       
+      generate(A, i+1, nums); // Case in which element considered is not added
+      
+      nums.push_back(A[i]);
+      generate(A, i+1, nums); // Case in which element considered is added
+      nums.pop_back(); //backtrack
+   }
+   public:
+   vector<vector<int>> subsets(vector<int>& A)
+   {
+       //code here
+       vector<int> nums;
+       generate(A, 0, nums);
+       sort(subsetsRes.begin(), subsetsRes.end());
+       return subsetsRes;
+   }
+};
+
+// { Driver Code Starts.
+
+int main()
+{
+	int t;
+	cin >> t;
+
+	while (t--)
+	{
+		int n, x;
+		cin >> n;
+
+		vector<int> array;
+		for (int i = 0; i < n; i++)
+		{
+			cin >> x;
+			array.push_back(x);
+		}
+        
+        
+        Solution ob;
+		vector<vector<int> > res = ob.subsets(array);
+
+		// Print result
+		for (int i = 0; i < res.size(); i++) {
+			for (int j = 0; j < res[i].size(); j++)
+				cout << res[i][j] << " ";
+			cout << endl;
+		}
+
+		
+	}
+
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Swap Kth nodes from ends - GFG/README.md b/Swap Kth nodes from ends - GFG/README.md
new file mode 100644
index 0000000..4f37f83
--- /dev/null
+++ b/Swap Kth nodes from ends - GFG/README.md	
@@ -0,0 +1,50 @@
+# Swap Kth nodes from ends
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a singly linked list of size N, and an integer K.&nbsp;You need to swap the K<sup>th</sup>&nbsp;node from the beginning and K<sup>th</sup> node from the end of the linked list. Swap the nodes through the links. Do&nbsp;not change&nbsp;the content of the nodes.</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 = 4,  K = 1
+value[] = {1,2,3,4}
+<strong>Output: </strong>1<strong>
+Explanation: </strong>Here K = 1, hence after
+swapping the 1st node from the beginning
+and end thenew list will be 4 2 3 1.</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,  K = 7
+value[] = {1,2,3,4,5}
+<strong>Output: </strong>1<strong>
+Explanation: </strong>K &gt; N. Swapping is invalid. 
+Return the head node as it is.</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong>&nbsp;<br>
+You do not need to read input or print anything. The task is to complete the function&nbsp;<strong>swapkthnode</strong>(), which has takes head of link list, N and K as input parameters<strong>&nbsp;</strong>and&nbsp;returns the&nbsp;new head.<br>
+<strong>The generated output will be 1 if you are able to complete your task.&nbsp;</strong></span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity</strong>: O(n)<br>
+<strong>Expected Auxillary space Complexity:</strong> O(1)</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong></span><br>
+<span style="font-size:18px">1 &lt;= N &lt;= 10<sup>3</sup></span><br>
+<span style="font-size:18px">1 &lt;= K &lt;= 10<sup>3</sup></span></p>
+
+<p>&nbsp;</p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Swap Kth nodes from ends - GFG/swap-kth-nodes-from-ends.cpp b/Swap Kth nodes from ends - GFG/swap-kth-nodes-from-ends.cpp
new file mode 100644
index 0000000..b5ad4d0
--- /dev/null
+++ b/Swap Kth nodes from ends - GFG/swap-kth-nodes-from-ends.cpp	
@@ -0,0 +1,138 @@
+// { Driver Code Starts
+#include <iostream>
+
+using namespace std;
+
+struct Node {
+  int data;
+  struct Node *next;
+  Node(int x) {
+    data = x;
+    next = NULL;
+  }
+};
+
+
+
+Node *swapkthnode(Node* head, int num, int K);
+
+void addressstore(Node **arr, Node* head)
+{
+    Node* temp = head;
+    int i = 0;
+    while(temp){
+        arr[i] = temp;
+        i++;
+        temp = temp->next;
+    }
+}
+
+bool check(Node ** before, Node **after, int num, int K)
+{
+    if(K > num)
+        return 1;
+    return (before[K-1] == after[num - K]) && (before[num-K] == after[K-1]);
+}
+
+int main()
+{
+    int T;
+    cin>>T;
+    while(T--){
+        int num, K , firstdata;
+        cin>>num>>K;
+        int temp;
+        cin>>firstdata;
+        Node* head = new Node(firstdata);
+        Node* tail = head;
+        for(int i = 0; i<num - 1; i++){
+            cin>>temp;
+            tail->next = new Node(temp);
+            tail = tail->next;
+        }
+        
+        Node *before[num];
+        addressstore(before, head);
+        
+        head = swapkthnode(head, num, K);
+        
+        Node *after[num];
+        addressstore(after, head);
+        
+        if(check(before, after, num, K))
+            cout<<1<<endl;
+        else
+            cout<<0<<endl;
+    }
+}
+// } Driver Code Ends
+
+
+//User function Template for C++
+
+/* Linked List Node structure
+   struct Node  {
+     int data;
+     Node *next;
+     Node(int x) {
+        data = x;
+        next = NULL;
+  }
+  }
+*/
+
+//Function to swap Kth node from beginning and end in a linked list.
+Node *swapkthnode(Node* head, int num, int K)
+{
+    // Your Code here
+    int L = num-K+1;
+    
+    if(K == L or K > num)
+        return head;
+        
+    if(K > L)
+        swap(K, L);
+    
+    Node *first, *second, *prev1, *prev2;
+    
+    prev1 = prev2 = head;
+    
+    for(int i=0; i<K-2; i++)
+        prev1 = prev1->next;
+    
+    for(int i=0; i<L-2; i++)
+        prev2 = prev2->next;
+    
+    first = prev1->next;
+    second = prev2->next;
+    
+    if(K == 1)
+    {
+        first = head;
+        head = second;
+        second->next = first->next;
+        prev2->next = first;
+        first->next = nullptr;
+        
+        return head;
+    }
+    
+    if(K+1 == L)
+    {
+        prev1->next = second;
+        first->next = second->next;
+        second->next = first;
+        
+        return head;
+    }
+    
+    Node *temp = second->next;
+    
+    prev1->next = second;
+    second->next = first->next;
+    
+    prev2->next = first;
+    first->next = temp;
+    
+    return head;
+}
diff --git a/The Painter's Partition Problem-II - GFG/README.md b/The Painter's Partition Problem-II - GFG/README.md
new file mode 100644
index 0000000..a49ec49
--- /dev/null
+++ b/The Painter's Partition Problem-II - GFG/README.md	
@@ -0,0 +1,49 @@
+# The Painter's Partition Problem-II
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Dilpreet wants to paint&nbsp;his dog's home that has&nbsp;<strong>n</strong> boards with&nbsp;different lengths. The length of i<sup>th&nbsp;</sup>board is given by <strong>arr[i]</strong> where <strong>arr[]</strong> is an array of <strong>n</strong> integers. He hired <strong>k</strong> painters for this work and each painter takes <strong>1 unit time to paint 1 unit of the board.&nbsp;</strong></span></p>
+
+<p><span style="font-size:18px">The problem is to find the minimum time to get this job done if all painters start together with the constraint&nbsp;that any painter will only paint continuous boards, say boards numbered <strong>{2,3,4} </strong>or only board <strong>{1}</strong> or nothing but not boards <strong>{2,4,5}</strong>.</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
+k = 3
+arr[] = {5,10,30,20,15}
+<strong>Output:</strong> 35
+<strong>Explanation: </strong>The most optimal way will be:
+Painter 1 allocation : {5,10}
+Painter 2 allocation : {30}
+Painter 3 allocation : {20,15}
+Job will be done when all painters finish
+i.e. at time = max(5+10, 30, 20+15) = 35</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
+k = 2
+arr[] = {10,20,30,40}
+<strong>Output: </strong>60
+<strong>Explanation: </strong>The most optimal way to paint:
+Painter 1 allocation : {10,20,30}
+Painter 2 allocation : {40}
+Job will be complete at time = 60</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your task:</strong><br>
+Your task is to complete the function <strong>minTime() </strong>which takes the integers&nbsp;<strong>n </strong>and&nbsp;<strong>k</strong>&nbsp;and the array&nbsp;<strong>arr[]</strong>&nbsp;as input and returns the minimum time required to paint all partitions.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(n log m) , m = sum of all boards' length<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ n ≤ 10<sup>5</sup><br>
+1 ≤ k ≤ 10<sup>5</sup><br>
+1 ≤ arr[i] ≤ 10<sup>5</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/The Painter's Partition Problem-II - GFG/the-painters-partition-problem-ii.cpp b/The Painter's Partition Problem-II - GFG/the-painters-partition-problem-ii.cpp
new file mode 100644
index 0000000..e23a112
--- /dev/null
+++ b/The Painter's Partition Problem-II - GFG/the-painters-partition-problem-ii.cpp	
@@ -0,0 +1,83 @@
+// { Driver Code Starts
+// driver code
+
+#include <bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+//User function template for C++
+
+class Solution
+{
+  public:
+    
+    bool isPossible(long long int mid,int arr[],int n,int k)
+    {
+        int count = 1;
+        int sum = 0;
+        for(int i=0;i<n;i++)
+        {
+            if(arr[i] + sum > mid)
+            {
+               sum = arr[i];
+               count++;
+               if(count>k)
+                return false;
+            }
+            else
+                sum += arr[i];
+        }
+        return true;
+    }
+    
+    long long minTime(int arr[], int n, int k)
+    {
+        // code here
+        // return minimum time
+        int low = INT_MIN;
+         long long int  high = 0;
+        
+        for(int i=0;i<n;i++)
+        {
+            low = max(low,arr[i]);
+            high += arr[i];
+        }
+        
+        long long int ans = 0;
+        
+        while(low<=high)
+        {
+             long long int mid = low + (high-low)/2;
+             
+             if(isPossible(mid,arr,n,k) )
+             {
+                 ans = mid;
+                 high = mid-1;
+             }
+             else
+                 low = mid+1;
+        }
+        return ans;
+    }
+};
+
+// { Driver Code Starts.
+
+int main()
+{
+	int t;
+	cin>>t;
+	while(t--)
+	{
+		int k,n;
+		cin>>k>>n;
+		
+		int arr[n];
+		for(int i=0;i<n;i++)
+		    cin>>arr[i];
+		Solution obj;
+		cout << obj.minTime(arr, n, k) << endl;
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Transfiguration - GFG/README.md b/Transfiguration - GFG/README.md
new file mode 100644
index 0000000..0fbc848
--- /dev/null
+++ b/Transfiguration - GFG/README.md	
@@ -0,0 +1,46 @@
+# Transfiguration
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Professor McGonagall teaches transfiguration at Hogwarts. She has given Harry the task of changing himself into a cat. She explains that the trick is to analyze your own DNA and change it into the DNA&nbsp;of a cat. The transfigure spell can be used to pick any one character from the DNA string, remove it and insert it in the beginning.&nbsp;<br>
+Help Harry calculates minimum number of times he needs to use the spell to change himself into a cat.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: 
+</strong>A = "GEEKSFORGEEKS" 
+B = "FORGEEKSGEEKS"</span>
+<span style="font-size:18px"><strong>Output:</strong> 3</span>
+<span style="font-size:18px"><strong>Explanation:</strong>The conversion can take place 
+in 3 operations:
+1. Pick 'R' and place it at the front, 
+&nbsp;  A="RGEEKSFOGEEKS"
+2. Pick 'O' and place it at the front, 
+&nbsp;  A="ORGEEKSFGEEKS"
+3. Pick 'F' and place it at the front, 
+&nbsp;  A="FORGEEKSGEEKS"</span></pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: 
+</strong>A = "ABC" 
+B = "BCA"</span>
+<span style="font-size:18px"><strong>Output:</strong> 2</span>
+<span style="font-size:18px"><strong>Explanation:</strong> The conversion can take place 
+in 2 operations:
+1. Pick 'C' and place it at the front, 
+&nbsp;  A = "CAB"
+2. Pick 'B' and place it at the front, 
+&nbsp;  A = "BCA"</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Your Task: </strong>&nbsp;<br>
+You don't need to read input or print anything. Complete the function <strong>transfigure()</strong> which takes strings <strong>A</strong> and <strong>B</strong> as input parameters and returns the minimum number of spells needed. If it is not possible to convert <strong>A</strong> to <strong>B</strong> then return -1.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(max(|A|, |B|))<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ |A|, |B| ≤ 10<sup>5</sup><br>
+A and B consists of lowercase and uppercase letters of english alphabet only.</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Triangle and Square - GFG/README.md b/Triangle and Square - GFG/README.md
new file mode 100644
index 0000000..df7f00b
--- /dev/null
+++ b/Triangle and Square - GFG/README.md	
@@ -0,0 +1,45 @@
+# Triangle and Square
+## Easy 
+<div class="problem-statement">
+                <p></p><p><strong><span style="font-size:18px">Note: This <a href="http://practice.geeksforgeeks.org/problem-of-the-day" target="_blank">POTD</a>&nbsp;is a part of&nbsp;<a href="https://practice.geeksforgeeks.org/summer-carnival-2022?utm_source=potd&amp;utm_medium=problempage&amp;utm_campaign=gsc22" target="_blank">Geek Summer Carnival</a>. Solve all POTD consecutively from 5th to 10th April and get a chance to win exclusive discount vouchers on our GfG courses.</span></strong></p>
+
+<hr>
+<p><span style="font-size:18px">Geek has a ticket to the Geek Summer Carnival. The ticket has a positive integer <strong>B </strong>written on it. <strong>B </strong>denotes the base of a right-angled <strong>isosceles </strong>triangle.&nbsp;<br>
+Geek can avail discounts on <strong>X </strong>courses in the carnival.</span></p>
+
+<p><span style="font-size:18px"><strong>X </strong>is the <strong>maximum </strong>number of squares of size <strong>2x2 </strong>units that can fit in the given right-angled isosceles triangle.&nbsp;<br>
+Find <strong>X</strong>.&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>
+B = 8
+<strong>Output:</strong>
+6 
+<strong>Explanation: 
+</strong></span><img alt="" src="https://media.geeksforgeeks.org/img-practice/ScreenShot2022-04-01at2-1648805313.png" style="height:224px; width:300px" class="img-responsive">
+</pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong>
+B = 2
+<strong>Output:</strong>
+0</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>countSquare()</strong> that takes integer b as input parameter and returns the number of possible squares that can fit into the isosceles triangle.&nbsp;</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(1)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= B &lt;= 1000</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Triangle and Square - GFG/triangle-and-square.cpp b/Triangle and Square - GFG/triangle-and-square.cpp
new file mode 100644
index 0000000..edcae52
--- /dev/null
+++ b/Triangle and Square - GFG/triangle-and-square.cpp	
@@ -0,0 +1,29 @@
+// { Driver Code Starts
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+class Solution{
+    public:
+     int countSquare(int B)
+    {
+	    return (((B/2)*(B/2))/2)-(B/4);
+    }
+};
+
+
+
+// { Driver Code Starts.
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+    	int B,count;
+    	cin>>B;
+    	Solution ob;
+    	count = ob.countSquare(B);
+    	cout<<count<<endl;
+    }
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Union of two arrays - GFG/README.md b/Union of two arrays - GFG/README.md
new file mode 100644
index 0000000..b2c7cd1
--- /dev/null
+++ b/Union of two arrays - GFG/README.md	
@@ -0,0 +1,45 @@
+# Union of two arrays
+## Easy
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given two arrays <strong>a[]</strong>&nbsp;and <strong>b[]</strong>&nbsp;of size <strong>n</strong>&nbsp;and <strong>m</strong> respectively. The task is to find union between these two arrays. </span></p>
+
+<p><span style="font-size:18px">Union of the two arrays can be defined as the set containing distinct elements from both the arrays. If there are repetitions, then only one occurrence of element should be printed in the union.</span></p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>5 3
+1 2 3 4 5
+1 2 3
+<strong>Output: 
+</strong>5<strong>
+Explanation: 
+</strong>1, 2, 3, 4 and 5 are the
+elements which comes in the union set
+of both arrays. So count is 5.</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input:
+</strong>6 2 
+85 25 1 32 54 6
+85 2 
+<strong>Output: 
+</strong>7<strong>
+Explanation: 
+</strong>85, 25, 1, 32, 54, 6, and
+2 are the elements which comes in the
+union set of both arrays. So count is 7.</span></pre>
+
+<p><strong><span style="font-size:18px">Your Task:</span></strong><br>
+<span style="font-size:18px">Complete <strong>doUnion </strong>funciton that takes<strong> a, n, b, m as parameters and returns</strong> the count of union elements of the&nbsp;two arrays. The <strong>printing </strong>is done by the <strong>driver </strong>code.</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong></span><br>
+<span style="font-size:18px">1 ≤ n, m&nbsp;≤ 10<sup>5</sup><br>
+0 ≤ a[i], b[i] &lt;&nbsp;10<sup>5</sup></span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity </strong>: O((n+m)log(n+m))<br>
+<strong>Expected Auxilliary Space</strong> : O(n+m)</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Union of two arrays - GFG/union-of-two-arrays.cpp b/Union of two arrays - GFG/union-of-two-arrays.cpp
new file mode 100644
index 0000000..cd2f534
--- /dev/null
+++ b/Union of two arrays - GFG/union-of-two-arrays.cpp	
@@ -0,0 +1,50 @@
+// { Driver Code Starts
+//Initial template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+//User function template in C++
+
+class Solution{
+    public:
+    //Function to return the count of number of elements in union of two arrays.
+    int doUnion(int a[], int n, int b[], int m)  {
+        //code here
+        set<int> s;
+        for(int i=0;i<n;i++)
+        s.insert(a[i]);
+        
+      for(int i=0;i<m;i++)
+        s.insert(b[i]);
+        
+        return s.size();
+    }
+};
+
+// { Driver Code Starts.
+
+int main() {
+	
+	int t;
+	cin >> t;
+	
+	while(t--){
+	    
+	    int n, m;
+	    cin >> n >> m;
+	    int a[n], b[m];
+	   
+	    for(int i = 0;i<n;i++)
+	       cin >> a[i];
+	       
+	    for(int i = 0;i<m;i++)
+	       cin >> b[i];
+	    Solution ob;
+	    cout << ob.doUnion(a, n, b, m) << endl;
+	    
+	}
+	
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/Word Break - Part 2 - GFG/README.md b/Word Break - Part 2 - GFG/README.md
new file mode 100644
index 0000000..3374280
--- /dev/null
+++ b/Word Break - Part 2 - GFG/README.md	
@@ -0,0 +1,36 @@
+# Word Break - Part 2
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a string <strong>s</strong> and a dictionary of words <strong>dict</strong> of length <strong>n</strong><strong>,</strong> add spaces in <strong>s</strong> to construct a sentence where each word is a valid dictionary word. Each dictionary word can be used more than once. Return all such possible sentences.</span></p>
+
+<p><span style="font-size:18px">Follow examples for better understanding.</span></p>
+
+<p><strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> s = "catsanddog", n = 5 
+dict = {"cats", "cat", "and", "sand", "dog"}
+<strong>Output:</strong> (cats and dog)(cat sand dog)
+<strong>Explanation:</strong> All the words in the given 
+sentences are present in the dictionary.</span></pre>
+
+<p><strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> s = "catsandog", n = 5
+dict = {"cats", "cat", "and", "sand", "dog"}
+<strong>Output:</strong> Empty
+<strong>Explanation:</strong> There is no possible breaking 
+of the string s where all the words are present 
+in dict.</span></pre>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You do not need to read input or print anything. Your task is to complete the function <strong>wordBreak()</strong> which takes <strong>n</strong>, <strong>dict</strong> and <strong>s</strong> as input parameters and returns a list of possible sentences. If no sentence is possible it returns an empty list.</span></p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(N<sup>2</sup>*n) where N = |s|<br>
+<strong>Expected Auxiliary Space:</strong> O(N<sup>2</sup>)</span></p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ n ≤ 20<br>
+1 ≤ dict[i] ≤ 15<br>
+1 ≤ |s| ≤ 500&nbsp;</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/Word Break - Part 2 - GFG/word-break-part-2.cpp b/Word Break - Part 2 - GFG/word-break-part-2.cpp
new file mode 100644
index 0000000..acaa99b
--- /dev/null
+++ b/Word Break - Part 2 - GFG/word-break-part-2.cpp	
@@ -0,0 +1,83 @@
+// { Driver Code Starts
+// Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+
+class Solution{
+public:
+
+    bool isThere(vector<string>& dict,string & left,int n)
+    {
+        for(int i=0;i<n;i++)
+        {
+            if(dict[i] == left)
+            return true;
+        }
+        return false;
+    }
+
+    void helper(vector<string>& ans,string & res,int n, vector<string>& dict, string s)
+    {
+         for(int i=1;i<=s.size();i++)
+        {
+            string left = s.substr(0,i);
+             string right = s.substr(i,s.size()-i);
+            if(isThere(dict,left,n))
+            {
+                if(i==s.size())
+                {
+                    res += left;
+                    //string aa = "( " + res + " )";
+                    ans.push_back(res);
+                    return;
+                }
+                string answer = res+left+" ";
+               helper(ans,answer,n,dict,right); 
+            }
+        }
+    }
+    
+    vector<string> wordBreak(int n, vector<string>& dict, string s)
+    {
+        // code here
+         vector<string> ans;
+         string res;
+         helper(ans,res,n,dict,s);
+        return ans;
+       
+    }
+};
+
+// { Driver Code Starts.
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int n;
+        vector<string> dict;
+        string s;
+        cin>>n;
+        for(int i = 0;i < n;i++){
+            cin>>s;
+            dict.push_back(s);
+        }
+        cin>>s;
+        
+        Solution ob;
+        vector<string> ans = ob.wordBreak(n, dict, s);
+        if(ans.size() == 0)
+            cout<<"Empty\n";
+        else{
+            sort(ans.begin(), ans.end());
+            for(int i = 0;i < ans.size();i++)
+                cout<<"("<<ans[i]<<")";
+            cout<<endl;
+        }
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/XOR Game - GFG/README.md b/XOR Game - GFG/README.md
new file mode 100644
index 0000000..bc98fb8
--- /dev/null
+++ b/XOR Game - GFG/README.md	
@@ -0,0 +1,33 @@
+# XOR Game
+## Medium 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given a positive number <strong>k</strong>, we need to find a minimum value of&nbsp;positive integer <strong>n</strong>, such that XOR of n and n+1 is equal to k. If no such <strong>n</strong> exist then print -1.</span></p>
+
+<p><br>
+<strong><span style="font-size:18px">Example 1:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> k = 3
+<strong>Output:</strong> 1
+<strong>Explaination:</strong> 1 xor 2 = 3.</span></pre>
+
+<p><br>
+<strong><span style="font-size:18px">Example 2:</span></strong></p>
+
+<pre><span style="font-size:18px"><strong>Input:</strong> k = 6
+<strong>Output:</strong> -1
+<strong>Explaination:</strong> There is no such n, so that, 
+n xor n+1 = k.</span></pre>
+
+<p><br>
+<span style="font-size:18px"><strong>Your Task:</strong><br>
+You do not need to read input or print anything. Your task is to complete the function <strong>xorCal()</strong> which takes k as input parameter and returns the value of n. If there is no such , then it returns -1.</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Expected Time Complexity:</strong> O(1)<br>
+<strong>Expected Auxiliary Space:</strong> O(1)</span></p>
+
+<p><br>
+<span style="font-size:18px"><strong>Constraints:</strong><br>
+1 ≤ k ≤ 100</span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/XOR Game - GFG/xor-game.cpp b/XOR Game - GFG/xor-game.cpp
new file mode 100644
index 0000000..e7f822c
--- /dev/null
+++ b/XOR Game - GFG/xor-game.cpp	
@@ -0,0 +1,36 @@
+// { Driver Code Starts
+// Initial Template for C++
+
+#include <bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+// User function Template for C++
+
+class Solution{
+public:
+   int xorCal(int k){
+       
+       
+       if(k == 1) return 2;
+       int val = k/2;
+       if((val ^ (val +1)) == k) return val;
+       else{
+           return -1;
+       }
+   }
+};
+// { Driver Code Starts.
+
+int main(){
+    int t;
+    cin>>t;
+    while(t--){
+        int k;
+        cin>>k;
+        
+        Solution ob;
+        cout<<ob.xorCal(k)<<"\n";
+    }
+    return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/accounts-merge/README.md b/accounts-merge/README.md
new file mode 100644
index 0000000..2b6b766
--- /dev/null
+++ b/accounts-merge/README.md
@@ -0,0 +1,35 @@
+<h2>721. Accounts Merge</h2><h3>Medium</h3><hr><div><p>Given a list of <code>accounts</code> where each element <code>accounts[i]</code> is a list of strings, where the first element <code>accounts[i][0]</code> is a name, and the rest of the elements are <strong>emails</strong> representing emails of the account.</p>
+
+<p>Now, we would like to merge these accounts. Two accounts definitely belong to the same person if there is some common email to both accounts. Note that even if two accounts have the same name, they may belong to different people as people could have the same name. A person can have any number of accounts initially, but all of their accounts definitely have the same name.</p>
+
+<p>After merging the accounts, return the accounts in the following format: the first element of each account is the name, and the rest of the elements are emails <strong>in sorted order</strong>. The accounts themselves can be returned in <strong>any order</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> accounts = [["John","johnsmith@mail.com","john_newyork@mail.com"],["John","johnsmith@mail.com","john00@mail.com"],["Mary","mary@mail.com"],["John","johnnybravo@mail.com"]]
+<strong>Output:</strong> [["John","john00@mail.com","john_newyork@mail.com","johnsmith@mail.com"],["Mary","mary@mail.com"],["John","johnnybravo@mail.com"]]
+<strong>Explanation:</strong>
+The first and second John's are the same person as they have the common email "johnsmith@mail.com".
+The third John and Mary are different people as none of their email addresses are used by other accounts.
+We could return these lists in any order, for example the answer [['Mary', 'mary@mail.com'], ['John', 'johnnybravo@mail.com'], 
+['John', 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com']] would still be accepted.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> accounts = [["Gabe","Gabe0@m.co","Gabe3@m.co","Gabe1@m.co"],["Kevin","Kevin3@m.co","Kevin5@m.co","Kevin0@m.co"],["Ethan","Ethan5@m.co","Ethan4@m.co","Ethan0@m.co"],["Hanzo","Hanzo3@m.co","Hanzo1@m.co","Hanzo0@m.co"],["Fern","Fern5@m.co","Fern1@m.co","Fern0@m.co"]]
+<strong>Output:</strong> [["Ethan","Ethan0@m.co","Ethan4@m.co","Ethan5@m.co"],["Gabe","Gabe0@m.co","Gabe1@m.co","Gabe3@m.co"],["Hanzo","Hanzo0@m.co","Hanzo1@m.co","Hanzo3@m.co"],["Kevin","Kevin0@m.co","Kevin3@m.co","Kevin5@m.co"],["Fern","Fern0@m.co","Fern1@m.co","Fern5@m.co"]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= accounts.length &lt;= 1000</code></li>
+	<li><code>2 &lt;= accounts[i].length &lt;= 10</code></li>
+	<li><code>1 &lt;= accounts[i][j] &lt;= 30</code></li>
+	<li><code>accounts[i][0]</code> consists of English letters.</li>
+	<li><code>accounts[i][j] (for j &gt; 0)</code> is a valid email.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/accounts-merge/accounts-merge.cpp b/accounts-merge/accounts-merge.cpp
new file mode 100644
index 0000000..dbfe94d
--- /dev/null
+++ b/accounts-merge/accounts-merge.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    void dfs(string& email) {
+        seen.insert(email);
+        ans.back().push_back(email);
+        for(auto& adjEmail : G[email]) 
+            if(!seen.count(adjEmail)) 
+                dfs(adjEmail);        
+    }
+    vector<vector<string>> accountsMerge(vector<vector<string>>& A) {        
+        for(auto& acc : A)                            
+            for(int i = 2; i < size(acc); i++)              // create graph with email as nodes and,
+                G[acc[i]].push_back(acc[i-1]),              // add edges between adjacent nodes of same account
+                G[acc[i-1]].push_back(acc[i]);
+        
+        for(auto& acc : A) 
+            if(!seen.count(acc[1])) {                       // If an email from a account is not previously seen,
+                ans.push_back({acc[0]});                    // create new account & insert person's name
+                dfs(acc[1]);                                // perform dfs to find all his emails & add it to the list
+                sort(begin(ans.back())+1, end(ans.back())); // sort the emails
+            }            
+   //     ans.push_back({});
+        return ans;
+    }
+private:
+    unordered_map<string, vector<string>> G;  // adjacency list graph with email as nodes and edges between adjacent email of same account
+    unordered_set<string> seen;               // to mark an email as visited in DFS
+    vector<vector<string>> ans;               // final answer after merging accounts
+};
\ No newline at end of file
diff --git a/add-digits/README.md b/add-digits/README.md
new file mode 100644
index 0000000..46da928
--- /dev/null
+++ b/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/add-digits/add-digits.cpp b/add-digits/add-digits.cpp
new file mode 100644
index 0000000..7839f13
--- /dev/null
+++ b/add-digits/add-digits.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int addDigits(int num) {
+        if(num / 10 == 0)
+          return num;
+      
+      int temp = num;
+      int sum = 0;
+      while(temp)
+      {
+        sum += temp%10;
+        temp /= 10;
+      }
+      return addDigits(sum);
+    }
+};
\ No newline at end of file
diff --git a/add-strings/README.md b/add-strings/README.md
new file mode 100644
index 0000000..ea34177
--- /dev/null
+++ b/add-strings/README.md
@@ -0,0 +1,32 @@
+<h2>415. Add Strings</h2><h3>Easy</h3><hr><div><p>Given two non-negative integers, <code>num1</code> and <code>num2</code> represented as string, return <em>the sum of</em> <code>num1</code> <em>and</em> <code>num2</code> <em>as a string</em>.</p>
+
+<p>You must solve the problem without using any built-in library for handling large integers (such as <code>BigInteger</code>). You must also not convert the inputs to integers directly.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num1 = "11", num2 = "123"
+<strong>Output:</strong> "134"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num1 = "456", num2 = "77"
+<strong>Output:</strong> "533"
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> num1 = "0", num2 = "0"
+<strong>Output:</strong> "0"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= num1.length, num2.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>num1</code> and <code>num2</code> consist of only digits.</li>
+	<li><code>num1</code> and <code>num2</code> don't have any leading zeros except for the zero itself.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/add-strings/add-strings.cpp b/add-strings/add-strings.cpp
new file mode 100644
index 0000000..c018f65
--- /dev/null
+++ b/add-strings/add-strings.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+string addStrings(string num1, string num2) {
+    int i = num1.size() - 1;
+    int j = num2.size() - 1;
+    int carry = 0;
+    string res = "";
+    while(i>=0 || j>=0 || carry){
+        long sum = 0;
+        if(i >= 0){sum += (num1[i] - '0');i--;}
+        if(j >= 0){sum += (num2[j] - '0');j--;}
+        sum += carry; 
+        carry = sum / 10;
+        sum = sum % 10;
+        res =  res + to_string(sum);
+    }
+    reverse(res.begin(), res.end());
+    return res;
+}
+};
\ No newline at end of file
diff --git a/add-two-numbers/README.md b/add-two-numbers/README.md
new file mode 100644
index 0000000..f257754
--- /dev/null
+++ b/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/add-two-numbers/add-two-numbers.cpp b/add-two-numbers/add-two-numbers.cpp
new file mode 100644
index 0000000..85a5c8e
--- /dev/null
+++ b/add-two-numbers/add-two-numbers.cpp
@@ -0,0 +1,58 @@
+/**
+ * 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 * reverse(ListNode * l1)
+//     {
+//         if(!l1 || l1->next == NULL)
+//             return l1;
+        
+//         ListNode * nextnode=l1->next;
+//         ListNode * reversed = reverse(l1->next);
+//         l1->next = NULL;
+//         nextnode->next = l1;
+//         return reversed;
+//     }
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+   //     l1 = reverse(l1);
+   //     l2 = reverse(l2);
+        int carry = 0;
+        ListNode * dummy = new ListNode(0);
+        ListNode * temp = dummy;
+        while(l1 != NULL || l2 !=NULL)
+        {
+            int sum = carry;
+            if(l1)
+                sum+=l1->val;
+            if(l2)
+                sum+=l2->val;
+            
+            int value = sum%10;
+            carry = sum/10;
+            ListNode * newNode = new ListNode(value);
+            temp->next = newNode;
+            temp = temp->next;
+            if(l1)
+            l1 = l1->next;
+            if(l2)
+            l2 = l2->next;
+        }
+        
+        if(carry)
+        {
+            ListNode * newNode = new ListNode(carry);
+            temp->next = newNode;
+            temp = temp->next;
+        }
+        return dummy->next;
+        
+    }
+};
\ No newline at end of file
diff --git a/all-elements-in-two-binary-search-trees/README.md b/all-elements-in-two-binary-search-trees/README.md
new file mode 100644
index 0000000..bb7f4a4
--- /dev/null
+++ b/all-elements-in-two-binary-search-trees/README.md
@@ -0,0 +1,43 @@
+<h2>1305. All Elements in Two Binary Search Trees</h2><h3>Medium</h3><hr><div><p>Given two binary search trees <code>root1</code> and <code>root2</code>.</p>
+
+<p>Return a list containing <em>all the integers</em> from <em>both trees</em> sorted in <strong>ascending</strong> order.</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>
+
+<pre><strong>Input:</strong> root1 = [0,-10,10], root2 = [5,1,7,0,2]
+<strong>Output:</strong> [-10,0,0,1,2,5,7,10]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root1 = [], root2 = [5,1,7,0,2]
+<strong>Output:</strong> [0,1,2,5,7]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> root1 = [0,-10,10], root2 = []
+<strong>Output:</strong> [-10,0,10]
+</pre>
+
+<p><strong>Example 5:</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>Each tree has at most <code>5000</code> nodes.</li>
+	<li>Each node's value is between <code>[-10^5, 10^5]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/all-elements-in-two-binary-search-trees/all-elements-in-two-binary-search-trees.cpp b/all-elements-in-two-binary-search-trees/all-elements-in-two-binary-search-trees.cpp
new file mode 100644
index 0000000..2d2ead2
--- /dev/null
+++ b/all-elements-in-two-binary-search-trees/all-elements-in-two-binary-search-trees.cpp
@@ -0,0 +1,60 @@
+/**
+ * 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:
+   void inOrderTraverse(TreeNode *root, vector<int>& vec)
+    {
+        if(root)
+	    {
+		    inOrderTraverse(root->left, vec);
+		    vec.push_back(root->val);
+		    inOrderTraverse(root->right, vec);
+
+	    }
+    }
+  void mergeVectors(vector<int> vec1, vector<int> vec2, vector<int>& mergedVectors)
+    {
+        int i = 0, j = 0, k = 0; 
+
+        // Traverse both array 
+        while (i < vec1.size() && j < vec2.size()) 
+        { 
+        
+            if (vec1[i] < vec2[j]) 
+                mergedVectors[k++] = vec1[i++]; 
+            else
+                mergedVectors[k++] = vec2[j++]; 
+        } 
+  
+    
+        while (i < vec1.size()) 
+            mergedVectors[k++] = vec1[i++]; 
+  
+    
+        while (j < vec2.size()) 
+            mergedVectors[k++] = vec2[j++]; 
+        
+        
+    } 
+  
+    vector<int> getAllElements(TreeNode* root1, TreeNode* root2) {
+      vector<int> v1;
+      vector<int> v2;
+       inOrderTraverse(root1, v1);
+        inOrderTraverse(root2, v2);
+        
+     vector<int> mergedVectors(v1.size() + v2.size());
+		
+        mergeVectors(v1, v2, mergedVectors);
+        return  mergedVectors;
+    }
+};
\ No newline at end of file
diff --git a/all-paths-from-source-to-target/README.md b/all-paths-from-source-to-target/README.md
new file mode 100644
index 0000000..afe7dee
--- /dev/null
+++ b/all-paths-from-source-to-target/README.md
@@ -0,0 +1,48 @@
+<h2>797. All Paths From Source to Target</h2><h3>Medium</h3><hr><div><p>Given a directed acyclic graph (<strong>DAG</strong>) of <code>n</code> nodes labeled from <code>0</code> to <code>n - 1</code>, find all possible paths from node <code>0</code> to node <code>n - 1</code> and return them in <strong>any order</strong>.</p>
+
+<p>The graph is given as follows: <code>graph[i]</code> is a list of all nodes you can visit from node <code>i</code> (i.e., there is a directed edge from node <code>i</code> to node <code>graph[i][j]</code>).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/28/all_1.jpg" style="width: 242px; height: 242px;">
+<pre><strong>Input:</strong> graph = [[1,2],[3],[3],[]]
+<strong>Output:</strong> [[0,1,3],[0,2,3]]
+<strong>Explanation:</strong> There are two paths: 0 -&gt; 1 -&gt; 3 and 0 -&gt; 2 -&gt; 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/28/all_2.jpg" style="width: 423px; height: 301px;">
+<pre><strong>Input:</strong> graph = [[4,3,1],[3,2,4],[3],[4],[]]
+<strong>Output:</strong> [[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> graph = [[1],[]]
+<strong>Output:</strong> [[0,1]]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> graph = [[1,2,3],[2],[3],[]]
+<strong>Output:</strong> [[0,1,2,3],[0,2,3],[0,3]]
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> graph = [[1,3],[2],[3],[]]
+<strong>Output:</strong> [[0,1,2,3],[0,3]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == graph.length</code></li>
+	<li><code>2 &lt;= n &lt;= 15</code></li>
+	<li><code>0 &lt;= graph[i][j] &lt; n</code></li>
+	<li><code>graph[i][j] != i</code> (i.e., there will be no self-loops).</li>
+	<li>All the elements of <code>graph[i]</code> are <strong>unique</strong>.</li>
+	<li>The input graph is <strong>guaranteed</strong> to be a <strong>DAG</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/all-paths-from-source-to-target/all-paths-from-source-to-target.cpp b/all-paths-from-source-to-target/all-paths-from-source-to-target.cpp
new file mode 100644
index 0000000..fa24701
--- /dev/null
+++ b/all-paths-from-source-to-target/all-paths-from-source-to-target.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+   void dfs(vector<vector<int>>& g, vector<vector<int>>& res, vector<int>& path, int cur) {
+        path.push_back(cur);
+        if (cur == g.size() - 1)
+            res.push_back(path);
+        else for (auto it: g[cur])
+            dfs(g, res, path, it);
+        path.pop_back();
+
+    }
+
+    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& g) {
+        vector<vector<int>> paths;
+        vector<int> path;
+        dfs(g, paths, path, 0);
+        return paths;
+    }
+};
\ No newline at end of file
diff --git a/all-possible-full-binary-trees/README.md b/all-possible-full-binary-trees/README.md
new file mode 100644
index 0000000..a6334d5
--- /dev/null
+++ b/all-possible-full-binary-trees/README.md
@@ -0,0 +1,26 @@
+<h2>894. All Possible Full Binary Trees</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>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>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/all-possible-full-binary-trees/all-possible-full-binary-trees.cpp b/all-possible-full-binary-trees/all-possible-full-binary-trees.cpp
new file mode 100644
index 0000000..b9e2657
--- /dev/null
+++ b/all-possible-full-binary-trees/all-possible-full-binary-trees.cpp
@@ -0,0 +1,36 @@
+class Solution {
+	vector<TreeNode *> generateFBTs(int n) {
+		if(n == 1) return {new TreeNode(0)}; //choice 1
+		//choice two
+		vector<TreeNode *> trees;
+		n--; //count this node
+		
+		vector<TreeNode *> leftChoices, rightChoices;
+		//fixing the sizes of the subtrees
+		for(int i = 1; i<n; i+=2) {
+			leftChoices = generateFBTs(i);
+			rightChoices = generateFBTs(n-i);
+			
+			//add the trees for each possible combination
+			for(TreeNode *j : leftChoices) {
+				for(TreeNode *k : rightChoices) {
+					TreeNode *root = new TreeNode(0);
+					root->left = j;
+					root->right = k;
+					trees.push_back(root);
+				}
+			}
+		}
+		return trees;
+	}
+public: 
+	vector<TreeNode *> allPossibleFBT(int n) {
+		//checking for base cases
+		if(n == 1) return {new TreeNode(0)};
+		else if(n%2 == 11) return {};
+		else if(n==31) return {new TreeNode(0, new TreeNode(0), new TreeNode(0))};
+		
+		//otherwise, do the normal thing
+		return generateFBTs(n);
+	}
+};
\ No newline at end of file
diff --git a/arranging-coins/README.md b/arranging-coins/README.md
new file mode 100644
index 0000000..20e3cd8
--- /dev/null
+++ b/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/arranging-coins/arranging-coins.cpp b/arranging-coins/arranging-coins.cpp
new file mode 100644
index 0000000..181f32a
--- /dev/null
+++ b/arranging-coins/arranging-coins.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int arrangeCoins(int n) {
+        long end = n;
+        long low = 0;
+        long high = n;
+        
+        while(low <= high)
+        {
+            long mid = low + (high-low)/2;
+            if(mid*(mid+1) <= 2*end)
+            {
+                low = mid+1;
+            }
+            else
+                high = mid-1;
+        }
+        return (int)(low-1);
+    }
+};
\ No newline at end of file
diff --git a/array-of-doubled-pairs/README.md b/array-of-doubled-pairs/README.md
new file mode 100644
index 0000000..4e2adfb
--- /dev/null
+++ b/array-of-doubled-pairs/README.md
@@ -0,0 +1,37 @@
+<h2>954. Array of Doubled Pairs</h2><h3>Medium</h3><hr><div><p>Given an array of integers <code>arr</code> of even length, return <code>true</code> if and only if it is possible to reorder it such that <code>arr[2 * i + 1] = 2 * arr[2 * i]</code> for every <code>0 &lt;= i &lt; len(arr) / 2</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [3,1,3,6]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [2,1,2,6]
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [4,-2,2,-4]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> We can take two groups, [-2,-4] and [2,4] to form [-2,-4,2,4] or [2,4,-2,-4].
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,2,4,16,8,4]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= arr.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>arr.length</code> is even.</li>
+	<li><code>-10<sup>5</sup> &lt;= arr[i] &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/balance-a-binary-search-tree/README.md b/balance-a-binary-search-tree/README.md
new file mode 100644
index 0000000..59996a0
--- /dev/null
+++ b/balance-a-binary-search-tree/README.md
@@ -0,0 +1,26 @@
+<h2>1382. Balance a Binary Search Tree</h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary search tree, return <em>a <strong>balanced</strong> binary search tree with the same node values</em>. If there is more than one answer, return <strong>any of them</strong>.</p>
+
+<p>A binary search tree is <strong>balanced</strong> if the depth of the two subtrees of every node never differs by more than <code>1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/balance1-tree.jpg" style="width: 500px; height: 319px;">
+<pre><strong>Input:</strong> root = [1,null,2,null,3,null,4,null,null]
+<strong>Output:</strong> [2,1,3,null,null,null,4]
+<b>Explanation:</b> This is not the only correct answer, [3,1,4,null,2] is also correct.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/balanced2-tree.jpg" style="width: 224px; height: 145px;">
+<pre><strong>Input:</strong> root = [2,1,3]
+<strong>Output:</strong> [2,1,3]
+</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;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/balanced-binary-tree/README.md b/balanced-binary-tree/README.md
new file mode 100644
index 0000000..803d204
--- /dev/null
+++ b/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/balanced-binary-tree/balanced-binary-tree.cpp b/balanced-binary-tree/balanced-binary-tree.cpp
new file mode 100644
index 0000000..97df1b8
--- /dev/null
+++ b/balanced-binary-tree/balanced-binary-tree.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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:
+  int helper(TreeNode * root)
+  {
+    if(root == NULL)
+      return 0;
+    
+    int l = helper(root->left);
+    int r = helper(root->right);
+    
+    if(l != -1 && r != -1 && abs(l-r) <= 1 )
+    return 1 + max(l,r);
+    return -1;
+    
+  }
+  
+    bool isBalanced(TreeNode* root) {
+        if(root == NULL)
+          return true;
+      
+      int ans = helper(root);
+      if(ans != -1)
+        return true;
+      return false;
+    }
+};
\ No newline at end of file
diff --git a/best-sightseeing-pair/README.md b/best-sightseeing-pair/README.md
new file mode 100644
index 0000000..bf4fdfb
--- /dev/null
+++ b/best-sightseeing-pair/README.md
@@ -0,0 +1,28 @@
+<h2>1014. Best Sightseeing Pair</h2><h3>Medium</h3><hr><div><p>You are given an integer array <code>values</code> where values[i] represents the value of the <code>i<sup>th</sup></code> sightseeing spot. Two sightseeing spots <code>i</code> and <code>j</code> have a <strong>distance</strong> <code>j - i</code> between them.</p>
+
+<p>The score of a pair (<code>i &lt; j</code>) of sightseeing spots is <code>values[i] + values[j] + i - j</code>: the sum of the values of the sightseeing spots, minus the distance between them.</p>
+
+<p>Return <em>the maximum score of a pair of sightseeing spots</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> values = [8,1,5,2,6]
+<strong>Output:</strong> 11
+<strong>Explanation:</strong> i = 0, j = 2, values[i] + values[j] + i - j = 8 + 5 + 0 - 2 = 11
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> values = [1,2]
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= values.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= values[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/best-sightseeing-pair/best-sightseeing-pair.cpp b/best-sightseeing-pair/best-sightseeing-pair.cpp
new file mode 100644
index 0000000..1390423
--- /dev/null
+++ b/best-sightseeing-pair/best-sightseeing-pair.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int maxScoreSightseeingPair(vector<int>& values) {
+        int ans = INT_MIN;
+        int prev = values[0] + 0;
+        for(int i=1;i<values.size();i++){
+            ans = max(ans,prev + values[i] - i);
+            prev = max(prev,values[i]+i);
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/best-time-to-buy-and-sell-stock-ii/README.md b/best-time-to-buy-and-sell-stock-ii/README.md
new file mode 100644
index 0000000..e312436
--- /dev/null
+++ b/best-time-to-buy-and-sell-stock-ii/README.md
@@ -0,0 +1,38 @@
+<h2>122. Best Time to Buy and Sell Stock II</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>Find the maximum profit you can achieve. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).</p>
+
+<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> prices = [7,1,5,3,6,4]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> prices = [1,2,3,4,5]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> prices = [7,6,4,3,1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> In this case, no transaction is done, i.e., max profit = 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= prices.length &lt;= 3 * 10<sup>4</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/best-time-to-buy-and-sell-stock-ii/best-time-to-buy-and-sell-stock-ii.cpp b/best-time-to-buy-and-sell-stock-ii/best-time-to-buy-and-sell-stock-ii.cpp
new file mode 100644
index 0000000..557a683
--- /dev/null
+++ b/best-time-to-buy-and-sell-stock-ii/best-time-to-buy-and-sell-stock-ii.cpp
@@ -0,0 +1,9 @@
+class Solution {
+public:
+ int maxProfit(vector<int> &prices) {
+    int ret = 0;
+    for (size_t p = 1; p < prices.size(); ++p) 
+      ret += max(prices[p] - prices[p - 1], 0);    
+    return ret;
+}
+};
\ No newline at end of file
diff --git a/best-time-to-buy-and-sell-stock-iii/README.md b/best-time-to-buy-and-sell-stock-iii/README.md
new file mode 100644
index 0000000..89b23aa
--- /dev/null
+++ b/best-time-to-buy-and-sell-stock-iii/README.md
@@ -0,0 +1,37 @@
+<h2>123. Best Time to Buy and Sell Stock III</h2><h3>Hard</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>Find the maximum profit you can achieve. You may complete <strong>at most two transactions</strong>.</p>
+
+<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> prices = [3,3,5,0,0,3,1,4]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> prices = [1,2,3,4,5]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> prices = [7,6,4,3,1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> In this case, no transaction is done, i.e. 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>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/best-time-to-buy-and-sell-stock-iv/README.md b/best-time-to-buy-and-sell-stock-iv/README.md
new file mode 100644
index 0000000..0954381
--- /dev/null
+++ b/best-time-to-buy-and-sell-stock-iv/README.md
@@ -0,0 +1,30 @@
+<h2>188. Best Time to Buy and Sell Stock IV</h2><h3>Hard</h3><hr><div><p>You are given an integer 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, and an integer <code>k</code>.</p>
+
+<p>Find the maximum profit you can achieve. You may complete at most <code>k</code> transactions.</p>
+
+<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> k = 2, prices = [2,4,1]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> k = 2, prices = [3,2,6,5,0,3]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4. Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= k &lt;= 100</code></li>
+	<li><code>0 &lt;= prices.length &lt;= 1000</code></li>
+	<li><code>0 &lt;= prices[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/best-time-to-buy-and-sell-stock-iv/best-time-to-buy-and-sell-stock-iv.cpp b/best-time-to-buy-and-sell-stock-iv/best-time-to-buy-and-sell-stock-iv.cpp
new file mode 100644
index 0000000..cbd0447
--- /dev/null
+++ b/best-time-to-buy-and-sell-stock-iv/best-time-to-buy-and-sell-stock-iv.cpp
@@ -0,0 +1,42 @@
+class Solution {
+public:
+    int maxProfit(int k, vector<int>& prices) {
+        if(prices.size()==0 || k==0)return 0;
+        vector<vector<int>> dp(k+1,vector<int> (prices.size()));
+        
+        for(int i=1;i<=k;i++)
+        {
+            int maxi ;
+            for(int j=1;j<prices.size();j++)
+            {
+                if(j==1)
+                {
+                    maxi =-1* prices[0];
+                }
+                
+                    // dp[i][j] = dp[i][j-1];
+                    // for(int k = 0;k<j;k++)
+                    // {
+                    //     dp[i][j] = max(dp[i][j],dp[i-1][k] + prices[j] - prices[k] );
+                    // }
+                    
+                    dp[i][j] = max(dp[i][j-1] ,maxi+prices[j]);
+                    maxi = max(maxi,dp[i-1][j] - prices[j]);
+            }
+            
+            
+        }
+        
+        
+//         for(int i=0;i<=k;i++)
+//         {
+//             for(int j=0;j<prices.size();j++)
+//             {
+//                 cout<<dp[i][j]<<" ";       
+//             }
+//             cout<<endl;
+//         }
+        
+        return dp[k][prices.size()-1];
+    }
+};
\ No newline at end of file
diff --git a/best-time-to-buy-and-sell-stock-with-cooldown/README.md b/best-time-to-buy-and-sell-stock-with-cooldown/README.md
new file mode 100644
index 0000000..8cfa7a9
--- /dev/null
+++ b/best-time-to-buy-and-sell-stock-with-cooldown/README.md
@@ -0,0 +1,32 @@
+<h2>309. Best Time to Buy and Sell Stock with Cooldown</h2><h3>Medium</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>Find the maximum profit you can achieve. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times) with the following restrictions:</p>
+
+<ul>
+	<li>After you sell your stock, you cannot buy stock on the next day (i.e., cooldown one day).</li>
+</ul>
+
+<p><strong>Note:</strong> You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> prices = [1,2,3,0,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> transactions = [buy, sell, cooldown, buy, sell]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> prices = [1]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= prices.length &lt;= 5000</code></li>
+	<li><code>0 &lt;= prices[i] &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/best-time-to-buy-and-sell-stock-with-cooldown/best-time-to-buy-and-sell-stock-with-cooldown.cpp b/best-time-to-buy-and-sell-stock-with-cooldown/best-time-to-buy-and-sell-stock-with-cooldown.cpp
new file mode 100644
index 0000000..abcce8a
--- /dev/null
+++ b/best-time-to-buy-and-sell-stock-with-cooldown/best-time-to-buy-and-sell-stock-with-cooldown.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& arr) {
+       vector<vector<int>> dp(2,vector<int> (arr.size()+1));
+ 
+ dp[0][1] = -1*arr[0];
+ dp[1][1] = 0;
+ 
+ for(int i=2;i<=arr.size();i++)
+ {
+    dp[0][i] = max(dp[0][i-1], dp[1][i-2]-arr[i-1]);
+      dp[1][i] = max(dp[0][i-1]+arr[i-1],dp[1][i-1]);
+ }
+        
+        
+        return dp[1][arr.size()];
+    }
+};
\ No newline at end of file
diff --git a/best-time-to-buy-and-sell-stock/README.md b/best-time-to-buy-and-sell-stock/README.md
new file mode 100644
index 0000000..f6dbc57
--- /dev/null
+++ b/best-time-to-buy-and-sell-stock/README.md
@@ -0,0 +1,30 @@
+<h2>121. Best Time to Buy and Sell Stock</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/best-time-to-buy-and-sell-stock/best-time-to-buy-and-sell-stock.cpp b/best-time-to-buy-and-sell-stock/best-time-to-buy-and-sell-stock.cpp
new file mode 100644
index 0000000..59b1fd8
--- /dev/null
+++ b/best-time-to-buy-and-sell-stock/best-time-to-buy-and-sell-stock.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int maxProfit(vector<int> &prices) {
+    int maxPro = 0;
+    int minPrice = INT_MAX;
+    for(int i = 0; i < prices.size(); i++){
+        minPrice = min(minPrice, prices[i]);
+        maxPro = max(maxPro, prices[i] - minPrice);
+    }
+    return maxPro;
+}
+};
\ No newline at end of file
diff --git a/binary-search-tree-to-greater-sum-tree/README.md b/binary-search-tree-to-greater-sum-tree/README.md
new file mode 100644
index 0000000..73b6022
--- /dev/null
+++ b/binary-search-tree-to-greater-sum-tree/README.md
@@ -0,0 +1,46 @@
+<h2>1038. Binary Search Tree to Greater Sum Tree</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 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&nbsp;<strong>less than</strong>&nbsp;the node's key.</li>
+	<li>The right subtree of a node contains only nodes with keys&nbsp;<strong>greater than</strong>&nbsp;the node's key.</li>
+	<li>Both the left and right subtrees must also be binary search trees.</li>
+</ul>
+
+<p><strong>Note:</strong> This question is the same as 538:&nbsp;<a href="https://leetcode.com/problems/convert-bst-to-greater-tree/">https://leetcode.com/problems/convert-bst-to-greater-tree/</a></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/05/02/tree.png" style="width: 550px; height: 375px;">
+<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><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,0,2]
+<strong>Output:</strong> [3,3,2]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> root = [3,2,4,1]
+<strong>Output:</strong> [7,9,4,10]
+</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>
+	<li><code>root</code> is guaranteed to be a valid binary search tree.</li>
+</ul></div>
\ No newline at end of file
diff --git a/binary-search-tree-to-greater-sum-tree/binary-search-tree-to-greater-sum-tree.cpp b/binary-search-tree-to-greater-sum-tree/binary-search-tree-to-greater-sum-tree.cpp
new file mode 100644
index 0000000..e015e32
--- /dev/null
+++ b/binary-search-tree-to-greater-sum-tree/binary-search-tree-to-greater-sum-tree.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    TreeNode* bstToGst(TreeNode* root) {
+        int acc_sum = 0;
+        sum_node(root,acc_sum);
+        return root;
+    }
+    
+    void sum_node(TreeNode* node, int& acc_sum){
+        if (node == NULL)  return;
+        sum_node(node->right,acc_sum);
+        node->val += acc_sum;
+        acc_sum = node->val;
+        sum_node(node->left, acc_sum);
+    }
+};
\ No newline at end of file
diff --git a/binary-search/README.md b/binary-search/README.md
new file mode 100644
index 0000000..cb494d2
--- /dev/null
+++ b/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/binary-search/binary-search.cpp b/binary-search/binary-search.cpp
new file mode 100644
index 0000000..49dcdde
--- /dev/null
+++ b/binary-search/binary-search.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+        
+    int bs(vector<int>& nums, int target,int low,int high)
+    {
+        if(high>=low)
+        {
+            int mid = low+(high-low)/2;
+            if(nums[mid]==target)return mid;
+            else if(nums[mid]>target)return bs(nums,target,low,mid-1);
+            else return bs(nums,target,mid+1,high);
+        }
+            return -1;
+    }
+    
+    int search(vector<int>& nums, int target) {
+        return bs(nums,target,0,nums.size()-1);
+    }
+};
\ No newline at end of file
diff --git a/binary-tree-inorder-traversal/README.md b/binary-tree-inorder-traversal/README.md
new file mode 100644
index 0000000..728adca
--- /dev/null
+++ b/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/binary-tree-inorder-traversal/binary-tree-inorder-traversal.cpp b/binary-tree-inorder-traversal/binary-tree-inorder-traversal.cpp
new file mode 100644
index 0000000..d02d1b8
--- /dev/null
+++ b/binary-tree-inorder-traversal/binary-tree-inorder-traversal.cpp
@@ -0,0 +1,27 @@
+/**
+ * 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:
+     vector <int> ans;
+    vector<int> inorderTraversal(TreeNode* root) {
+        
+        if(root == NULL)
+            return ans;
+        
+      inorderTraversal(root->left);
+      ans.push_back(root->val);
+      inorderTraversal(root->right);
+        
+      return ans;
+        
+    }
+};
\ No newline at end of file
diff --git a/binary-tree-level-order-traversal/README.md b/binary-tree-level-order-traversal/README.md
new file mode 100644
index 0000000..26c0297
--- /dev/null
+++ b/binary-tree-level-order-traversal/README.md
@@ -0,0 +1,29 @@
+<h2>102. Binary Tree Level Order Traversal</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/binary-tree-level-order-traversal/binary-tree-level-order-traversal.cpp b/binary-tree-level-order-traversal/binary-tree-level-order-traversal.cpp
new file mode 100644
index 0000000..5b91c11
--- /dev/null
+++ b/binary-tree-level-order-traversal/binary-tree-level-order-traversal.cpp
@@ -0,0 +1,81 @@
+/**
+ * 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:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> ans;
+        
+        if(root == NULL)
+            return ans;
+        
+        queue <TreeNode*> pendingNodes;
+        pendingNodes.push(root);
+        int siz  = 1;
+         vector<int> level;
+        while(pendingNodes.size())
+        {
+             
+            if(siz == 0)
+            {
+                siz  = pendingNodes.size();
+                ans.push_back(level);
+                level.clear();
+            }
+            TreeNode* front = pendingNodes.front();
+             pendingNodes.pop();
+            level.push_back(front->val);
+         //   cout<<siz<<endl;
+            siz--;
+            
+            if(front->left)
+            {
+                pendingNodes.push(front->left);
+            }
+            if(front->right)
+            {
+                pendingNodes.push(front->right);
+            }
+            
+        
+        }
+         if(siz == 0)
+            {
+                siz  = pendingNodes.size();
+                ans.push_back(level);
+                level.clear();
+            }
+        
+        return ans;
+    }
+};
+
+
+
+
+
+
+
+
+
+  //   TreeNode* start = pendingNodes.front();
+           
+//             vector<int> level;
+//             int siz = pendingNodes.size();
+//             while(siz--)
+//             {
+//                 level.push_back(start->data);
+                
+//             }
+//             TreeNode* front = pendingNodes.front();
+//             pendingNodes.pop();
+            
+            // 
\ No newline at end of file
diff --git a/binary-tree-maximum-path-sum/README.md b/binary-tree-maximum-path-sum/README.md
new file mode 100644
index 0000000..d17f97a
--- /dev/null
+++ b/binary-tree-maximum-path-sum/README.md
@@ -0,0 +1,29 @@
+<h2>124. Binary Tree Maximum Path Sum</h2><h3>Hard</h3><hr><div><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'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>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>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>
+</div>
\ No newline at end of file
diff --git a/binary-tree-maximum-path-sum/binary-tree-maximum-path-sum.cpp b/binary-tree-maximum-path-sum/binary-tree-maximum-path-sum.cpp
new file mode 100644
index 0000000..26fe647
--- /dev/null
+++ b/binary-tree-maximum-path-sum/binary-tree-maximum-path-sum.cpp
@@ -0,0 +1,17 @@
+class Solution {
+    int maxToRoot(TreeNode *root, int &re) {
+        if (!root) return 0;
+        int l = maxToRoot(root->left, re);
+        int r = maxToRoot(root->right, re);
+        if (l < 0) l = 0;
+        if (r < 0) r = 0;
+        if (l + r + root->val > re) re = l + r + root->val;
+        return root->val += max(l, r);
+    }
+public:
+    int maxPathSum(TreeNode *root) {
+        int max = -2147483648;
+  maxToRoot(root, max);
+        return max;
+    }
+};
\ No newline at end of file
diff --git a/binary-tree-paths/README.md b/binary-tree-paths/README.md
new file mode 100644
index 0000000..66ed67e
--- /dev/null
+++ b/binary-tree-paths/README.md
@@ -0,0 +1,25 @@
+<h2>257. Binary Tree Paths</h2><h3>Easy</h3><hr><div><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>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> ["1-&gt;2-&gt;5","1-&gt;3"]
+</pre>
+
+<p><strong>Example 2:</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>[1, 100]</code>.</li>
+	<li><code>-100 &lt;= Node.val &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/binary-tree-paths/binary-tree-paths.cpp b/binary-tree-paths/binary-tree-paths.cpp
new file mode 100644
index 0000000..a918b7d
--- /dev/null
+++ b/binary-tree-paths/binary-tree-paths.cpp
@@ -0,0 +1,41 @@
+/**
+ * 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:
+  void helper(TreeNode * root, vector<string> & v,string s)
+  {
+    if(root == NULL)
+    {
+      return ;
+    }
+    if(root->left ==NULL && root->right == NULL)
+    {
+      s += to_string(root->val);
+      v.push_back(s);
+      return ;
+    }
+    s += to_string(root->val);
+    s += "->";
+    helper(root->left,v,s);
+    helper(root->right,v,s);
+    return ;
+    
+  }
+    vector<string> binaryTreePaths(TreeNode* root) {
+        if(root == NULL)
+          return {};
+      vector <string> v;
+      string s = "";
+      helper(root,v,s);
+      return v;
+    }
+};
\ No newline at end of file
diff --git a/binary-tree-postorder-traversal/README.md b/binary-tree-postorder-traversal/README.md
new file mode 100644
index 0000000..24f1990
--- /dev/null
+++ b/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/binary-tree-preorder-traversal/README.md b/binary-tree-preorder-traversal/README.md
new file mode 100644
index 0000000..7794c1f
--- /dev/null
+++ b/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/binary-tree-preorder-traversal/binary-tree-preorder-traversal.cpp b/binary-tree-preorder-traversal/binary-tree-preorder-traversal.cpp
new file mode 100644
index 0000000..ee23dff
--- /dev/null
+++ b/binary-tree-preorder-traversal/binary-tree-preorder-traversal.cpp
@@ -0,0 +1,28 @@
+/**
+ * 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:
+    vector<int> preorderTraversal(TreeNode* root) {
+        vector<int> nodes;
+        preorder(root, nodes);
+        return nodes;
+    }
+private:
+    void preorder(TreeNode* root, vector<int>& nodes) {
+        if (!root) {
+            return;
+        }
+        nodes.push_back(root -> val);
+        preorder(root -> left, nodes);
+        preorder(root -> right, nodes);
+    }
+};
\ No newline at end of file
diff --git a/binary-tree-pruning/README.md b/binary-tree-pruning/README.md
new file mode 100644
index 0000000..cf8305a
--- /dev/null
+++ b/binary-tree-pruning/README.md
@@ -0,0 +1,34 @@
+<h2>814. Binary Tree Pruning</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/binary-tree-right-side-view/README.md b/binary-tree-right-side-view/README.md
new file mode 100644
index 0000000..8117c78
--- /dev/null
+++ b/binary-tree-right-side-view/README.md
@@ -0,0 +1,29 @@
+<h2>199. Binary Tree Right Side View</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/binary-tree-right-side-view/binary-tree-right-side-view.cpp b/binary-tree-right-side-view/binary-tree-right-side-view.cpp
new file mode 100644
index 0000000..334791b
--- /dev/null
+++ b/binary-tree-right-side-view/binary-tree-right-side-view.cpp
@@ -0,0 +1,41 @@
+/**
+ * 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:
+    vector<int> rightSideView(TreeNode* root) {
+          if(root == NULL)
+            return {};
+      vector<int> ans;
+        queue <TreeNode*> p;
+        p.push(root);
+        while(p.size())
+        {
+            
+            int n = p.size();
+             for(int i=0;i<n;i++)
+            {
+                TreeNode * front  = p.front();
+                p.pop();
+                
+              if(i == (n-1))
+                  ans.push_back(front->val);
+                
+                if(front->left)
+                    p.push(front->left);
+                if(front->right)
+                    p.push(front->right);
+            }
+            
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/binary-tree-zigzag-level-order-traversal/README.md b/binary-tree-zigzag-level-order-traversal/README.md
new file mode 100644
index 0000000..600d22f
--- /dev/null
+++ b/binary-tree-zigzag-level-order-traversal/README.md
@@ -0,0 +1,29 @@
+<h2>103. Binary Tree Zigzag Level Order Traversal</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/binary-tree-zigzag-level-order-traversal/binary-tree-zigzag-level-order-traversal.cpp b/binary-tree-zigzag-level-order-traversal/binary-tree-zigzag-level-order-traversal.cpp
new file mode 100644
index 0000000..c3a304b
--- /dev/null
+++ b/binary-tree-zigzag-level-order-traversal/binary-tree-zigzag-level-order-traversal.cpp
@@ -0,0 +1,53 @@
+/**
+ * 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:
+    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
+        if(root == NULL)
+            return {};
+      vector<vector<int>> ans;
+        queue <TreeNode*> p;
+        p.push(root);
+        int l = 0;
+        while(p.size())
+        {
+            vector <int> level;
+            int n = p.size();
+            
+            for(int i=0;i<n;i++)
+            {
+                TreeNode * front  = p.front();
+                p.pop();
+                
+                level.push_back(front->val);
+                
+                if(front->left)
+                    p.push(front->left);
+                if(front->right)
+                    p.push(front->right);
+            }
+            
+            if(l != 0)
+            {
+                reverse(level.begin(),level.end());
+                l = 0;
+            } 
+            else
+            {
+                l = 1;
+            }
+            ans.push_back(level);
+           
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/binary-watch/README.md b/binary-watch/README.md
new file mode 100644
index 0000000..a947f89
--- /dev/null
+++ b/binary-watch/README.md
@@ -0,0 +1,37 @@
+<h2>401. Binary Watch</h2><h3>Easy</h3><hr><div><p>A binary watch has 4 LEDs on the top which represent the hours (0-11), and the 6 LEDs on the bottom represent the minutes (0-59). Each LED represents a zero or one, with the least significant bit on the right.</p>
+
+<ul>
+	<li>For example, the below binary watch reads <code>"4:51"</code>.</li>
+</ul>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2021/04/08/binarywatch.jpg" style="width: 500px; height: 500px;"></p>
+
+<p>Given an integer <code>turnedOn</code> which represents the number of LEDs that are currently on, return <em>all possible times the watch could represent</em>. You may return the answer in <strong>any order</strong>.</p>
+
+<p>The hour must not contain a leading zero.</p>
+
+<ul>
+	<li>For example, <code>"01:00"</code> is not valid. It should be <code>"1:00"</code>.</li>
+</ul>
+
+<p>The minute must be consist of two digits and may contain a leading zero.</p>
+
+<ul>
+	<li>For example, <code>"10:2"</code> is not valid. It should be <code>"10:02"</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> turnedOn = 1
+<strong>Output:</strong> ["0:01","0:02","0:04","0:08","0:16","0:32","1:00","2:00","4:00","8:00"]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> turnedOn = 9
+<strong>Output:</strong> []
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= turnedOn &lt;= 10</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/binary-watch/binary-watch.cpp b/binary-watch/binary-watch.cpp
new file mode 100644
index 0000000..2f15693
--- /dev/null
+++ b/binary-watch/binary-watch.cpp
@@ -0,0 +1,25 @@
+class Solution {
+public:
+
+    void helper(vector<string>& res,vector<int>& chart,int&num,int curr,int idx,int hour,int min){
+        if(hour>11||min>59) return;
+        if(curr==num){
+            string tmp=to_string(hour)+":"+((min<10)?"0":"")+to_string(min);
+            res.push_back(tmp);
+            return;
+        }
+        for(int i=idx;i<chart.size();i++){
+            if(i<4)
+                helper(res,chart,num,curr+1,i+1,hour+chart[i],min);
+            else
+                helper(res,chart,num,curr+1,i+1,hour,min+chart[i]);
+        }
+    }
+    
+    vector<string> readBinaryWatch(int num) {
+        vector<int> chart({1,2,4,8,1,2,4,8,16,32});
+        vector<string> res;
+        helper(res,chart,num,0,0,0,0);
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/build-array-from-permutation/README.md b/build-array-from-permutation/README.md
new file mode 100644
index 0000000..a2f3be6
--- /dev/null
+++ b/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/build-array-from-permutation/build-array-from-permutation.cpp b/build-array-from-permutation/build-array-from-permutation.cpp
new file mode 100644
index 0000000..2fb3780
--- /dev/null
+++ b/build-array-from-permutation/build-array-from-permutation.cpp
@@ -0,0 +1,13 @@
+class Solution {
+public:
+    vector<int> buildArray(vector<int>& nums) {
+        int maxNum = nums.size();
+        for(int i=0; i<nums.size(); i++) {
+            nums[i] = nums[i] + (nums[nums[i]]%maxNum )*maxNum;
+        }
+        for(int i=0; i<nums.size(); i++) {
+            nums[i] = nums[i]/maxNum;
+        }
+        return nums;
+    }
+};
\ No newline at end of file
diff --git a/burst-balloons/README.md b/burst-balloons/README.md
new file mode 100644
index 0000000..4b89ee1
--- /dev/null
+++ b/burst-balloons/README.md
@@ -0,0 +1,30 @@
+<h2>312. Burst Balloons</h2><h3>Hard</h3><hr><div><p>You are given <code>n</code> balloons, indexed from <code>0</code> to <code>n - 1</code>. Each balloon is painted with a number on it represented by an array <code>nums</code>. You are asked to burst all the balloons.</p>
+
+<p>If you burst the <code>i<sup>th</sup></code> balloon, you will get <code>nums[i - 1] * nums[i] * nums[i + 1]</code> coins. If <code>i - 1</code> or <code>i + 1</code> goes out of bounds of the array, then treat it as if there is a balloon with a <code>1</code> painted on it.</p>
+
+<p>Return <em>the maximum coins you can collect by bursting the balloons wisely</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,1,5,8]
+<strong>Output:</strong> 167
+<strong>Explanation:</strong>
+nums = [3,1,5,8] --&gt; [3,5,8] --&gt; [3,8] --&gt; [8] --&gt; []
+coins =  3*1*5    +   3*5*8   +  1*3*8  + 1*8*1 = 167</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,5]
+<strong>Output:</strong> 10
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 &lt;= n &lt;= 500</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/burst-balloons/burst-balloons.cpp b/burst-balloons/burst-balloons.cpp
new file mode 100644
index 0000000..c64becd
--- /dev/null
+++ b/burst-balloons/burst-balloons.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int maxCoins(vector<int>& nums) {
+        int n = nums.size();
+        if(n == 0)return 0;
+        vector<vector<int>> dp(n,vector<int> (n));
+        
+        for(int gap = 0; gap < n;gap++ )
+        {
+            for(int i=0,j = gap; j<n;j++,i++)
+            {
+                int maxi = INT_MIN;
+                for(int k = i;k<=j;k++)
+                {
+                    int l = (i==k ? 0 : dp[i][k-1]);
+                    int r = (j == k ? 0 : dp[k+1][j]);
+                    int val = (i == 0 ? 1 : nums[i-1] ) * nums[k] * (j == n-1 ? 1 : nums[j+1]);
+                    
+                    int sum = l+r+val;
+                    
+                    maxi  = max(maxi,sum);
+                }
+                dp[i][j] = maxi;
+            }
+        }
+        
+        return dp[0][n-1];
+    }
+};
\ No newline at end of file
diff --git a/climbing-stairs/README.md b/climbing-stairs/README.md
new file mode 100644
index 0000000..057c39e
--- /dev/null
+++ b/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/climbing-stairs/climbing-stairs.cpp b/climbing-stairs/climbing-stairs.cpp
new file mode 100644
index 0000000..fef2fc3
--- /dev/null
+++ b/climbing-stairs/climbing-stairs.cpp
@@ -0,0 +1,13 @@
+class Solution {
+public:
+int climbStairs(int n) {
+        int t[n+1];
+        for(int i=0;i<=n;i++) t[i]=0;
+        t[1]=1;
+        if(n>=2) t[2]=2;
+        for(int i=3;i<=n;i++){
+             t[i] = t[i-1]+t[i-2];    
+        }
+        return t[n];
+    }
+};
\ No newline at end of file
diff --git a/clone-graph/README.md b/clone-graph/README.md
new file mode 100644
index 0000000..4fe35c9
--- /dev/null
+++ b/clone-graph/README.md
@@ -0,0 +1,65 @@
+<h2>133. Clone Graph</h2><h3>Medium</h3><hr><div><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's value is the same as the node'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>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/11/04/133_clone_graph_question.png" style="width: 500px; height: 550px;">
+<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)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
+4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
+</pre>
+
+<p><strong>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>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><strong>Example 4:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/01/07/graph-1.png" style="width: 272px; height: 133px;">
+<pre><strong>Input:</strong> adjList = [[2],[1]]
+<strong>Output:</strong> [[2],[1]]
+</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>
+</div>
\ No newline at end of file
diff --git a/coin-change-2/README.md b/coin-change-2/README.md
new file mode 100644
index 0000000..96c3439
--- /dev/null
+++ b/coin-change-2/README.md
@@ -0,0 +1,43 @@
+<h2>518. Coin Change 2</h2><h3>Medium</h3><hr><div><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 number of combinations that make up that amount</em>. If that amount of money cannot be made up by any combination of the coins, return <code>0</code>.</p>
+
+<p>You may assume that you have an infinite number of each kind of coin.</p>
+
+<p>The answer is <strong>guaranteed</strong> to fit into a signed <strong>32-bit</strong> integer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> amount = 5, coins = [1,2,5]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> there are four ways to make up the amount:
+5=5
+5=2+2+1
+5=2+1+1+1
+5=1+1+1+1+1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> amount = 3, coins = [2]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> the amount of 3 cannot be made up just with coins of 2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> amount = 10, coins = [10]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= coins.length &lt;= 300</code></li>
+	<li><code>1 &lt;= coins[i] &lt;= 5000</code></li>
+	<li>All the values of <code>coins</code> are <strong>unique</strong>.</li>
+	<li><code>0 &lt;= amount &lt;= 5000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/coin-change-2/coin-change-2.cpp b/coin-change-2/coin-change-2.cpp
new file mode 100644
index 0000000..17d564e
--- /dev/null
+++ b/coin-change-2/coin-change-2.cpp
@@ -0,0 +1,38 @@
+class Solution {
+public:
+    
+    int change(int amount, vector<int>& coins) {
+        int n = coins.size();
+        if(amount == 0) {
+            return 1;
+        }
+        if(n==0)
+          return 0;
+        vector<vector<int>> dp;
+        dp.resize(n+2,vector<int>(amount+2,-1));
+        
+        for(int i=0;i<n+1;i++)
+        {
+            dp[i][0] = 1;
+        }
+        
+        for(int i=0;i<amount+1;i++)
+        {
+            dp[0][i] = 0;
+        }
+        
+        for(int i=1;i<n+1;i++)
+        {
+            for(int j=1;j<amount+1;j++)
+            {
+                if(coins[i-1] > j) {
+                    dp[i][j] = dp[i-1][j];
+                } else {
+                    dp[i][j] = dp[i-1][j]+dp[i][j-coins[i-1]];
+                }
+            }
+        }
+        return dp[n][amount];
+        
+    }
+};
\ No newline at end of file
diff --git a/coin-change/README.md b/coin-change/README.md
new file mode 100644
index 0000000..f3deb93
--- /dev/null
+++ b/coin-change/README.md
@@ -0,0 +1,35 @@
+<h2>322. Coin Change</h2><h3>Medium</h3><hr><div><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>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>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> coins = [2], amount = 3
+<strong>Output:</strong> -1
+</pre>
+
+<p><strong>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>
+</div>
\ No newline at end of file
diff --git a/coin-change/coin-change.cpp b/coin-change/coin-change.cpp
new file mode 100644
index 0000000..503e101
--- /dev/null
+++ b/coin-change/coin-change.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int coinChange(vector<int>& coins, int amount) {
+         int Max = amount + 1;
+        vector<int> dp(amount + 1, Max);
+        dp[0] = 0;
+        for (int i = 1; i <= amount; i++) {
+            for (int j = 0; j < coins.size(); j++) {
+                if (coins[j] <= i) {
+                    dp[i] = min(dp[i], dp[i - coins[j]] + 1);
+                }
+            }
+        }
+        return dp[amount] > amount ? -1 : dp[amount];
+        
+    }
+};
\ No newline at end of file
diff --git a/combination-sum-iv/README.md b/combination-sum-iv/README.md
new file mode 100644
index 0000000..8504e57
--- /dev/null
+++ b/combination-sum-iv/README.md
@@ -0,0 +1,40 @@
+<h2>377. Combination Sum IV</h2><h3>Medium</h3><hr><div><p>Given an array of <strong>distinct</strong> integers <code>nums</code> and a target integer <code>target</code>, return <em>the number of possible combinations that add up to</em>&nbsp;<code>target</code>.</p>
+
+<p>The test cases are generated so that the answer can 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], target = 4
+<strong>Output:</strong> 7
+<strong>Explanation:</strong>
+The possible combination ways are:
+(1, 1, 1, 1)
+(1, 1, 2)
+(1, 2, 1)
+(1, 3)
+(2, 1, 1)
+(2, 2)
+(3, 1)
+Note that different sequences are counted as different combinations.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [9], target = 3
+<strong>Output:</strong> 0
+</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;= 1000</code></li>
+	<li>All the elements of <code>nums</code> are <strong>unique</strong>.</li>
+	<li><code>1 &lt;= target &lt;= 1000</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> What if negative numbers are allowed in the given array? How does it change the problem? What limitation we need to add to the question to allow negative numbers?</p>
+</div>
\ No newline at end of file
diff --git a/combination-sum-iv/combination-sum-iv.cpp b/combination-sum-iv/combination-sum-iv.cpp
new file mode 100644
index 0000000..350d888
--- /dev/null
+++ b/combination-sum-iv/combination-sum-iv.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+ int combinationSum4(vector<int>& nums, int target) {
+	sort(begin(nums), end(nums));
+    vector<uint> dp(target + 1); dp[0] = 1;
+	for (int curTarget = 1; curTarget <= target; curTarget++) 
+        for (auto& num : nums) 
+            if (num <= curTarget)  dp[curTarget] += dp[curTarget - num];
+            else break;
+    return dp[target];
+}
+};
\ No newline at end of file
diff --git a/combination-sum/README.md b/combination-sum/README.md
new file mode 100644
index 0000000..fd7ca62
--- /dev/null
+++ b/combination-sum/README.md
@@ -0,0 +1,51 @@
+<h2>39. Combination Sum</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><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> candidates = [1], target = 1
+<strong>Output:</strong> [[1]]
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> candidates = [1], target = 2
+<strong>Output:</strong> [[1,1]]
+</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/combination-sum/combination-sum.cpp b/combination-sum/combination-sum.cpp
new file mode 100644
index 0000000..7aebb52
--- /dev/null
+++ b/combination-sum/combination-sum.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+
+vector<vector<int>>result;
+vector<int>current;
+
+void function(vector<int>& candidates,int target,int index)
+{
+    if(target==0){
+        result.push_back(current);
+        return;
+    }
+    
+    if(index==candidates.size() || target<0)return;
+    
+    current.push_back(candidates[index]);
+    function(candidates,target-candidates[index],index);
+    current.pop_back();
+    function(candidates,target,index+1);      
+}
+
+vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+    function(candidates,target,0);
+    return result;
+}
+};
\ No newline at end of file
diff --git a/combine-two-tables/README.md b/combine-two-tables/README.md
new file mode 100644
index 0000000..01eeded
--- /dev/null
+++ b/combine-two-tables/README.md
@@ -0,0 +1,32 @@
+<h2>175. Combine Two Tables</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    |
++-------------+---------+
+| PersonId    | int     |
+| FirstName   | varchar |
+| LastName    | varchar |
++-------------+---------+
+PersonId is the primary key column for this table.
+</pre>
+
+<p>Table: <code>Address</code></p>
+
+<pre>+-------------+---------+
+| Column Name | Type    |
++-------------+---------+
+| AddressId   | int     |
+| PersonId    | int     |
+| City        | varchar |
+| State       | varchar |
++-------------+---------+
+AddressId is the primary key column for this table.
+</pre>
+
+<p>&nbsp;</p>
+
+<p>Write a SQL query for a report that provides the following information for each person in the Person table, regardless if there is an address for each of those people:</p>
+
+<pre>FirstName, LastName, City, State
+</pre>
+</div>
\ No newline at end of file
diff --git a/combine-two-tables/combine-two-tables.sql b/combine-two-tables/combine-two-tables.sql
new file mode 100644
index 0000000..6658ef3
--- /dev/null
+++ b/combine-two-tables/combine-two-tables.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+SELECT Person.FirstName, Person.LastName, Address.City, Address.State
+FROM Person LEFT JOIN Address
+on Person.PersonId = Address.PersonId
\ No newline at end of file
diff --git a/consecutive-characters/README.md b/consecutive-characters/README.md
new file mode 100644
index 0000000..561fd51
--- /dev/null
+++ b/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/consecutive-characters/consecutive-characters.cpp b/consecutive-characters/consecutive-characters.cpp
new file mode 100644
index 0000000..6ebd418
--- /dev/null
+++ b/consecutive-characters/consecutive-characters.cpp
@@ -0,0 +1,27 @@
+class Solution {
+public:
+    int maxPower(string s) {
+        
+        if(s.length() <= 1)
+            return 1;
+        
+        int temp = 1;
+        int count = 0;
+        for(int i=1;i<s.length();i++)
+        {
+            if(s[i] != s[i-1])
+            {
+               count = max(count , temp);
+                temp = 1;
+            }
+            else
+            {
+                temp++;
+            }
+        }
+        count = max(count , temp);
+        return count;
+        
+        
+    }
+};
\ No newline at end of file
diff --git a/construct-binary-tree-from-inorder-and-postorder-traversal/README.md b/construct-binary-tree-from-inorder-and-postorder-traversal/README.md
new file mode 100644
index 0000000..94dd949
--- /dev/null
+++ b/construct-binary-tree-from-inorder-and-postorder-traversal/README.md
@@ -0,0 +1,28 @@
+<h2>106. Construct Binary Tree from Inorder and Postorder Traversal</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/construct-binary-tree-from-inorder-and-postorder-traversal/construct-binary-tree-from-inorder-and-postorder-traversal.cpp b/construct-binary-tree-from-inorder-and-postorder-traversal/construct-binary-tree-from-inorder-and-postorder-traversal.cpp
new file mode 100644
index 0000000..c874b50
--- /dev/null
+++ b/construct-binary-tree-from-inorder-and-postorder-traversal/construct-binary-tree-from-inorder-and-postorder-traversal.cpp
@@ -0,0 +1,51 @@
+/**
+ * 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:
+  TreeNode * helper(vector<int>& postorder, vector<int>& inorder,int poss,int pose,int ins,int ine)
+    {
+      if(poss > pose)return NULL;
+      
+      
+      int rootdata = postorder[pose];
+      int rootIndex = -1;
+      for(int i=ins;i<=ine;i++)
+      {
+        if(inorder[i] == rootdata)
+        {
+          rootIndex = i;
+          break;
+        } 
+      }
+  
+      int lins = ins;
+      int line = rootIndex-1;
+      int rins = rootIndex + 1;
+      int rine = ine;
+      int lposs = poss;
+      int lpose = lposs + (line-lins);
+      int rposs = lpose + 1;
+      int rpose = pose-1;
+      
+      TreeNode * root = new TreeNode(rootdata);
+      root->left = helper(postorder,inorder,lposs,lpose,lins,line);
+      root->right = helper(postorder,inorder,rposs,rpose,rins,rine);
+      
+      return root;
+      
+    }
+  
+  
+    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
+    return helper(postorder,inorder,0,postorder.size()-1,0,inorder.size()-1);
+    }
+};
\ No newline at end of file
diff --git a/construct-binary-tree-from-preorder-and-inorder-traversal/README.md b/construct-binary-tree-from-preorder-and-inorder-traversal/README.md
new file mode 100644
index 0000000..63363b6
--- /dev/null
+++ b/construct-binary-tree-from-preorder-and-inorder-traversal/README.md
@@ -0,0 +1,28 @@
+<h2>105. Construct Binary Tree from Preorder and Inorder Traversal</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/construct-binary-tree-from-preorder-and-inorder-traversal/construct-binary-tree-from-preorder-and-inorder-traversal.cpp b/construct-binary-tree-from-preorder-and-inorder-traversal/construct-binary-tree-from-preorder-and-inorder-traversal.cpp
new file mode 100644
index 0000000..4cf8e46
--- /dev/null
+++ b/construct-binary-tree-from-preorder-and-inorder-traversal/construct-binary-tree-from-preorder-and-inorder-traversal.cpp
@@ -0,0 +1,51 @@
+/**
+ * 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:
+    TreeNode * helper(vector<int>& preorder, vector<int>& inorder,int pres,int pree,int ins,int ine)
+    {
+      if(pres > pree)return NULL;
+      
+      
+      int rootdata = preorder[pres];
+      int rootIndex = -1;
+      for(int i=ins;i<=ine;i++)
+      {
+        if(inorder[i] == rootdata)
+        {
+          rootIndex = i;
+          break;
+        } 
+      }
+  
+      int lins = ins;
+      int line = rootIndex-1;
+      int rins = rootIndex + 1;
+      int rine = ine;
+      int lpres =  pres + 1;
+      int lpree = lpres + (line-lins);
+      int rpres = lpree + 1;
+      int rpree = pree;
+      
+      TreeNode * root = new TreeNode(rootdata);
+      root->left = helper(preorder,inorder,lpres,lpree,lins,line);
+      root->right = helper(preorder,inorder,rpres,rpree,rins,rine);
+      
+      return root;
+      
+    }
+  
+    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
+      
+        return helper(preorder,inorder,0,preorder.size()-1,0,inorder.size()-1);
+    }
+};
\ No newline at end of file
diff --git a/contains-duplicate-ii/README.md b/contains-duplicate-ii/README.md
new file mode 100644
index 0000000..1e79687
--- /dev/null
+++ b/contains-duplicate-ii/README.md
@@ -0,0 +1,30 @@
+<h2>219. Contains Duplicate II</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> and an integer <code>k</code>, return <code>true</code> if there are two <strong>distinct indices</strong> <code>i</code> and <code>j</code> in the array such that <code>nums[i] == nums[j]</code> and <code>abs(i - j) &lt;= k</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,1], k = 3
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,0,1,1], k = 1
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,1,2,3], k = 2
+<strong>Output:</strong> false
+</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>
+	<li><code>0 &lt;= k &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/contains-duplicate-ii/contains-duplicate-ii.cpp b/contains-duplicate-ii/contains-duplicate-ii.cpp
new file mode 100644
index 0000000..43f158a
--- /dev/null
+++ b/contains-duplicate-ii/contains-duplicate-ii.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    bool containsNearbyDuplicate(vector<int>& nums, int k) {
+        unordered_map<int, int> mp;
+        for(int i = 0; i < nums.size(); i++) {
+            if(mp.count(nums[i])){
+                int diff = abs(mp[nums[i]] - i);
+                if (diff <= k)return true;  
+            }
+            mp[nums[i]] = i;
+        }
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/contains-duplicate/README.md b/contains-duplicate/README.md
new file mode 100644
index 0000000..3c222d4
--- /dev/null
+++ b/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/contains-duplicate/contains-duplicate.cpp b/contains-duplicate/contains-duplicate.cpp
new file mode 100644
index 0000000..8363cd1
--- /dev/null
+++ b/contains-duplicate/contains-duplicate.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        
+        map<int,int> m;
+        int i=0;
+        for(i=0;i<nums.size();i++)
+        {
+            m[nums[i]]++;
+            
+            if(m[nums[i]] == 2)
+                break;
+        }
+        
+        if(nums.size() == i)
+            return false;
+        
+        return true;
+            
+        
+    }
+};
\ No newline at end of file
diff --git a/convert-binary-number-in-a-linked-list-to-integer/README.md b/convert-binary-number-in-a-linked-list-to-integer/README.md
new file mode 100644
index 0000000..d1ba6d7
--- /dev/null
+++ b/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/convert-binary-number-in-a-linked-list-to-integer/convert-binary-number-in-a-linked-list-to-integer.cpp b/convert-binary-number-in-a-linked-list-to-integer/convert-binary-number-in-a-linked-list-to-integer.cpp
new file mode 100644
index 0000000..4d37430
--- /dev/null
+++ b/convert-binary-number-in-a-linked-list-to-integer/convert-binary-number-in-a-linked-list-to-integer.cpp
@@ -0,0 +1,22 @@
+/**
+ * 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:
+    int getDecimalValue(ListNode* head) {
+        int ans = 0;
+        while(head != NULL)
+        {
+            ans = (ans<<1) + head->val;
+            head = head->next;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/convert-sorted-array-to-binary-search-tree/README.md b/convert-sorted-array-to-binary-search-tree/README.md
new file mode 100644
index 0000000..f590b05
--- /dev/null
+++ b/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/convert-sorted-array-to-binary-search-tree/convert-sorted-array-to-binary-search-tree.cpp b/convert-sorted-array-to-binary-search-tree/convert-sorted-array-to-binary-search-tree.cpp
new file mode 100644
index 0000000..e4bb3bb
--- /dev/null
+++ b/convert-sorted-array-to-binary-search-tree/convert-sorted-array-to-binary-search-tree.cpp
@@ -0,0 +1,38 @@
+/**
+ * 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:
+    
+    TreeNode* helper(vector<int>& nums,int start,int end)
+    {
+      if(start<= end)
+      {
+        int mid = (start+end)/2;
+        TreeNode * root = new TreeNode(nums[mid]);
+        TreeNode * left = helper(nums,start,mid-1);
+        TreeNode * right = helper(nums,mid+1,end);
+        root->left = left;
+        root->right = right;
+        return root;
+      }
+      return NULL;
+    }
+  
+    TreeNode* sortedArrayToBST(vector<int>& nums) {
+        
+      if(nums.size()==0)
+          return NULL;
+      
+      return helper(nums,0,nums.size()-1);
+      
+    }
+};
\ No newline at end of file
diff --git a/copy-list-with-random-pointer/README.md b/copy-list-with-random-pointer/README.md
new file mode 100644
index 0000000..fec390f
--- /dev/null
+++ b/copy-list-with-random-pointer/README.md
@@ -0,0 +1,54 @@
+<h2>138. Copy List with Random Pointer</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><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+<strong>Explanation:</strong> The given linked list is empty (null pointer), so return null.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= n &lt;= 1000</code></li>
+	<li><code>-10000 &lt;= Node.val &lt;= 10000</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/copy-list-with-random-pointer/copy-list-with-random-pointer.cpp b/copy-list-with-random-pointer/copy-list-with-random-pointer.cpp
new file mode 100644
index 0000000..a2c1b70
--- /dev/null
+++ b/copy-list-with-random-pointer/copy-list-with-random-pointer.cpp
@@ -0,0 +1,61 @@
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* next;
+    Node* random;
+    
+    Node(int _val) {
+        val = _val;
+        next = NULL;
+        random = NULL;
+    }
+};
+*/
+
+class Solution {
+public:
+    Node* copyRandomList(Node* head) {
+        
+        if(head == NULL)return NULL;
+        
+        Node * it = head;
+        Node * front = head;
+        
+        while(it != NULL)
+        {
+            front = it->next;
+            Node * newNode = new Node(it->val);
+            it->next = newNode;
+            newNode->next = front;
+            it = front;
+        }
+        
+        it = head;
+        front = NULL;
+        while(it != NULL)
+        {
+            if(it->random)
+            {
+                it->next->random = it->random->next;
+            }
+            it = it->next->next;
+        }
+        
+        Node * dummy = new Node(0);
+        Node * temp = dummy;
+        
+        it = head;
+        while(it != NULL)
+        {
+            front = it->next->next;
+            temp->next = it->next;
+            it->next = front;
+            it = front;
+            temp = temp->next;
+        }
+        
+        return dummy->next;
+    }
+};
\ No newline at end of file
diff --git a/count-number-of-teams/README.md b/count-number-of-teams/README.md
new file mode 100644
index 0000000..de2821c
--- /dev/null
+++ b/count-number-of-teams/README.md
@@ -0,0 +1,42 @@
+<h2>1395. Count Number of Teams</h2><h3>Medium</h3><hr><div><p>There are <code>n</code> soldiers standing in a line. Each soldier is assigned a <strong>unique</strong> <code>rating</code> value.</p>
+
+<p>You have to form a team of 3 soldiers amongst them under the following rules:</p>
+
+<ul>
+	<li>Choose 3 soldiers with index (<code>i</code>, <code>j</code>, <code>k</code>) with rating (<code>rating[i]</code>, <code>rating[j]</code>, <code>rating[k]</code>).</li>
+	<li>A team is valid if: (<code>rating[i] &lt; rating[j] &lt; rating[k]</code>) or (<code>rating[i] &gt; rating[j] &gt; rating[k]</code>) where (<code>0 &lt;= i &lt; j &lt; k &lt; n</code>).</li>
+</ul>
+
+<p>Return the number of teams you can form given the conditions. (soldiers can be part of multiple teams).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> rating = [2,5,3,4,1]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> We can form three teams given the conditions. (2,3,4), (5,4,1), (5,3,1). 
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> rating = [2,1,3]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> We can't form any team given the conditions.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> rating = [1,2,3,4]
+<strong>Output:</strong> 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == rating.length</code></li>
+	<li><code>3 &lt;= n &lt;= 1000</code></li>
+	<li><code>1 &lt;= rating[i] &lt;= 10<sup>5</sup></code></li>
+	<li>All the integers in <code>rating</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/count-sorted-vowel-strings/README.md b/count-sorted-vowel-strings/README.md
new file mode 100644
index 0000000..a19f772
--- /dev/null
+++ b/count-sorted-vowel-strings/README.md
@@ -0,0 +1,34 @@
+<h2>1641. Count Sorted Vowel Strings</h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, return <em>the number of strings of length </em><code>n</code><em> that consist only of vowels (</em><code>a</code><em>, </em><code>e</code><em>, </em><code>i</code><em>, </em><code>o</code><em>, </em><code>u</code><em>) and are <strong>lexicographically sorted</strong>.</em></p>
+
+<p>A string <code>s</code> is <strong>lexicographically sorted</strong> if for all valid <code>i</code>, <code>s[i]</code> is the same as or comes before <code>s[i+1]</code> in the alphabet.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> The 5 sorted strings that consist of vowels only are <code>["a","e","i","o","u"].</code>
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> 15
+<strong>Explanation:</strong> The 15 sorted strings that consist of vowels only are
+["aa","ae","ai","ao","au","ee","ei","eo","eu","ii","io","iu","oo","ou","uu"].
+Note that "ea" is not a valid string since 'e' comes after 'a' in the alphabet.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 33
+<strong>Output:</strong> 66045
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 50</code>&nbsp;</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/count-substrings-that-differ-by-one-character/README.md b/count-substrings-that-differ-by-one-character/README.md
new file mode 100644
index 0000000..9068aa5
--- /dev/null
+++ b/count-substrings-that-differ-by-one-character/README.md
@@ -0,0 +1,52 @@
+<h2>1638. Count Substrings That Differ by One Character</h2><h3>Medium</h3><hr><div><p>Given two strings <code>s</code> and <code>t</code>, find the number of ways you can choose a non-empty substring of <code>s</code> and replace a <strong>single character</strong> by a different character such that the resulting substring is a substring of <code>t</code>. In other words, find the number of substrings in <code>s</code> that differ from some substring in <code>t</code> by <strong>exactly</strong> one character.</p>
+
+<p>For example, the underlined substrings in <code>"<u>compute</u>r"</code> and <code>"<u>computa</u>tion"</code> only differ by the <code>'e'</code>/<code>'a'</code>, so this is a valid way.</p>
+
+<p>Return <em>the number of substrings that satisfy the condition above.</em></p>
+
+<p>A <strong>substring</strong> is a contiguous sequence of characters within a string.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "aba", t = "baba"
+<strong>Output:</strong> 6
+<strong>Explanation: </strong>The following are the pairs of substrings from s and t that differ by exactly 1 character:
+("<u>a</u>ba", "<u>b</u>aba")
+("<u>a</u>ba", "ba<u>b</u>a")
+("ab<u>a</u>", "<u>b</u>aba")
+("ab<u>a</u>", "ba<u>b</u>a")
+("a<u>b</u>a", "b<u>a</u>ba")
+("a<u>b</u>a", "bab<u>a</u>")
+The underlined portions are the substrings that are chosen from s and t.
+</pre>
+​​<strong>Example 2:</strong>
+
+<pre><strong>Input:</strong> s = "ab", t = "bb"
+<strong>Output:</strong> 3
+<strong>Explanation: </strong>The following are the pairs of substrings from s and t that differ by 1 character:
+("<u>a</u>b", "<u>b</u>b")
+("<u>a</u>b", "b<u>b</u>")
+("<u>ab</u>", "<u>bb</u>")
+​​​​The underlined portions are the substrings that are chosen from s and t.
+</pre>
+<strong>Example 3:</strong>
+
+<pre><strong>Input:</strong> s = "a", t = "a"
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> s = "abe", t = "bbc"
+<strong>Output:</strong> 10
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length, t.length &lt;= 100</code></li>
+	<li><code>s</code> and <code>t</code> consist of lowercase English letters only.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/count-substrings-that-differ-by-one-character/count-substrings-that-differ-by-one-character.cpp b/count-substrings-that-differ-by-one-character/count-substrings-that-differ-by-one-character.cpp
new file mode 100644
index 0000000..8aa82dc
--- /dev/null
+++ b/count-substrings-that-differ-by-one-character/count-substrings-that-differ-by-one-character.cpp
@@ -0,0 +1,54 @@
+class Solution {
+public:
+    int countSubstrings(string s, string t) {
+        // dp[i][j] := longest substring ends at s[i] and t[j] such that they are equal
+		// dp2[i][j] := longest substring starts at s[i] and t[j] such that they are equal
+        int m = s.length(), n = t.length();
+        vector<vector<int>> dp(m + 2, vector<int>(n + 2));
+        vector<vector<int>> dp2(m + 2, vector<int>(n + 2));
+        
+        {
+            dp[1][1] = s[0] == t[0];
+
+            for (int i = 1; i <= m; i++)
+                dp[i][1] = s[i - 1] == t[0];
+
+            for (int j = 1; j <= n; j++)
+                dp[1][j] = s[0] == t[j - 1];
+
+            for (int i = 2; i <= m; i++)
+                for (int j = 2; j <= n; j++) {
+                    if (s[i - 1] == t[j - 1])
+                        dp[i][j] = 1 + dp[i - 1][j - 1];
+                }
+        }
+        
+        {
+            dp2[m][n] = s[m - 1] == t[n - 1];
+            
+            for (int i = 1; i <= m; i++)
+                dp2[i][n] = s[i - 1] == t[n - 1];
+
+            for (int j = 1; j <= n; j++)
+                dp2[m][j] = s[m - 1] == t[j - 1];
+            
+            for (int i = m - 1; i >= 1; i--)
+                for (int j = n - 1; j >= 1; j--) {
+                    if (s[i - 1] == t[j - 1])
+                        dp2[i][j] = 1 + dp2[i + 1][j + 1];
+                }
+        }
+        
+        int res = 0;
+        
+        for (int i = 0; i < m; i++)
+            for (int j = 0; j < n; j++) {
+                if (s[i] != t[j]) {
+                    res += (dp[i][j] + 1) * (dp2[i + 2][j + 2] + 1);
+                }
+            }
+
+        return res;
+        
+    }
+};
\ No newline at end of file
diff --git a/count-triplets-that-can-form-two-arrays-of-equal-xor/README.md b/count-triplets-that-can-form-two-arrays-of-equal-xor/README.md
new file mode 100644
index 0000000..b01876f
--- /dev/null
+++ b/count-triplets-that-can-form-two-arrays-of-equal-xor/README.md
@@ -0,0 +1,54 @@
+<h2>1442. Count Triplets That Can Form Two Arrays of Equal XOR</h2><h3>Medium</h3><hr><div><p>Given an array of&nbsp;integers <code>arr</code>.</p>
+
+<p>We want to select three indices <code>i</code>, <code>j</code> and <code>k</code> where <code>(0 &lt;= i &lt; j &lt;= k &lt; arr.length)</code>.</p>
+
+<p>Let's define <code>a</code> and <code>b</code> as follows:</p>
+
+<ul>
+	<li><code>a = arr[i] ^ arr[i + 1] ^ ... ^ arr[j - 1]</code></li>
+	<li><code>b = arr[j] ^ arr[j + 1] ^ ... ^ arr[k]</code></li>
+</ul>
+
+<p>Note that <strong>^</strong> denotes the <strong>bitwise-xor</strong> operation.</p>
+
+<p>Return <em>the number of triplets</em> (<code>i</code>, <code>j</code> and <code>k</code>) Where <code>a == b</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [2,3,1,6,7]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The triplets are (0,1,2), (0,2,2), (2,3,4) and (2,4,4)
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,1,1,1,1]
+<strong>Output:</strong> 10
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [2,3]
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,3,5,7,9]
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> arr = [7,11,12,9,5,2,7,17,22]
+<strong>Output:</strong> 8
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 300</code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 10^8</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/course-schedule-ii/README.md b/course-schedule-ii/README.md
new file mode 100644
index 0000000..363108b
--- /dev/null
+++ b/course-schedule-ii/README.md
@@ -0,0 +1,42 @@
+<h2>210. Course Schedule II</h2><h3>Medium</h3><hr><div><p>There are a total of <code>numCourses</code> courses you have to take, labeled from <code>0</code> to <code>numCourses - 1</code>. You are given an array <code>prerequisites</code> where <code>prerequisites[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that you <strong>must</strong> take course <code>b<sub>i</sub></code> first if you want to take course <code>a<sub>i</sub></code>.</p>
+
+<ul>
+	<li>For example, the pair <code>[0, 1]</code>, indicates that to take course <code>0</code> you have to first take course <code>1</code>.</li>
+</ul>
+
+<p>Return <em>the ordering of courses you should take to finish all courses</em>. If there are many valid answers, return <strong>any</strong> of them. If it is impossible to finish all courses, return <strong>an empty array</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> numCourses = 2, prerequisites = [[1,0]]
+<strong>Output:</strong> [0,1]
+<strong>Explanation:</strong> There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
+<strong>Output:</strong> [0,2,1,3]
+<strong>Explanation:</strong> There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
+So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> numCourses = 1, prerequisites = []
+<strong>Output:</strong> [0]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= numCourses &lt;= 2000</code></li>
+	<li><code>0 &lt;= prerequisites.length &lt;= numCourses * (numCourses - 1)</code></li>
+	<li><code>prerequisites[i].length == 2</code></li>
+	<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt; numCourses</code></li>
+	<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
+	<li>All the pairs <code>[a<sub>i</sub>, b<sub>i</sub>]</code> are <strong>distinct</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/course-schedule-ii/course-schedule-ii.cpp b/course-schedule-ii/course-schedule-ii.cpp
new file mode 100644
index 0000000..058a519
--- /dev/null
+++ b/course-schedule-ii/course-schedule-ii.cpp
@@ -0,0 +1,37 @@
+class Solution {
+public:
+    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
+       
+        vector<int>adj[numCourses];
+        queue<int>q;
+        vector<int>indegree(numCourses,0);
+        //store 
+         for(int i =0; i< prerequisites.size(); i++ ){
+            adj[prerequisites[i][1]].push_back(prerequisites[i][0]);
+        }
+        //indegree u -> v
+        for(int i =0; i < prerequisites.size(); i++){
+            indegree[prerequisites[i][0]]++;
+            
+        }
+        //push into q,indegree having 0
+        for(int i =0; i< indegree.size(); i++){
+            if(indegree[i] == 0)q.push(i);
+        }
+        vector<int>result;
+        //Simple BFS and keep storing indegree values equal to 0 into result vector
+        while(!q.empty()){
+           int v = q.front();
+            q.pop();
+            for(auto it : adj[v]){
+                indegree[it]--;
+                 if(indegree[it] == 0)q.push(it);
+            }
+            result.emplace_back(v);
+        }
+        //check case 
+        if (result.size() != numCourses)
+        result.clear();
+        return result;
+    }
+};
\ No newline at end of file
diff --git a/course-schedule/README.md b/course-schedule/README.md
new file mode 100644
index 0000000..9ce82ab
--- /dev/null
+++ b/course-schedule/README.md
@@ -0,0 +1,36 @@
+<h2>207. Course Schedule</h2><h3>Medium</h3><hr><div><p>There are a total of <code>numCourses</code> courses you have to take, labeled from <code>0</code> to <code>numCourses - 1</code>. You are given an array <code>prerequisites</code> where <code>prerequisites[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that you <strong>must</strong> take course <code>b<sub>i</sub></code> first if you want to take course <code>a<sub>i</sub></code>.</p>
+
+<ul>
+	<li>For example, the pair <code>[0, 1]</code>, indicates that to take course <code>0</code> you have to first take course <code>1</code>.</li>
+</ul>
+
+<p>Return <code>true</code> if you can finish all courses. Otherwise, return <code>false</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> numCourses = 2, prerequisites = [[1,0]]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> There are a total of 2 courses to take. 
+To take course 1 you should have finished course 0. So it is possible.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> numCourses = 2, prerequisites = [[1,0],[0,1]]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There are a total of 2 courses to take. 
+To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= numCourses &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= prerequisites.length &lt;= 5000</code></li>
+	<li><code>prerequisites[i].length == 2</code></li>
+	<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt; numCourses</code></li>
+	<li>All the pairs prerequisites[i] are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/custom-sort-string/README.md b/custom-sort-string/README.md
new file mode 100644
index 0000000..f693659
--- /dev/null
+++ b/custom-sort-string/README.md
@@ -0,0 +1,26 @@
+<h2>791. Custom Sort String</h2><h3>Medium</h3><hr><div><p><code>order</code> and <code>str</code> are strings composed of lowercase letters. In <code>order</code>, no letter occurs more than once.</p>
+
+<p><code>order</code> was sorted in some custom order previously. We want to permute the characters of <code>str</code> so that they match the order that <code>order</code> was sorted. More specifically, if <code>x</code> occurs before <code>y</code> in <code>order</code>, then <code>x</code> should occur before <code>y</code> in the returned string.</p>
+
+<p>Return any permutation of <code>str</code> (as a string) that satisfies this property.</p>
+
+<pre><strong>Example:</strong>
+<strong>Input:</strong> 
+order = "cba"
+str = "abcd"
+<strong>Output:</strong> "cbad"
+<strong>Explanation:</strong> 
+"a", "b", "c" appear in order, so the order of "a", "b", "c" should be "c", "b", and "a". 
+Since "d" does not appear in order, it can be at any position in the returned string. "dcba", "cdba", "cbda" are also valid outputs.
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>Note:</strong></p>
+
+<ul>
+	<li><code>order</code> has length at most <code>26</code>, and no character is repeated in <code>order</code>.</li>
+	<li><code>str</code> has length at most <code>200</code>.</li>
+	<li><code>order</code> and <code>str</code> consist of lowercase letters only.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/custom-sort-string/custom-sort-string.cpp b/custom-sort-string/custom-sort-string.cpp
new file mode 100644
index 0000000..117e60a
--- /dev/null
+++ b/custom-sort-string/custom-sort-string.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+  string customSortString(string order, string str) 
+    {
+        unordered_map<char,int> mp;
+        for(auto i:str)
+            mp[i]++;
+        string res;
+        for(auto i:order)
+        {
+            res+=string(mp[i],i);
+            mp[i]=0;
+        }
+        for (auto i : mp) {
+            res += string(i.second, i.first);
+        }
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/daily-temperatures/README.md b/daily-temperatures/README.md
new file mode 100644
index 0000000..b9fb76b
--- /dev/null
+++ b/daily-temperatures/README.md
@@ -0,0 +1,21 @@
+<h2>739. Daily Temperatures</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/daily-temperatures/daily-temperatures.cpp b/daily-temperatures/daily-temperatures.cpp
new file mode 100644
index 0000000..b7c161e
--- /dev/null
+++ b/daily-temperatures/daily-temperatures.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    vector<int> dailyTemperatures(vector<int>& temperatures) {
+    vector<int> res(temperatures.size());
+    for (int i = temperatures.size() - 1; i >= 0; --i) {
+        int j = i+1;
+        while (j < temperatures.size() && temperatures[j] <= temperatures[i]) {
+            if (res[j] > 0) j = res[j] + j;
+            else j = temperatures.size();
+        }
+        // either j == size || temperatures[j] > temperatures[i]
+        if (j < temperatures.size()) res[i] = j - i;
+    }
+    return res;
+}
+};
\ No newline at end of file
diff --git a/decode-ways-ii/README.md b/decode-ways-ii/README.md
new file mode 100644
index 0000000..ce34689
--- /dev/null
+++ b/decode-ways-ii/README.md
@@ -0,0 +1,59 @@
+<h2>639. Decode Ways II</h2><h3>Hard</h3><hr><div><p>A message containing letters from <code>A-Z</code> can be <strong>encoded</strong> into numbers using the following mapping:</p>
+
+<pre>'A' -&gt; "1"
+'B' -&gt; "2"
+...
+'Z' -&gt; "26"
+</pre>
+
+<p>To <strong>decode</strong> an encoded message, all the digits must be grouped then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, <code>"11106"</code> can be mapped into:</p>
+
+<ul>
+	<li><code>"AAJF"</code> with the grouping <code>(1 1 10 6)</code></li>
+	<li><code>"KJF"</code> with the grouping <code>(11 10 6)</code></li>
+</ul>
+
+<p>Note that the grouping <code>(1 11 06)</code> is invalid because <code>"06"</code> cannot be mapped into <code>'F'</code> since <code>"6"</code> is different from <code>"06"</code>.</p>
+
+<p><strong>In addition</strong> to the mapping above, an encoded message may contain the <code>'*'</code> character, which can represent any digit from <code>'1'</code> to <code>'9'</code> (<code>'0'</code> is excluded). For example, the encoded message <code>"1*"</code> may represent any of the encoded messages <code>"11"</code>, <code>"12"</code>, <code>"13"</code>, <code>"14"</code>, <code>"15"</code>, <code>"16"</code>, <code>"17"</code>, <code>"18"</code>, or <code>"19"</code>. Decoding <code>"1*"</code> is equivalent to decoding <strong>any</strong> of the encoded messages it can represent.</p>
+
+<p>Given a string <code>s</code> containing digits and the <code>'*'</code> character, return <em>the <strong>number</strong> of ways to <strong>decode</strong> it</em>.</p>
+
+<p>Since the answer may be very large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "*"
+<strong>Output:</strong> 9
+<strong>Explanation:</strong> The encoded message can represent any of the encoded messages "1", "2", "3", "4", "5", "6", "7", "8", or "9".
+Each of these can be decoded to the strings "A", "B", "C", "D", "E", "F", "G", "H", and "I" respectively.
+Hence, there are a total of 9 ways to decode "*".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "1*"
+<strong>Output:</strong> 18
+<strong>Explanation:</strong> The encoded message can represent any of the encoded messages "11", "12", "13", "14", "15", "16", "17", "18", or "19".
+Each of these encoded messages have 2 ways to be decoded (e.g. "11" can be decoded to "AA" or "K").
+Hence, there are a total of 9 * 2 = 18 ways to decode "1*".
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "2*"
+<strong>Output:</strong> 15
+<strong>Explanation:</strong> The encoded message can represent any of the encoded messages "21", "22", "23", "24", "25", "26", "27", "28", or "29".
+"21", "22", "23", "24", "25", and "26" have 2 ways of being decoded, but "27", "28", and "29" only have 1 way.
+Hence, there are a total of (6 * 2) + (3 * 1) = 12 + 3 = 15 ways to decode "2*".
+</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 digit or <code>'*'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/decode-ways/README.md b/decode-ways/README.md
new file mode 100644
index 0000000..07eac2a
--- /dev/null
+++ b/decode-ways/README.md
@@ -0,0 +1,60 @@
+<h2>91. Decode Ways</h2><h3>Medium</h3><hr><div><p>A message containing letters from <code>A-Z</code> can be <strong>encoded</strong> into numbers using the following mapping:</p>
+
+<pre>'A' -&gt; "1"
+'B' -&gt; "2"
+...
+'Z' -&gt; "26"
+</pre>
+
+<p>To <strong>decode</strong> an encoded message, all the digits must be grouped then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, <code>"11106"</code> can be mapped into:</p>
+
+<ul>
+	<li><code>"AAJF"</code> with the grouping <code>(1 1 10 6)</code></li>
+	<li><code>"KJF"</code> with the grouping <code>(11 10 6)</code></li>
+</ul>
+
+<p>Note that the grouping <code>(1 11 06)</code> is invalid because <code>"06"</code> cannot be mapped into <code>'F'</code> since <code>"6"</code> is different from <code>"06"</code>.</p>
+
+<p>Given a string <code>s</code> containing only digits, return <em>the <strong>number</strong> of ways to <strong>decode</strong> it</em>.</p>
+
+<p>The answer is guaranteed to fit in a <strong>32-bit</strong> integer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "12"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> "12" could be decoded as "AB" (1 2) or "L" (12).
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "226"
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> "226" could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "0"
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There is no character that is mapped to a number starting with 0.
+The only valid mappings with 0 are 'J' -&gt; "10" and 'T' -&gt; "20", neither of which start with 0.
+Hence, there are no valid ways to decode this since all digits need to be mapped.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> s = "06"
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> "06" cannot be mapped to "F" because of the leading zero ("6" is different from "06").
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 100</code></li>
+	<li><code>s</code> contains only digits and may contain leading zero(s).</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/decode-ways/decode-ways.cpp b/decode-ways/decode-ways.cpp
new file mode 100644
index 0000000..b7a1213
--- /dev/null
+++ b/decode-ways/decode-ways.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+int numDecodings(string s) {
+    if (!s.size() || s.front() == '0') return 0;
+    // r2: decode ways of s[i-2] , r1: decode ways of s[i-1] 
+    int r1 = 1, r2 = 1;
+    
+    for (int i = 1; i < s.size(); i++) {
+        // zero voids ways of the last because zero cannot be used separately
+        if (s[i] == '0') r1 = 0;
+
+        // possible two-digit letter, so new r1 is sum of both while new r2 is the old r1
+        if (s[i - 1] == '1' || s[i - 1] == '2' && s[i] <= '6') {
+            r1 = r2 + r1;
+            r2 = r1 - r2;
+        }
+
+        // one-digit letter, no new way added
+        else {
+            r2 = r1;
+        }
+    }
+
+    return r1;
+}
+};
\ No newline at end of file
diff --git a/deepest-leaves-sum/README.md b/deepest-leaves-sum/README.md
new file mode 100644
index 0000000..9652701
--- /dev/null
+++ b/deepest-leaves-sum/README.md
@@ -0,0 +1,22 @@
+<h2>1302. Deepest Leaves Sum</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/deepest-leaves-sum/deepest-leaves-sum.cpp b/deepest-leaves-sum/deepest-leaves-sum.cpp
new file mode 100644
index 0000000..61e09f1
--- /dev/null
+++ b/deepest-leaves-sum/deepest-leaves-sum.cpp
@@ -0,0 +1,31 @@
+/**
+ * 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:
+   int max_depth;
+    int deepestLeavesSum(TreeNode* root) {
+        max_depth = depthHelper(root);
+        return sumHelper(root, 0);
+    }
+    
+    int sumHelper (TreeNode* root, int depth) {
+        if(!root) return 0;
+        if(depth==max_depth-1) return root->val;
+        return sumHelper(root->left, depth+1) +
+            sumHelper(root->right, depth+1);
+    
+    }
+    int depthHelper(TreeNode* root) {
+        if(!root) return 0;
+        return max(1+ depthHelper(root->left), 1+ depthHelper(root->right));
+    }
+};
\ No newline at end of file
diff --git a/delete-and-earn/README.md b/delete-and-earn/README.md
new file mode 100644
index 0000000..83932cd
--- /dev/null
+++ b/delete-and-earn/README.md
@@ -0,0 +1,37 @@
+<h2>740. Delete and Earn</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/delete-leaves-with-a-given-value/README.md b/delete-leaves-with-a-given-value/README.md
new file mode 100644
index 0000000..50dc740
--- /dev/null
+++ b/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/delete-node-in-a-bst/README.md b/delete-node-in-a-bst/README.md
new file mode 100644
index 0000000..90e77ba
--- /dev/null
+++ b/delete-node-in-a-bst/README.md
@@ -0,0 +1,47 @@
+<h2>450. Delete Node in a BST</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/delete-node-in-a-bst/delete-node-in-a-bst.cpp b/delete-node-in-a-bst/delete-node-in-a-bst.cpp
new file mode 100644
index 0000000..b9ca729
--- /dev/null
+++ b/delete-node-in-a-bst/delete-node-in-a-bst.cpp
@@ -0,0 +1,65 @@
+/**
+ * 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:
+    TreeNode * findMini (TreeNode * root)
+    {
+      if(root == NULL)
+        return NULL;
+      TreeNode * temp = root;
+      while(temp->left != NULL)
+      {
+        temp = temp->left;
+      }
+      return temp;
+    
+    }
+  
+    TreeNode* deleteNode(TreeNode* root, int key) {
+      
+      if(root == NULL)
+        return root;
+      if(root->val > key)
+        root->left = deleteNode(root->left,key);
+      if(root->val < key)
+        root->right = deleteNode(root->right,key);
+      if(root->val == key)
+      {
+        if(root->left == NULL && root->right == NULL)
+        {
+          delete root;
+          return NULL;
+        }
+        if(root->left == NULL)
+        {
+          TreeNode * temp = root->right;
+          root->right = NULL;
+          delete root;
+          return temp;
+        }
+        if(root->right == NULL)
+        {
+          TreeNode * temp = root->left;
+          root->left = NULL;
+          delete root;
+          return temp;
+        }
+        
+        TreeNode * temp = findMini(root->right);
+        root->val = temp->val;
+        root->right = deleteNode(root->right,temp->val);
+         //delete temp;
+        return root;
+      }
+      return root;
+    }
+};
\ No newline at end of file
diff --git a/delete-node-in-a-linked-list/README.md b/delete-node-in-a-linked-list/README.md
new file mode 100644
index 0000000..87760a2
--- /dev/null
+++ b/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/delete-node-in-a-linked-list/delete-node-in-a-linked-list.cpp b/delete-node-in-a-linked-list/delete-node-in-a-linked-list.cpp
new file mode 100644
index 0000000..6aab0b7
--- /dev/null
+++ b/delete-node-in-a-linked-list/delete-node-in-a-linked-list.cpp
@@ -0,0 +1,17 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+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/destination-city/README.md b/destination-city/README.md
new file mode 100644
index 0000000..41a0181
--- /dev/null
+++ b/destination-city/README.md
@@ -0,0 +1,41 @@
+<h2>1436. Destination City</h2><h3>Easy</h3><hr><div><p>You are given the array <code>paths</code>, where <code>paths[i] = [cityA<sub>i</sub>, cityB<sub>i</sub>]</code> means there exists a direct path going from <code>cityA<sub>i</sub></code> to <code>cityB<sub>i</sub></code>. <em>Return the destination city, that is, the city without any path outgoing to another city.</em></p>
+
+<p>It is guaranteed that the graph of paths forms a line without any loop, therefore, there will be exactly one destination city.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> paths = [["London","New York"],["New York","Lima"],["Lima","Sao Paulo"]]
+<strong>Output:</strong> "Sao Paulo" 
+<strong>Explanation:</strong> Starting at "London" city you will reach "Sao Paulo" city which is the destination city. Your trip consist of: "London" -&gt; "New York" -&gt; "Lima" -&gt; "Sao Paulo".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> paths = [["B","C"],["D","B"],["C","A"]]
+<strong>Output:</strong> "A"
+<strong>Explanation:</strong> All possible trips are:&nbsp;
+"D" -&gt; "B" -&gt; "C" -&gt; "A".&nbsp;
+"B" -&gt; "C" -&gt; "A".&nbsp;
+"C" -&gt; "A".&nbsp;
+"A".&nbsp;
+Clearly the destination city is "A".
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> paths = [["A","Z"]]
+<strong>Output:</strong> "Z"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= paths.length &lt;= 100</code></li>
+	<li><code>paths[i].length == 2</code></li>
+	<li><code>1 &lt;= cityA<sub>i</sub>.length, cityB<sub>i</sub>.length &lt;= 10</code></li>
+	<li><code>cityA<sub>i</sub> != cityB<sub>i</sub></code></li>
+	<li>All strings consist of lowercase and uppercase English letters and the space character.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/detonate-the-maximum-bombs/README.md b/detonate-the-maximum-bombs/README.md
new file mode 100644
index 0000000..fc99ad9
--- /dev/null
+++ b/detonate-the-maximum-bombs/README.md
@@ -0,0 +1,49 @@
+<h2>2101. Detonate the Maximum Bombs</h2><h3>Medium</h3><hr><div><p>You are given a list of bombs. The <strong>range</strong> of a bomb is defined as the area where its effect can be felt. This area is in the shape of a <strong>circle</strong> with the center as the location of the bomb.</p>
+
+<p>The bombs are represented by a <strong>0-indexed</strong> 2D integer array <code>bombs</code> where <code>bombs[i] = [x<sub>i</sub>, y<sub>i</sub>, r<sub>i</sub>]</code>. <code>x<sub>i</sub></code> and <code>y<sub>i</sub></code> denote the X-coordinate and Y-coordinate of the location of the <code>i<sup>th</sup></code> bomb, whereas <code>r<sub>i</sub></code> denotes the <strong>radius</strong> of its range.</p>
+
+<p>You may choose to detonate a <strong>single</strong> bomb. When a bomb is detonated, it will detonate <strong>all bombs</strong> that lie in its range. These bombs will further detonate the bombs that lie in their ranges.</p>
+
+<p>Given the list of <code>bombs</code>, return <em>the <strong>maximum</strong> number of bombs that can be detonated if you are allowed to detonate <strong>only one</strong> bomb</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/06/desmos-eg-3.png" style="width: 300px; height: 300px;">
+<pre><strong>Input:</strong> bombs = [[2,1,3],[6,1,4]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+The above figure shows the positions and ranges of the 2 bombs.
+If we detonate the left bomb, the right bomb will not be affected.
+But if we detonate the right bomb, both bombs will be detonated.
+So the maximum bombs that can be detonated is max(1, 2) = 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/06/desmos-eg-2.png" style="width: 300px; height: 300px;">
+<pre><strong>Input:</strong> bombs = [[1,1,5],[10,10,5]]
+<strong>Output:</strong> 1
+<strong>Explanation:
+</strong>Detonating either bomb will not detonate the other bomb, so the maximum number of bombs that can be detonated is 1.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/11/07/desmos-eg1.png" style="width: 300px; height: 300px;">
+<pre><strong>Input:</strong> bombs = [[1,2,3],[2,3,1],[3,4,2],[4,5,3],[5,6,4]]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong>
+The best bomb to detonate is bomb 0 because:
+- Bomb 0 detonates bombs 1 and 2. The red circle denotes the range of bomb 0.
+- Bomb 2 detonates bomb 3. The blue circle denotes the range of bomb 2.
+- Bomb 3 detonates bomb 4. The green circle denotes the range of bomb 3.
+Thus all 5 bombs are detonated.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= bombs.length&nbsp;&lt;= 100</code></li>
+	<li><code>bombs[i].length == 3</code></li>
+	<li><code>1 &lt;= x<sub>i</sub>, y<sub>i</sub>, r<sub>i</sub> &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/detonate-the-maximum-bombs/detonate-the-maximum-bombs.cpp b/detonate-the-maximum-bombs/detonate-the-maximum-bombs.cpp
new file mode 100644
index 0000000..4003731
--- /dev/null
+++ b/detonate-the-maximum-bombs/detonate-the-maximum-bombs.cpp
@@ -0,0 +1,38 @@
+class Solution {
+public:
+    // from gfg          https://www.geeksforgeeks.org/find-if-a-point-lies-inside-or-on-circle/
+    bool isInside(int circle_x, int circle_y,
+                   int rad, int x, int y)
+    {
+    
+    if ((x - circle_x) * (x - circle_x) +
+        (y - circle_y) * (y - circle_y) <= rad * rad)
+        return true;
+    else
+        return false;
+}
+  int maximumDetonation(vector<vector<int>>& bs) {
+    int res = 0, sz = bs.size();
+    vector<vector<int>> al(bs.size());
+    for (int i = 0; i < sz; ++i) {
+        long long x = bs[i][0], y = bs[i][1], r2 = (long long)bs[i][2] * bs[i][2];
+        for (int j = 0; j < bs.size(); ++j)
+            if ((x - bs[j][0]) * (x - bs[j][0]) + (y - bs[j][1]) * (y - bs[j][1]) <= r2)
+                al[i].push_back(j);
+    }
+    for (int i = 0; i < sz && res < sz; ++i) {
+        vector<int> q{i};
+        unordered_set<int> detonated{i};
+        while (!q.empty()) {
+            vector<int> q1;
+            for (int j : q)
+                for (int k : al[j])
+                    if (detonated.insert(k).second)
+                        q1.push_back(k);
+            swap(q, q1);
+        }
+        res = max((int)detonated.size(), res);
+    }
+    return res;
+    }
+};
\ No newline at end of file
diff --git a/di-string-match/README.md b/di-string-match/README.md
new file mode 100644
index 0000000..a2cb4a9
--- /dev/null
+++ b/di-string-match/README.md
@@ -0,0 +1,28 @@
+<h2>942. DI String Match</h2><h3>Easy</h3><hr><div><p>A permutation <code>perm</code> of <code>n + 1</code> integers of all the integers in the range <code>[0, n]</code> can be represented as a string <code>s</code> of length <code>n</code> where:</p>
+
+<ul>
+	<li><code>s[i] == 'I'</code> if <code>perm[i] &lt; perm[i + 1]</code>, and</li>
+	<li><code>s[i] == 'D'</code> if <code>perm[i] &gt; perm[i + 1]</code>.</li>
+</ul>
+
+<p>Given a string <code>s</code>, reconstruct the permutation <code>perm</code> and return it. If there are multiple valid permutations perm, return <strong>any of them</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "IDID"
+<strong>Output:</strong> [0,4,1,3,2]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "III"
+<strong>Output:</strong> [0,1,2,3]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> s = "DDI"
+<strong>Output:</strong> [3,2,0,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[i]</code> is either <code>'I'</code> or <code>'D'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/di-string-match/di-string-match.cpp b/di-string-match/di-string-match.cpp
new file mode 100644
index 0000000..48d917f
--- /dev/null
+++ b/di-string-match/di-string-match.cpp
@@ -0,0 +1,9 @@
+class Solution {
+public:
+  vector<int> diStringMatch(string S) {
+    vector<int> res;
+    for (int l = 0, h = S.size(), i = 0; i <= S.size(); ++i)
+        res.push_back(i == S.size() || S[i] == 'I' ? l++ : h--);
+    return res;
+}
+};
\ No newline at end of file
diff --git a/diameter-of-binary-tree/README.md b/diameter-of-binary-tree/README.md
new file mode 100644
index 0000000..cde9546
--- /dev/null
+++ b/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/diameter-of-binary-tree/diameter-of-binary-tree.cpp b/diameter-of-binary-tree/diameter-of-binary-tree.cpp
new file mode 100644
index 0000000..25fa113
--- /dev/null
+++ b/diameter-of-binary-tree/diameter-of-binary-tree.cpp
@@ -0,0 +1,40 @@
+/**
+ * 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:
+    
+    pair <int,int> hd(TreeNode * root)
+    {
+     if(root == NULL)
+     {
+       pair <int,int> p;
+       p.first = 0;
+       p.second = 0;
+       return p;
+     }
+       pair <int,int> left = hd(root->left);
+       pair <int,int> right = hd(root->right);
+      
+       pair <int,int> ans;
+      ans.first = 1 + max(left.first , right.first);
+      ans.second = max( left.first + right.first,max(left.second,right.second));
+      return ans;
+      
+      
+    }
+    
+    int diameterOfBinaryTree(TreeNode* root) {
+        pair <int,int> p;
+      p = hd(root);
+      return p.second;
+    }
+};
\ No newline at end of file
diff --git a/different-ways-to-add-parentheses/README.md b/different-ways-to-add-parentheses/README.md
new file mode 100644
index 0000000..33c65ab
--- /dev/null
+++ b/different-ways-to-add-parentheses/README.md
@@ -0,0 +1,33 @@
+<h2>241. Different Ways to Add Parentheses</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>&nbsp;</p>
+<p><strong>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>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/divide-two-integers/README.md b/divide-two-integers/README.md
new file mode 100644
index 0000000..935ef13
--- /dev/null
+++ b/divide-two-integers/README.md
@@ -0,0 +1,43 @@
+<h2>29. Divide Two Integers</h2><h3>Medium</h3><hr><div><p>Given two integers <code>dividend</code> and <code>divisor</code>, divide two integers without using multiplication, division, and mod operator.</p>
+
+<p>Return the quotient after dividing <code>dividend</code> by <code>divisor</code>.</p>
+
+<p>The integer division should truncate toward zero, which means losing its fractional part. For example, <code>truncate(8.345) = 8</code> and <code>truncate(-2.7335) = -2</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>[−2<sup>31</sup>, 2<sup>31</sup> − 1]</code>. For this problem, assume that your function <strong>returns </strong><code>2<sup>31</sup> − 1</code><strong> when the division result overflows</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> dividend = 10, divisor = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 10/3 = truncate(3.33333..) = 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> dividend = 7, divisor = -3
+<strong>Output:</strong> -2
+<strong>Explanation:</strong> 7/-3 = truncate(-2.33333..) = -2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> dividend = 0, divisor = 1
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> dividend = 1, divisor = 1
+<strong>Output:</strong> 1
+</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>
+</div>
\ No newline at end of file
diff --git a/edit-distance/README.md b/edit-distance/README.md
new file mode 100644
index 0000000..fd57dbc
--- /dev/null
+++ b/edit-distance/README.md
@@ -0,0 +1,41 @@
+<h2>72. Edit Distance</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/encode-and-decode-tinyurl/README.md b/encode-and-decode-tinyurl/README.md
new file mode 100644
index 0000000..34013ef
--- /dev/null
+++ b/encode-and-decode-tinyurl/README.md
@@ -0,0 +1,34 @@
+<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/encode-and-decode-tinyurl/encode-and-decode-tinyurl.cpp b/encode-and-decode-tinyurl/encode-and-decode-tinyurl.cpp
new file mode 100644
index 0000000..f726b81
--- /dev/null
+++ b/encode-and-decode-tinyurl/encode-and-decode-tinyurl.cpp
@@ -0,0 +1,13 @@
+class Solution {
+public:
+
+    // Encodes a URL to a shortened URL.
+    string encode(string longUrl) {
+        return longUrl;
+    }
+
+    // Decodes a shortened URL to its original URL.
+    string decode(string shortUrl) {
+        return shortUrl;
+    }
+};
\ No newline at end of file
diff --git a/excel-sheet-column-title/README.md b/excel-sheet-column-title/README.md
new file mode 100644
index 0000000..8a6c269
--- /dev/null
+++ b/excel-sheet-column-title/README.md
@@ -0,0 +1,45 @@
+<h2>168. Excel Sheet Column Title</h2><h3>Easy</h3><hr><div><p>Given an integer <code>columnNumber</code>, return <em>its corresponding column title as it appears in an Excel sheet</em>.</p>
+
+<p>For example:</p>
+
+<pre>A -&gt; 1
+B -&gt; 2
+C -&gt; 3
+...
+Z -&gt; 26
+AA -&gt; 27
+AB -&gt; 28 
+...
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> columnNumber = 1
+<strong>Output:</strong> "A"
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> columnNumber = 28
+<strong>Output:</strong> "AB"
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> columnNumber = 701
+<strong>Output:</strong> "ZY"
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> columnNumber = 2147483647
+<strong>Output:</strong> "FXSHRXW"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= columnNumber &lt;= 2<sup>31</sup> - 1</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/excel-sheet-column-title/excel-sheet-column-title.cpp b/excel-sheet-column-title/excel-sheet-column-title.cpp
new file mode 100644
index 0000000..9f98b5b
--- /dev/null
+++ b/excel-sheet-column-title/excel-sheet-column-title.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+   string convertToTitle(int n) {
+
+    string res;
+
+    char tmp;
+
+    while(n){
+
+        n -= 1;
+
+        tmp = 'A' + n % 26;
+
+        res = tmp + res;
+
+        n /= 26;
+
+    }
+
+    return res;
+
+}
+};
diff --git a/fibonacci-number/README.md b/fibonacci-number/README.md
new file mode 100644
index 0000000..3dfc343
--- /dev/null
+++ b/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/fibonacci-number/fibonacci-number.cpp b/fibonacci-number/fibonacci-number.cpp
new file mode 100644
index 0000000..e6f38d8
--- /dev/null
+++ b/fibonacci-number/fibonacci-number.cpp
@@ -0,0 +1,7 @@
+class Solution {
+public:
+    int fib(int N) {
+        double phi = (sqrt(5) + 1) / 2;     
+        return round(pow(phi, N) / sqrt(5));
+    }
+};
\ No newline at end of file
diff --git a/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/README.md b/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/README.md
new file mode 100644
index 0000000..8e5c3cb
--- /dev/null
+++ b/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/README.md
@@ -0,0 +1,52 @@
+<h2>1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree</h2><h3>Medium</h3><hr><div><p>Given two binary trees <code>original</code> and <code>cloned</code> and given a reference to a node <code>target</code> in the original tree.</p>
+
+<p>The <code>cloned</code> tree is a <strong>copy of</strong> the <code>original</code> tree.</p>
+
+<p>Return <em>a reference to the same node</em> in the <code>cloned</code> tree.</p>
+
+<p><strong>Note</strong> that you are <strong>not allowed</strong> to change any of the two trees or the <code>target</code> node and the answer <strong>must be</strong> a reference to a node in the <code>cloned</code> tree.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e1.png" style="width: 544px; height: 426px;">
+<pre><strong>Input:</strong> tree = [7,4,3,null,null,6,19], target = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> In all examples the original and cloned trees are shown. The target node is a green node from the original tree. The answer is the yellow node from the cloned tree.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e2.png" style="width: 221px; height: 159px;">
+<pre><strong>Input:</strong> tree = [7], target =  7
+<strong>Output:</strong> 7
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e3.png" style="width: 459px; height: 486px;">
+<pre><strong>Input:</strong> tree = [8,null,6,null,5,null,4,null,3,null,2,null,1], target = 4
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 4:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e4.png" style="width: 555px; height: 239px;">
+<pre><strong>Input:</strong> tree = [1,2,3,4,5,6,7,8,9,10], target = 5
+<strong>Output:</strong> 5
+</pre>
+
+<p><strong>Example 5:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/02/21/e5.png" style="width: 427px; height: 345px;">
+<pre><strong>Input:</strong> tree = [1,2,null,3], target = 2
+<strong>Output:</strong> 2
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the <code>tree</code> is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li>The values of the nodes of the <code>tree</code> are unique.</li>
+	<li><code>target</code> node is a node from the <code>original</code> tree and is not <code>null</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you solve the problem if repeated values on the tree are allowed?</p>
+</div>
\ No newline at end of file
diff --git a/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree.cpp b/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree.cpp
new file mode 100644
index 0000000..5c34ded
--- /dev/null
+++ b/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree.cpp
@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+class Solution {
+public:
+    TreeNode* getTargetCopy(TreeNode* original, TreeNode* clone, TreeNode* targ) {
+        return original == nullptr ? nullptr :
+    original == targ ? clone : 
+      getTargetCopy(original->left, clone->left, targ) ?: getTargetCopy(original->right, clone->right, targ);
+    }
+};
\ No newline at end of file
diff --git a/find-all-numbers-disappeared-in-an-array/README.md b/find-all-numbers-disappeared-in-an-array/README.md
new file mode 100644
index 0000000..66b6fce
--- /dev/null
+++ b/find-all-numbers-disappeared-in-an-array/README.md
@@ -0,0 +1,22 @@
+<h2>448. Find All Numbers Disappeared in an Array</h2><h3>Easy</h3><hr><div><p>Given an array <code>nums</code> of <code>n</code> integers where <code>nums[i]</code> is in the range <code>[1, n]</code>, return <em>an array of all the integers in the range</em> <code>[1, n]</code> <em>that do not appear in</em> <code>nums</code>.</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> [5,6]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1]
+<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;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= nums[i] &lt;= n</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you do it without extra space and in <code>O(n)</code> runtime? You may assume the returned list does not count as extra space.</p>
+</div>
\ No newline at end of file
diff --git a/find-all-numbers-disappeared-in-an-array/find-all-numbers-disappeared-in-an-array.cpp b/find-all-numbers-disappeared-in-an-array/find-all-numbers-disappeared-in-an-array.cpp
new file mode 100644
index 0000000..fcff191
--- /dev/null
+++ b/find-all-numbers-disappeared-in-an-array/find-all-numbers-disappeared-in-an-array.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    vector<int> findDisappearedNumbers(vector<int>& nums) {
+        vector <int> freq(nums.size()+1,0);
+      vector <int> ans;
+      for(int i=0;i<nums.size();i++)
+        freq[nums[i]]++;
+      
+      for(int i=1;i<freq.size();i++)
+        if(freq[i] == 0)
+          ans.push_back(i);
+      
+      return ans;
+    }
+};
\ No newline at end of file
diff --git a/find-center-of-star-graph/README.md b/find-center-of-star-graph/README.md
new file mode 100644
index 0000000..3267212
--- /dev/null
+++ b/find-center-of-star-graph/README.md
@@ -0,0 +1,30 @@
+<h2>1791. Find Center of Star Graph</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>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>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/find-center-of-star-graph/find-center-of-star-graph.cpp b/find-center-of-star-graph/find-center-of-star-graph.cpp
new file mode 100644
index 0000000..003f890
--- /dev/null
+++ b/find-center-of-star-graph/find-center-of-star-graph.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int findCenter(vector<vector<int>>& edges) {
+      
+      int n = edges.size()+1;
+      
+      vector <int> v(n+1,0);
+      
+      for(int i=0;i<edges.size();i++)
+      {
+          v[edges[i][0]]++;
+          v[edges[i][1]]++;
+      }
+      
+      for(int i=1;i<=n;i++)
+        if(v[i]>1)
+          return i;
+      
+      return -1;
+    }
+  
+};
\ No newline at end of file
diff --git a/find-first-and-last-position-of-element-in-sorted-array/README.md b/find-first-and-last-position-of-element-in-sorted-array/README.md
new file mode 100644
index 0000000..5d30040
--- /dev/null
+++ b/find-first-and-last-position-of-element-in-sorted-array/README.md
@@ -0,0 +1,27 @@
+<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 ascending 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/find-first-and-last-position-of-element-in-sorted-array/find-first-and-last-position-of-element-in-sorted-array.cpp b/find-first-and-last-position-of-element-in-sorted-array/find-first-and-last-position-of-element-in-sorted-array.cpp
new file mode 100644
index 0000000..850c4f4
--- /dev/null
+++ b/find-first-and-last-position-of-element-in-sorted-array/find-first-and-last-position-of-element-in-sorted-array.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+vector<int> searchRange(vector<int>& nums, int target) {
+    int idx1 = lower_bound(nums, target);
+    int idx2 = lower_bound(nums, target+1)-1;
+    if (idx1 < nums.size() && nums[idx1] == target)
+        return {idx1, idx2};
+    else
+        return {-1, -1};
+}
+
+int lower_bound(vector<int>& nums, int target) {
+    int l = 0, r = nums.size()-1;
+    while (l <= r) {
+        int mid = (r-l)/2+l;
+        if (nums[mid] < target)
+            l = mid+1;
+        else
+            r = mid-1;
+    }
+    return l;
+}
+};
\ No newline at end of file
diff --git a/find-median-from-data-stream/README.md b/find-median-from-data-stream/README.md
new file mode 100644
index 0000000..0c4c67c
--- /dev/null
+++ b/find-median-from-data-stream/README.md
@@ -0,0 +1,50 @@
+<h2>295. Find Median from Data Stream</h2><h3>Hard</h3><hr><div><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 and the median is the mean of the two middle values.</p>
+
+<ul>
+	<li>For example, for <code>arr = [2,3,4]</code>, the median is <code>3</code>.</li>
+	<li>For example, for <code>arr = [2,3]</code>, the median is <code>(2 + 3) / 2 = 2.5</code>.</li>
+</ul>
+
+<p>Implement the MedianFinder class:</p>
+
+<ul>
+	<li><code>MedianFinder()</code> initializes the <code>MedianFinder</code> object.</li>
+	<li><code>void addNum(int num)</code> adds the integer <code>num</code> from the data stream to the data structure.</li>
+	<li><code>double findMedian()</code> returns the median of all elements so far. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
+[[], [1], [2], [], [3], []]
+<strong>Output</strong>
+[null, null, null, 1.5, null, 2.0]
+
+<strong>Explanation</strong>
+MedianFinder medianFinder = new MedianFinder();
+medianFinder.addNum(1);    // arr = [1]
+medianFinder.addNum(2);    // arr = [1, 2]
+medianFinder.findMedian(); // return 1.5 (i.e., (1 + 2) / 2)
+medianFinder.addNum(3);    // arr[1, 2, 3]
+medianFinder.findMedian(); // return 2.0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>-10<sup>5</sup> &lt;= num &lt;= 10<sup>5</sup></code></li>
+	<li>There will be at least one element in the data structure before calling <code>findMedian</code>.</li>
+	<li>At most <code>5 * 10<sup>4</sup></code> calls will be made to <code>addNum</code> and <code>findMedian</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong></p>
+
+<ul>
+	<li>If all integer numbers from the stream are in the range <code>[0, 100]</code>, how would you optimize your solution?</li>
+	<li>If <code>99%</code> of all integer numbers from the stream are in the range <code>[0, 100]</code>, how would you optimize your solution?</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/find-median-from-data-stream/find-median-from-data-stream.cpp b/find-median-from-data-stream/find-median-from-data-stream.cpp
new file mode 100644
index 0000000..61d25b4
--- /dev/null
+++ b/find-median-from-data-stream/find-median-from-data-stream.cpp
@@ -0,0 +1,26 @@
+class MedianFinder {
+    priority_queue<long> small, large;
+public:
+
+    void addNum(int num) {
+        small.push(num);
+        large.push(-small.top());
+        small.pop();
+        if (small.size() < large.size()) {
+            small.push(-large.top());
+            large.pop();
+        }
+    }
+
+    double findMedian() {
+        return small.size() > large.size()
+               ? small.top()
+               : (small.top() - large.top()) / 2.0;
+    }
+};
+/**
+ * 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/find-minimum-in-rotated-sorted-array-ii/README.md b/find-minimum-in-rotated-sorted-array-ii/README.md
new file mode 100644
index 0000000..f8a17ad
--- /dev/null
+++ b/find-minimum-in-rotated-sorted-array-ii/README.md
@@ -0,0 +1,36 @@
+<h2>154. Find Minimum in Rotated Sorted Array II</h2><h3>Hard</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,4,4,5,6,7]</code> might become:</p>
+
+<ul>
+	<li><code>[4,5,6,7,0,1,4]</code> if it was rotated <code>4</code> times.</li>
+	<li><code>[0,1,4,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> that may contain <strong>duplicates</strong>, return <em>the minimum element of this array</em>.</p>
+
+<p>You must decrease the overall operation steps as much as possible.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,3,5]
+<strong>Output:</strong> 1
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [2,2,2,0,1]
+<strong>Output:</strong> 0
+</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><code>nums</code> is sorted and rotated between <code>1</code> and <code>n</code> times.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> This problem is similar to&nbsp;<a href="https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/" target="_blank">Find Minimum in Rotated Sorted Array</a>, but&nbsp;<code>nums</code> may contain <strong>duplicates</strong>. Would this affect the runtime complexity? How and why?</p>
+
+<p>&nbsp;</p>
+</div>
\ No newline at end of file
diff --git a/find-minimum-in-rotated-sorted-array-ii/find-minimum-in-rotated-sorted-array-ii.cpp b/find-minimum-in-rotated-sorted-array-ii/find-minimum-in-rotated-sorted-array-ii.cpp
new file mode 100644
index 0000000..9a6562d
--- /dev/null
+++ b/find-minimum-in-rotated-sorted-array-ii/find-minimum-in-rotated-sorted-array-ii.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int findMin(vector<int>& nums) {
+        
+        int low = 0;
+        int high = nums.size()-1;
+        
+        while(low < high)
+        {
+            int mid = low + (high-low)/2;
+            
+            if(nums[mid] > nums[high])
+            {
+                low = mid+1;
+            }
+            else if(nums[mid] < nums[high])
+            {
+                high = mid;
+            }
+            else
+            {
+                high--;
+            }
+            
+        }
+        return nums[high];
+        
+    }
+};
\ No newline at end of file
diff --git a/find-minimum-in-rotated-sorted-array/README.md b/find-minimum-in-rotated-sorted-array/README.md
new file mode 100644
index 0000000..54c6b9f
--- /dev/null
+++ b/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/find-minimum-in-rotated-sorted-array/find-minimum-in-rotated-sorted-array.cpp b/find-minimum-in-rotated-sorted-array/find-minimum-in-rotated-sorted-array.cpp
new file mode 100644
index 0000000..d0d1222
--- /dev/null
+++ b/find-minimum-in-rotated-sorted-array/find-minimum-in-rotated-sorted-array.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+  int findMin(vector<int> &num) {
+        int start=0,end=num.size()-1;
+        
+        while (start<end) {
+            if (num[start]<num[end])
+                return num[start];
+            
+            int mid = (start+end)/2;
+            
+            if (num[mid]>=num[start]) {
+                start = mid+1;
+            } else {
+                end = mid;
+            }
+        }
+        
+        return num[start];
+    }
+};
\ No newline at end of file
diff --git a/find-peak-element/README.md b/find-peak-element/README.md
new file mode 100644
index 0000000..6be57e0
--- /dev/null
+++ b/find-peak-element/README.md
@@ -0,0 +1,30 @@
+<h2>162. Find Peak Element</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/find-peak-element/find-peak-element.cpp b/find-peak-element/find-peak-element.cpp
new file mode 100644
index 0000000..c88604d
--- /dev/null
+++ b/find-peak-element/find-peak-element.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int findPeakElement(vector<int>& nums) {
+        // edge case - only one item
+        if (nums.size() == 1) return 0;
+        // peak is first item
+        if (nums[0] > nums[1]) return 0;
+        // peak is last item
+        if (nums.back() > nums[nums.size()-2]) return nums.size()-1;
+        // iterate to find peak
+        for (int i=0; i<nums.size(); i++) 
+            if ((nums[i] > nums[max(0,i-1)]) && (nums[i] > nums[i+1])) return i;
+        return -1;
+    }
+};
\ No newline at end of file
diff --git a/find-positive-integer-solution-for-a-given-equation/README.md b/find-positive-integer-solution-for-a-given-equation/README.md
new file mode 100644
index 0000000..e5f901d
--- /dev/null
+++ b/find-positive-integer-solution-for-a-given-equation/README.md
@@ -0,0 +1,60 @@
+<h2>1237. Find Positive Integer Solution for a Given Equation</h2><h3>Medium</h3><hr><div><p>Given a callable function <code>f(x, y)</code> <strong>with a hidden formula</strong> and a value <code>z</code>, reverse engineer the formula and return <em>all positive integer pairs </em><code>x</code><em> and </em><code>y</code><em> where </em><code>f(x,y) == z</code>. You may return the pairs in any order.</p>
+
+<p>While the exact formula is hidden, the function is monotonically increasing, i.e.:</p>
+
+<ul>
+	<li><code>f(x, y) &lt; f(x + 1, y)</code></li>
+	<li><code>f(x, y) &lt; f(x, y + 1)</code></li>
+</ul>
+
+<p>The function interface is defined like this:</p>
+
+<pre>interface CustomFunction {
+public:
+  // Returns some positive integer f(x, y) for two positive integers x and y based on a formula.
+  int f(int x, int y);
+};
+</pre>
+
+<p>We will judge your solution as follows:</p>
+
+<ul>
+	<li>The judge has a list of <code>9</code> hidden implementations of <code>CustomFunction</code>, along with a way to generate an <strong>answer key</strong> of all valid pairs for a specific <code>z</code>.</li>
+	<li>The judge will receive two inputs: a <code>function_id</code> (to determine which implementation to test your code with), and the target <code>z</code>.</li>
+	<li>The judge will call your <code>findSolution</code> and compare your results with the <strong>answer key</strong>.</li>
+	<li>If your results match the <strong>answer key</strong>, your solution will be <code>Accepted</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> function_id = 1, z = 5
+<strong>Output:</strong> [[1,4],[2,3],[3,2],[4,1]]
+<strong>Explanation:</strong> The hidden formula for function_id = 1 is f(x, y) = x + y.
+The following positive integer values of x and y make f(x, y) equal to 5:
+x=1, y=4 -&gt; f(1, 4) = 1 + 4 = 5.
+x=2, y=3 -&gt; f(2, 3) = 2 + 3 = 5.
+x=3, y=2 -&gt; f(3, 2) = 3 + 2 = 5.
+x=4, y=1 -&gt; f(4, 1) = 4 + 1 = 5.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> function_id = 2, z = 5
+<strong>Output:</strong> [[1,5],[5,1]]
+<strong>Explanation:</strong> The hidden formula for function_id = 2 is f(x, y) = x * y.
+The following positive integer values of x and y make f(x, y) equal to 5:
+x=1, y=5 -&gt; f(1, 5) = 1 * 5 = 5.
+x=5, y=1 -&gt; f(5, 1) = 5 * 1 = 5.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= function_id &lt;= 9</code></li>
+	<li><code>1 &lt;= z &lt;= 100</code></li>
+	<li>It is guaranteed that the solutions of <code>f(x, y) == z</code> will be in the range <code>1 &lt;= x, y &lt;= 1000</code>.</li>
+	<li>It is also guaranteed that <code>f(x, y)</code> will fit in 32 bit signed integer if <code>1 &lt;= x, y &lt;= 1000</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/find-the-duplicate-number/README.md b/find-the-duplicate-number/README.md
new file mode 100644
index 0000000..4b0c25c
--- /dev/null
+++ b/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/find-the-duplicate-number/find-the-duplicate-number.cpp b/find-the-duplicate-number/find-the-duplicate-number.cpp
new file mode 100644
index 0000000..af87c52
--- /dev/null
+++ b/find-the-duplicate-number/find-the-duplicate-number.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int findDuplicate(vector<int>& nums) {
+      int slow = nums[0];
+      int fast = nums[0];
+      
+      do{
+        slow = nums[slow];
+        fast = nums[nums[fast]];
+      }while(slow != fast);
+        
+        fast = nums[0];
+      while(slow != fast)
+      {
+        slow = nums[slow];
+        fast = nums[fast];
+      }
+      
+      return fast;
+    }
+};
\ No newline at end of file
diff --git a/find-the-town-judge/README.md b/find-the-town-judge/README.md
new file mode 100644
index 0000000..80b2545
--- /dev/null
+++ b/find-the-town-judge/README.md
@@ -0,0 +1,57 @@
+<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><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> n = 3, trust = [[1,2],[2,3]]
+<strong>Output:</strong> -1
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> n = 4, trust = [[1,3],[1,4],[2,3],[2,4],[4,3]]
+<strong>Output:</strong> 3
+</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/find-the-town-judge/find-the-town-judge.cpp b/find-the-town-judge/find-the-town-judge.cpp
new file mode 100644
index 0000000..8645d1b
--- /dev/null
+++ b/find-the-town-judge/find-the-town-judge.cpp
@@ -0,0 +1,37 @@
+class Solution {
+public:
+    int findJudge(int n, vector<vector<int>>& trust) {
+       //this condition is to check if given input is empty but n==1
+		
+		if(trust.empty() && n==1)
+            return 1;
+		
+		//counts outdegree of a person or node 
+		//outdegree means number of nodes that are trusted by given specific node 
+        
+		vector<int> out(n+1,0);
+		
+		//counts indegree of a person or node 
+		//indegree means number of nodes that trusts a given specific node
+        
+		vector<int> in(n+1,0);
+		
+		//loop counts indegree and outdegree
+        
+		for(auto edge : trust){
+            out[edge[0]]++;
+            in[edge[1]]++;
+        }
+		
+		//if a node has outdegree==0 that means that node doesnot trust anyone and
+		//indegree ==n-1 that means all other nodes trusts this node except himself
+        
+		for(int i=0;i<=n;i++){
+            if(out[i]==0 && in[i]==n-1)
+                return i;
+        }
+		//if there is no such node return -1
+        return -1;
+    }
+  
+};
\ No newline at end of file
diff --git a/find-the-winner-of-the-circular-game/README.md b/find-the-winner-of-the-circular-game/README.md
new file mode 100644
index 0000000..ab584f1
--- /dev/null
+++ b/find-the-winner-of-the-circular-game/README.md
@@ -0,0 +1,43 @@
+<h2>1823. Find the Winner of the Circular Game</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>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>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></div>
\ No newline at end of file
diff --git a/finding-the-users-active-minutes/README.md b/finding-the-users-active-minutes/README.md
new file mode 100644
index 0000000..17872f6
--- /dev/null
+++ b/finding-the-users-active-minutes/README.md
@@ -0,0 +1,42 @@
+<h2>1817. Finding the Users Active Minutes</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/first-bad-version/README.md b/first-bad-version/README.md
new file mode 100644
index 0000000..d0bd6b1
--- /dev/null
+++ b/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/first-bad-version/first-bad-version.cpp b/first-bad-version/first-bad-version.cpp
new file mode 100644
index 0000000..66c86fe
--- /dev/null
+++ b/first-bad-version/first-bad-version.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int firstBadVersion(int n) {
+        int lower = 1, upper = n, mid;
+        while(lower < upper) {
+            mid = lower + (upper - lower) / 2;
+            if(!isBadVersion(mid)) lower = mid + 1;   /* Only one call to API */
+            else upper = mid;
+        }
+        return lower;   /* Because there will alway be a bad version, return lower here */
+    }
+};
\ No newline at end of file
diff --git a/flatten-a-multilevel-doubly-linked-list/README.md b/flatten-a-multilevel-doubly-linked-list/README.md
new file mode 100644
index 0000000..a887c42
--- /dev/null
+++ b/flatten-a-multilevel-doubly-linked-list/README.md
@@ -0,0 +1,77 @@
+<h2>430. Flatten a Multilevel Doubly Linked List</h2><h3>Medium</h3><hr><div><p>You are given a doubly linked list which in addition to the next and previous pointers, it could have a child pointer, which may or may not point to a separate doubly linked list. These child lists may have one or more children of their own, and so on, to produce a multilevel data structure, as shown in the example below.</p>
+
+<p>Flatten the list so that all the nodes appear in a single-level, doubly linked list. You are given the head of the first level of the list.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<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 as follows:
+
+<img src="https://assets.leetcode.com/uploads/2018/10/12/multilevellinkedlist.png" style="width: 640px;">
+
+After flattening the multilevel linked list it becomes:
+
+<img src="https://assets.leetcode.com/uploads/2018/10/12/multilevellinkedlistflattened.png" style="width: 1100px;">
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,2,null,3]
+<strong>Output:</strong> [1,3,2]
+<strong>Explanation:
+
+</strong>The input multilevel linked list is as follows:
+
+  1---2---NULL
+  |
+  3---NULL
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = []
+<strong>Output:</strong> []
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>How&nbsp;multilevel linked list is represented in test case:</strong></p>
+
+<p>We use the&nbsp;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>
+
+<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>
+</div>
\ No newline at end of file
diff --git a/flatten-a-multilevel-doubly-linked-list/flatten-a-multilevel-doubly-linked-list.cpp b/flatten-a-multilevel-doubly-linked-list/flatten-a-multilevel-doubly-linked-list.cpp
new file mode 100644
index 0000000..7949a69
--- /dev/null
+++ b/flatten-a-multilevel-doubly-linked-list/flatten-a-multilevel-doubly-linked-list.cpp
@@ -0,0 +1,25 @@
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* prev;
+    Node* next;
+    Node* child;
+};
+*/
+
+class Solution {
+public:
+    
+Node* ff(Node* head, Node* rest = nullptr) {
+  if (!head) return rest;
+  head->next = ff(head->child, ff(head->next, rest));
+  if (head->next) head->next->prev = head;
+  head->child = nullptr;
+  return head;
+}
+    Node* flatten(Node* head) {
+        return ff(head);
+    }
+};
diff --git a/flatten-binary-tree-to-linked-list/README.md b/flatten-binary-tree-to-linked-list/README.md
new file mode 100644
index 0000000..299afc3
--- /dev/null
+++ b/flatten-binary-tree-to-linked-list/README.md
@@ -0,0 +1,36 @@
+<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/flatten-binary-tree-to-linked-list/flatten-binary-tree-to-linked-list.cpp b/flatten-binary-tree-to-linked-list/flatten-binary-tree-to-linked-list.cpp
new file mode 100644
index 0000000..4784c06
--- /dev/null
+++ b/flatten-binary-tree-to-linked-list/flatten-binary-tree-to-linked-list.cpp
@@ -0,0 +1,37 @@
+/**
+ * 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:
+    void flatten(TreeNode* root) {
+      
+      TreeNode * curr = root;
+      while(curr != NULL)
+      {
+        if(curr->left)
+        {
+        TreeNode * prev = curr->left;
+        while(prev->right)
+        {
+          prev = prev->right;
+        }
+        prev->right = curr->right;
+        curr->right = curr->left;
+        curr->left = NULL;
+        
+        }
+        curr = curr->right;
+       
+      }
+      
+      return ;
+    }
+};
\ No newline at end of file
diff --git a/flip-columns-for-maximum-number-of-equal-rows/README.md b/flip-columns-for-maximum-number-of-equal-rows/README.md
new file mode 100644
index 0000000..248f4de
--- /dev/null
+++ b/flip-columns-for-maximum-number-of-equal-rows/README.md
@@ -0,0 +1,38 @@
+<h2>1072. Flip Columns For Maximum Number of Equal Rows</h2><h3>Medium</h3><hr><div><p>You are given an <code>m x n</code> binary matrix <code>matrix</code>.</p>
+
+<p>You can choose any number of columns in the matrix and flip every cell in that column (i.e., Change the value of the cell from <code>0</code> to <code>1</code> or vice versa).</p>
+
+<p>Return <em>the maximum number of rows that have all values equal after some number of flips</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [[0,1],[1,1]]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> After flipping no values, 1 row has all values equal.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [[0,1],[1,0]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> After flipping values in the first column, both rows have equal values.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [[0,0,0],[0,0,1],[1,1,0]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> After flipping values in the first two columns, the last two rows have equal values.
+</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;= 300</code></li>
+	<li><code>matrix[i][j]</code> is either&nbsp;<code>0</code> or <code>1</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/flip-string-to-monotone-increasing/README.md b/flip-string-to-monotone-increasing/README.md
new file mode 100644
index 0000000..d7a95fb
--- /dev/null
+++ b/flip-string-to-monotone-increasing/README.md
@@ -0,0 +1,36 @@
+<h2>926. Flip String to Monotone Increasing</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>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>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>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/flip-string-to-monotone-increasing/flip-string-to-monotone-increasing.cpp b/flip-string-to-monotone-increasing/flip-string-to-monotone-increasing.cpp
new file mode 100644
index 0000000..2b2d54f
--- /dev/null
+++ b/flip-string-to-monotone-increasing/flip-string-to-monotone-increasing.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int minFlipsMonoIncr(const std::string& S, int counter_one  = 0, int counter_flip = 0) {
+        for (auto ch : S) {
+            if (ch == '1') {
+                ++counter_one;
+            } else {
+                ++counter_flip;
+            }
+            counter_flip = std::min(counter_one, counter_flip);
+        }
+        return counter_flip;
+    }
+};
\ No newline at end of file
diff --git a/flood-fill/README.md b/flood-fill/README.md
new file mode 100644
index 0000000..f5d9633
--- /dev/null
+++ b/flood-fill/README.md
@@ -0,0 +1,35 @@
+<h2>733. Flood Fill</h2><h3>Easy</h3><hr><div><p>An image is represented by an <code>m x n</code> integer grid <code>image</code> where <code>image[i][j]</code> represents the pixel value of the image.</p>
+
+<p>You are also given three integers <code>sr</code>, <code>sc</code>, and <code>newColor</code>. You should perform a <strong>flood fill</strong> on the image starting from the pixel <code>image[sr][sc]</code>.</p>
+
+<p>To perform a <strong>flood fill</strong>, consider the starting pixel, plus any pixels connected <strong>4-directionally</strong> to the starting pixel of the same color as the starting pixel, plus any pixels connected <strong>4-directionally</strong> to those pixels (also with the same color), and so on. Replace the color of all of the aforementioned pixels with <code>newColor</code>.</p>
+
+<p>Return <em>the modified image after performing the flood fill</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/01/flood1-grid.jpg" style="width: 613px; height: 253px;">
+<pre><strong>Input:</strong> image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, newColor = 2
+<strong>Output:</strong> [[2,2,2],[2,2,0],[2,0,1]]
+<strong>Explanation:</strong> From the center of the image with position (sr, sc) = (1, 1) (i.e., the red pixel), all pixels connected by a path of the same color as the starting pixel (i.e., the blue pixels) are colored with the new color.
+Note the bottom corner is not colored 2, because it is not 4-directionally connected to the starting pixel.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, newColor = 2
+<strong>Output:</strong> [[2,2,2],[2,2,2]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == image.length</code></li>
+	<li><code>n == image[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 50</code></li>
+	<li><code>0 &lt;= image[i][j], newColor &lt; 2<sup>16</sup></code></li>
+	<li><code>0 &lt;= sr &lt;&nbsp;m</code></li>
+	<li><code>0 &lt;= sc &lt;&nbsp;n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/flood-fill/flood-fill.cpp b/flood-fill/flood-fill.cpp
new file mode 100644
index 0000000..72d71d1
--- /dev/null
+++ b/flood-fill/flood-fill.cpp
@@ -0,0 +1,36 @@
+class Solution {
+public:
+  
+   void floodFill(vector<vector<int>>& image, int sr, int sc, int newColor,int color)
+   {
+     if(image[sr][sc] == color)
+     {
+       image[sr][sc] = newColor;
+       if(sr >= 1 )
+       {
+         floodFill(image,sr-1,sc,newColor,color);
+       }
+       if(sc >= 1)
+       {
+         floodFill(image,sr,sc-1,newColor,color);
+       }
+       if(sr < image.size() - 1)
+       {
+         floodFill(image,sr+1,sc,newColor,color);
+       }
+       if(sc < image[0].size() - 1)
+       {
+         floodFill(image,sr,sc+1,newColor,color);
+       }
+       
+     }
+   }
+  
+    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
+        if(image[sr][sc] == newColor)
+          return image;
+      int color = image[sr][sc];
+       floodFill(image,sr,sc,newColor,color);
+      return image;
+    }
+};
\ No newline at end of file
diff --git a/fruit-into-baskets/README.md b/fruit-into-baskets/README.md
new file mode 100644
index 0000000..50af033
--- /dev/null
+++ b/fruit-into-baskets/README.md
@@ -0,0 +1,51 @@
+<h2>904. Fruit Into Baskets</h2><h3>Medium</h3><hr><div><p>You are visiting a farm that has a single row of fruit trees arranged from left to right. The trees are represented by an integer array <code>fruits</code> where <code>fruits[i]</code> is the <strong>type</strong> of fruit the <code>i<sup>th</sup></code> tree produces.</p>
+
+<p>You want to collect as much fruit as possible. However, the owner has some strict rules that you must follow:</p>
+
+<ul>
+	<li>You only have <strong>two</strong> baskets, and each basket can only hold a <strong>single type</strong> of fruit. There is no limit on the amount of fruit each basket can hold.</li>
+	<li>Starting from any tree of your choice, you must pick <strong>exactly one fruit</strong> from <strong>every</strong> tree (including the start tree) while moving to the right. The picked fruits must fit in one of your baskets.</li>
+	<li>Once you reach a tree with fruit that cannot fit in your baskets, you must stop.</li>
+</ul>
+
+<p>Given the integer array <code>fruits</code>, return <em>the <strong>maximum</strong> number of fruits you can pick</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> fruits = [<u>1,2,1</u>]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> We can pick from all 3 trees.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> fruits = [0,<u>1,2,2</u>]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> We can pick from trees [1,2,2].
+If we had started at the first tree, we would only pick from trees [0,1].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> fruits = [1,<u>2,3,2,2</u>]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> We can pick from trees [2,3,2,2].
+If we had started at the first tree, we would only pick from trees [1,2].
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> fruits = [3,3,3,<u>1,2,1,1,2</u>,3,3,4]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> We can pick from trees [1,2,1,1,2].
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= fruits.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= fruits[i] &lt; fruits.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/generate-parentheses/README.md b/generate-parentheses/README.md
new file mode 100644
index 0000000..2053704
--- /dev/null
+++ b/generate-parentheses/README.md
@@ -0,0 +1,17 @@
+<h2>22. Generate Parentheses</h2><h3>Medium</h3><hr><div><p>Given <code>n</code> pairs of parentheses, write a function to <em>generate all combinations of well-formed parentheses</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 3
+<strong>Output:</strong> ["((()))","(()())","(())()","()(())","()()()"]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> ["()"]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 8</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/generate-parentheses/generate-parentheses.cpp b/generate-parentheses/generate-parentheses.cpp
new file mode 100644
index 0000000..4a49c74
--- /dev/null
+++ b/generate-parentheses/generate-parentheses.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    vector<string>result;
+    
+    void helper(int open,int close,int n,string current)
+    {
+        if(current.length()==n*2)
+        {
+            result.push_back(current);
+            return;
+        }
+        if(open<n)  helper(open+1,close,n,current+"(");
+        if(close<open)  helper(open,close+1,n,current+")");
+    }
+    vector<string> generateParenthesis(int n) {
+        helper(0,0,n,"");
+        return result;
+    }
+};
\ No newline at end of file
diff --git a/group-anagrams/README.md b/group-anagrams/README.md
new file mode 100644
index 0000000..e97202a
--- /dev/null
+++ b/group-anagrams/README.md
@@ -0,0 +1,24 @@
+<h2>49. Group Anagrams</h2><h3>Medium</h3><hr><div><p>Given an array of strings <code>strs</code>, group <strong>the anagrams</strong> together. You can 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> strs = ["eat","tea","tan","ate","nat","bat"]
+<strong>Output:</strong> [["bat"],["nat","tan"],["ate","eat","tea"]]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> strs = [""]
+<strong>Output:</strong> [[""]]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> strs = ["a"]
+<strong>Output:</strong> [["a"]]
+</pre>
+<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 lower-case English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/group-anagrams/group-anagrams.cpp b/group-anagrams/group-anagrams.cpp
new file mode 100644
index 0000000..c1eb42d
--- /dev/null
+++ b/group-anagrams/group-anagrams.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    vector<vector<string>> groupAnagrams(vector<string>& strs) {
+        unordered_map<string, vector<string>> mp;
+        for (string s : strs) {
+            mp[strSort(s)].push_back(s);
+        }
+        vector<vector<string>> anagrams;
+        for (auto p : mp) { 
+            anagrams.push_back(p.second);
+        }
+        return anagrams;
+    }
+private:
+    string strSort(string s) {
+        int counter[26] = {0};
+        for (char c : s) {
+            counter[c - 'a']++;
+        }
+        string t;
+        for (int c = 0; c < 26; c++) {
+            t += string(counter[c], c + 'a');
+        }
+        return t;
+    }
+};
\ No newline at end of file
diff --git a/group-the-people-given-the-group-size-they-belong-to/README.md b/group-the-people-given-the-group-size-they-belong-to/README.md
new file mode 100644
index 0000000..3db9e5a
--- /dev/null
+++ b/group-the-people-given-the-group-size-they-belong-to/README.md
@@ -0,0 +1,35 @@
+<h2>1282. Group the People Given the Group Size They Belong To</h2><h3>Medium</h3><hr><div><p>There are <code>n</code> people&nbsp;that are split into some unknown number of groups. Each person is labeled with a&nbsp;<strong>unique ID</strong>&nbsp;from&nbsp;<code>0</code>&nbsp;to&nbsp;<code>n - 1</code>.</p>
+
+<p>You are given an integer array&nbsp;<code>groupSizes</code>, where <code>groupSizes[i]</code>&nbsp;is the size of the group that person&nbsp;<code>i</code>&nbsp;is in. For example, if&nbsp;<code>groupSizes[1] = 3</code>, then&nbsp;person&nbsp;<code>1</code>&nbsp;must be in a&nbsp;group of size&nbsp;<code>3</code>.</p>
+
+<p>Return&nbsp;<em>a list of groups&nbsp;such that&nbsp;each person&nbsp;<code>i</code>&nbsp;is in a group of size&nbsp;<code>groupSizes[i]</code></em>.</p>
+
+<p>Each person should&nbsp;appear in&nbsp;<strong>exactly one group</strong>,&nbsp;and every person must be in a group. If there are&nbsp;multiple answers, <strong>return any of them</strong>. It is <strong>guaranteed</strong> that there will be <strong>at least one</strong> valid solution for the given input.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> groupSizes = [3,3,3,3,3,1,3]
+<strong>Output:</strong> [[5],[0,1,2],[3,4,6]]
+<b>Explanation:</b> 
+The first group is [5]. The size is 1, and groupSizes[5] = 1.
+The second group is [0,1,2]. The size is 3, and groupSizes[0] = groupSizes[1] = groupSizes[2] = 3.
+The third group is [3,4,6]. The size is 3, and groupSizes[3] = groupSizes[4] = groupSizes[6] = 3.
+Other possible solutions are [[2,1,6],[5],[0,4,3]] and [[5],[0,6,2],[4,3,1]].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> groupSizes = [2,1,3,3,3,2]
+<strong>Output:</strong> [[1],[0,5],[2,3,4]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>groupSizes.length == n</code></li>
+	<li><code>1 &lt;= n&nbsp;&lt;= 500</code></li>
+	<li><code>1 &lt;=&nbsp;groupSizes[i] &lt;= n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/group-the-people-given-the-group-size-they-belong-to/group-the-people-given-the-group-size-they-belong-to.cpp b/group-the-people-given-the-group-size-they-belong-to/group-the-people-given-the-group-size-they-belong-to.cpp
new file mode 100644
index 0000000..b3c7464
--- /dev/null
+++ b/group-the-people-given-the-group-size-they-belong-to/group-the-people-given-the-group-size-they-belong-to.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+   vector<vector<int>> groupThePeople(vector<int>& gz) {
+  vector<vector<int>> res, groups(gz.size() + 3);
+  for (auto i = 0; i < gz.size(); ++i) {
+    groups[gz[i]].push_back(i);
+    if (groups[gz[i]].size() == gz[i]) {
+      res.push_back({});
+      swap(res.back(), groups[gz[i]]);
+    }
+  }
+  return res;
+}
+};
\ No newline at end of file
diff --git a/hamming-distance/README.md b/hamming-distance/README.md
new file mode 100644
index 0000000..3f86179
--- /dev/null
+++ b/hamming-distance/README.md
@@ -0,0 +1,29 @@
+<h2>461. Hamming Distance</h2><h3>Easy</h3><hr><div><p>The <a href="https://en.wikipedia.org/wiki/Hamming_distance" target="_blank">Hamming distance</a> between two integers is the number of positions at which the corresponding bits are different.</p>
+
+<p>Given two integers <code>x</code> and <code>y</code>, return <em>the <strong>Hamming distance</strong> between them</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> x = 1, y = 4
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+1   (0 0 0 1)
+4   (0 1 0 0)
+       ↑   ↑
+The above arrows point to positions where the corresponding bits are different.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> x = 3, y = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;=&nbsp;x, y &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/hamming-distance/hamming-distance.cpp b/hamming-distance/hamming-distance.cpp
new file mode 100644
index 0000000..0989ce1
--- /dev/null
+++ b/hamming-distance/hamming-distance.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int hammingDistance(int x, int y) {
+        
+      int sum = 0;
+      
+      while(x != 0 ||  y != 0)
+      {
+        if(x % 2 == 0)
+        {
+          if(y % 2 != 0)
+          {
+            sum++;
+          }
+        }
+        else
+        {
+          if(y % 2 == 0)
+          {
+            sum++;
+          }
+        }
+        x = x/2;
+        y = y/2;
+      }
+      
+      return sum;
+    }
+};
\ No newline at end of file
diff --git a/house-robber-ii/README.md b/house-robber-ii/README.md
new file mode 100644
index 0000000..07c2349
--- /dev/null
+++ b/house-robber-ii/README.md
@@ -0,0 +1,34 @@
+<h2>213. House Robber II</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. 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>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>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>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>
+</div>
\ No newline at end of file
diff --git a/house-robber-iii/README.md b/house-robber-iii/README.md
new file mode 100644
index 0000000..b192749
--- /dev/null
+++ b/house-robber-iii/README.md
@@ -0,0 +1,29 @@
+<h2>337. House Robber III</h2><h3>Medium</h3><hr><div><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>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>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>
+</div>
\ No newline at end of file
diff --git a/house-robber-iii/house-robber-iii.cpp b/house-robber-iii/house-robber-iii.cpp
new file mode 100644
index 0000000..d06ac79
--- /dev/null
+++ b/house-robber-iii/house-robber-iii.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int tryRob(TreeNode* root, int& l, int& r) {
+        if (!root)
+            return 0;
+            
+        int ll = 0, lr = 0, rl = 0, rr = 0;
+        l = tryRob(root->left, ll, lr);
+        r = tryRob(root->right, rl, rr);
+        
+        return max(root->val + ll + lr + rl + rr, l + r);
+    }
+
+    int rob(TreeNode* root) {
+        int l, r;
+        return tryRob(root, l, r);
+    }
+};
\ No newline at end of file
diff --git a/house-robber/README.md b/house-robber/README.md
new file mode 100644
index 0000000..3b9409e
--- /dev/null
+++ b/house-robber/README.md
@@ -0,0 +1,29 @@
+<h2>198. House Robber</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/house-robber/house-robber.cpp b/house-robber/house-robber.cpp
new file mode 100644
index 0000000..7df70b5
--- /dev/null
+++ b/house-robber/house-robber.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int rob(vector<int>& nums) {
+        int n = nums.size();
+        vector<int> dp(n+1);
+        
+        dp[0] = 0;
+        dp[1] = nums[0];
+        
+        if(nums.size()<=1)return nums[0];
+        for(int i=2;i<=n;i++)
+        {
+            if(dp[i-1]>=dp[i-2]+nums[i-1])
+                dp[i] = dp[i-1];
+            else
+                dp[i] = dp[i-2]+nums[i-1];
+        }
+        
+        return dp[n];
+    }
+};
\ No newline at end of file
diff --git a/increasing-order-search-tree/README.md b/increasing-order-search-tree/README.md
new file mode 100644
index 0000000..bb4f076
--- /dev/null
+++ b/increasing-order-search-tree/README.md
@@ -0,0 +1,22 @@
+<h2>897. Increasing Order Search Tree</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a binary search tree, rearrange the tree in <strong>in-order</strong> so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only one right child.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/17/ex1.jpg" style="width: 600px; height: 350px;">
+<pre><strong>Input:</strong> root = [5,3,6,2,4,null,8,1,null,null,null,7,9]
+<strong>Output:</strong> [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/17/ex2.jpg" style="width: 300px; height: 114px;">
+<pre><strong>Input:</strong> root = [5,1,7]
+<strong>Output:</strong> [1,null,5,null,7]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the given tree will be in the range <code>[1, 100]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 1000</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/insert-into-a-binary-search-tree/README.md b/insert-into-a-binary-search-tree/README.md
new file mode 100644
index 0000000..8488968
--- /dev/null
+++ b/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/insert-into-a-binary-search-tree/insert-into-a-binary-search-tree.cpp b/insert-into-a-binary-search-tree/insert-into-a-binary-search-tree.cpp
new file mode 100644
index 0000000..49e8df4
--- /dev/null
+++ b/insert-into-a-binary-search-tree/insert-into-a-binary-search-tree.cpp
@@ -0,0 +1,33 @@
+/**
+ * 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:
+    TreeNode* insertIntoBST(TreeNode* root, int val) {
+      if(root == NULL)
+      {
+        TreeNode* newNode = new TreeNode(val);
+        return newNode;
+        
+      }
+      if(root->val > val)
+      {
+        root->left = insertIntoBST(root->left,val);
+        return root;
+      }
+      if(root->val < val)
+      {
+        root->right = insertIntoBST(root->right,val);
+        return root;
+      }
+      return root;
+    }
+};
\ No newline at end of file
diff --git a/insertion-sort-list/README.md b/insertion-sort-list/README.md
new file mode 100644
index 0000000..521112e
--- /dev/null
+++ b/insertion-sort-list/README.md
@@ -0,0 +1,33 @@
+<h2>147. Insertion Sort List</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/insertion-sort-list/insertion-sort-list.cpp b/insertion-sort-list/insertion-sort-list.cpp
new file mode 100644
index 0000000..4858a5b
--- /dev/null
+++ b/insertion-sort-list/insertion-sort-list.cpp
@@ -0,0 +1,20 @@
+/**
+ * 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* insertionSortList(ListNode* head) {
+        for(auto cur = head; cur; cur = cur -> next) 
+            for(auto j = head; j != cur; j = j -> next) 
+                if(j -> val > cur -> val) 
+                    swap(j -> val, cur -> val);
+        return head;    
+    }
+};
\ No newline at end of file
diff --git a/integer-break/README.md b/integer-break/README.md
new file mode 100644
index 0000000..d697f83
--- /dev/null
+++ b/integer-break/README.md
@@ -0,0 +1,26 @@
+<h2>343. Integer Break</h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, break it into the sum of <code>k</code> <strong>positive integers</strong>, where <code>k &gt;= 2</code>, and maximize the product of those integers.</p>
+
+<p>Return <em>the maximum product you can get</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 2
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> 2 = 1 + 1, 1 × 1 = 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 10
+<strong>Output:</strong> 36
+<strong>Explanation:</strong> 10 = 3 + 3 + 4, 3 × 3 × 4 = 36.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 58</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/integer-break/integer-break.cpp b/integer-break/integer-break.cpp
new file mode 100644
index 0000000..291f299
--- /dev/null
+++ b/integer-break/integer-break.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int recursion(int n, int cur)
+    {
+        // base
+        if (n == 0 || cur == 0) {
+            return 1;
+        }
+        // recurisve
+        if (cur > n) {
+            return recursion(n - 0, cur - 1);
+        }
+        else {
+            return max(recursion(n - 0, cur - 1), cur * recursion(n - cur, cur));
+        }
+    }
+    
+    int integerBreak(int n) 
+    {
+        return recursion(n, n - 1);    
+    }
+};
\ No newline at end of file
diff --git a/intersection-of-two-arrays/README.md b/intersection-of-two-arrays/README.md
new file mode 100644
index 0000000..b873037
--- /dev/null
+++ b/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/intersection-of-two-arrays/intersection-of-two-arrays.cpp b/intersection-of-two-arrays/intersection-of-two-arrays.cpp
new file mode 100644
index 0000000..fd7d89b
--- /dev/null
+++ b/intersection-of-two-arrays/intersection-of-two-arrays.cpp
@@ -0,0 +1,39 @@
+class Solution {
+public:
+    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
+        
+        vector<int> c;
+        sort(nums1.begin(),nums1.end());
+        sort(nums2.begin(),nums2.end());
+        
+        int a = nums1.size();
+        int b = nums2.size();
+        int i = 0,j = 0;
+        while((i < a) && (j < b))
+        {
+          if(nums1[i] == nums2[j]) 
+          {
+              c.push_back(nums1[i]);
+              
+              while((i < a) && nums1[i] == c[c.size()-1] )
+              {
+                  i++;
+              }
+               while((j < b) && nums2[j] == c[c.size()-1] )
+              {
+                  j++;
+              }
+              
+          }
+           else
+           {
+               if(nums1[i] > nums2[j])
+                   j++;
+               else
+                   i++;
+           }
+        }
+        return c;
+        
+    }
+};
\ No newline at end of file
diff --git a/intersection-of-two-linked-lists/README.md b/intersection-of-two-linked-lists/README.md
new file mode 100644
index 0000000..682bf96
--- /dev/null
+++ b/intersection-of-two-linked-lists/README.md
@@ -0,0 +1,63 @@
+<h2>160. Intersection of Two Linked Lists</h2><h3>Easy</h3><hr><div><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>&nbsp;to your program. If you correctly return the intersected node, then your solution will be <strong>accepted</strong>.</p>
+
+<p>&nbsp;</p>
+<p><strong>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 '8'
+<strong>Explanation:</strong> The intersected node'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.
+</pre>
+
+<p><strong>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 '2'
+<strong>Explanation:</strong> The intersected node'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>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>0 &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(n)</code> time and use only <code>O(1)</code> memory?</div>
\ No newline at end of file
diff --git a/intersection-of-two-linked-lists/intersection-of-two-linked-lists.cpp b/intersection-of-two-linked-lists/intersection-of-two-linked-lists.cpp
new file mode 100644
index 0000000..3df00bd
--- /dev/null
+++ b/intersection-of-two-linked-lists/intersection-of-two-linked-lists.cpp
@@ -0,0 +1,39 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
+        ListNode * slow = headA;
+        ListNode * fast = headB;
+        
+        while(slow != fast)
+        {
+            if(slow == NULL)
+            {
+                 slow = headB;
+            }
+            else
+            {
+                slow =slow->next;
+            }
+            if(fast == NULL)
+            {
+                 fast = headA;
+            }
+            else
+            {
+                fast = fast->next;
+            }
+            
+            // slow = slow->next;
+            // fast = fast->next;
+        }
+        return slow;
+    }
+};
\ No newline at end of file
diff --git a/interval-list-intersections/README.md b/interval-list-intersections/README.md
new file mode 100644
index 0000000..11f71af
--- /dev/null
+++ b/interval-list-intersections/README.md
@@ -0,0 +1,45 @@
+<h2>986. Interval List Intersections</h2><h3>Medium</h3><hr><div><p>You are given two lists of closed intervals, <code>firstList</code> and <code>secondList</code>, where <code>firstList[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> and <code>secondList[j] = [start<sub>j</sub>, end<sub>j</sub>]</code>. Each list of intervals is pairwise <strong>disjoint</strong> and in <strong>sorted order</strong>.</p>
+
+<p>Return <em>the intersection of these two interval lists</em>.</p>
+
+<p>A <strong>closed interval</strong> <code>[a, b]</code> (with <code>a &lt;= b</code>) denotes the set of real numbers <code>x</code> with <code>a &lt;= x &lt;= b</code>.</p>
+
+<p>The <strong>intersection</strong> of two closed intervals is a set of real numbers that are either empty or represented as a closed interval. For example, the intersection of <code>[1, 3]</code> and <code>[2, 4]</code> is <code>[2, 3]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/01/30/interval1.png" style="width: 700px; height: 194px;">
+<pre><strong>Input:</strong> firstList = [[0,2],[5,10],[13,23],[24,25]], secondList = [[1,5],[8,12],[15,24],[25,26]]
+<strong>Output:</strong> [[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> firstList = [[1,3],[5,9]], secondList = []
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> firstList = [], secondList = [[4,8],[10,12]]
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> firstList = [[1,7]], secondList = [[3,10]]
+<strong>Output:</strong> [[3,7]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= firstList.length, secondList.length &lt;= 1000</code></li>
+	<li><code>firstList.length + secondList.length &gt;= 1</code></li>
+	<li><code>0 &lt;= start<sub>i</sub> &lt; end<sub>i</sub> &lt;= 10<sup>9</sup></code></li>
+	<li><code>end<sub>i</sub> &lt; start<sub>i+1</sub></code></li>
+	<li><code>0 &lt;= start<sub>j</sub> &lt; end<sub>j</sub> &lt;= 10<sup>9</sup> </code></li>
+	<li><code>end<sub>j</sub> &lt; start<sub>j+1</sub></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/interval-list-intersections/interval-list-intersections.cpp b/interval-list-intersections/interval-list-intersections.cpp
new file mode 100644
index 0000000..ee99724
--- /dev/null
+++ b/interval-list-intersections/interval-list-intersections.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    vector<vector<int>> intervalIntersection(vector<vector<int>>& A, vector<vector<int>>& B) {
+        vector<vector<int>> v;
+        int i=0,j=0;
+        while(i<A.size() && j<B.size()){
+            int l=max(A[i][0], B[j][0]);
+            int u=min(A[i][1], B[j][1]);
+            if(l<=u) v.push_back({l,u});
+            if(A[i][1] < B[j][1])   i++;
+            else j++;
+        }
+        return v;
+    }
+};
\ No newline at end of file
diff --git a/intervals-between-identical-elements/README.md b/intervals-between-identical-elements/README.md
new file mode 100644
index 0000000..c4b82d0
--- /dev/null
+++ b/intervals-between-identical-elements/README.md
@@ -0,0 +1,43 @@
+<h2>2121. Intervals Between Identical Elements</h2><h3>Medium</h3><hr><div><p>You are given a <strong>0-indexed</strong> array of <code>n</code> integers <code>arr</code>.</p>
+
+<p>The <strong>interval</strong> between two elements in <code>arr</code> is defined as the <strong>absolute difference</strong> between their indices. More formally, the <strong>interval</strong> between <code>arr[i]</code> and <code>arr[j]</code> is <code>|i - j|</code>.</p>
+
+<p>Return <em>an array</em> <code>intervals</code> <em>of length</em> <code>n</code> <em>where</em> <code>intervals[i]</code> <em>is <strong>the sum of intervals</strong> between </em><code>arr[i]</code><em> and each element in </em><code>arr</code><em> with the same value as </em><code>arr[i]</code><em>.</em></p>
+
+<p><strong>Note:</strong> <code>|x|</code> is the absolute value of <code>x</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [2,1,3,1,2,3,3]
+<strong>Output:</strong> [4,2,7,2,4,4,5]
+<strong>Explanation:</strong>
+- Index 0: Another 2 is found at index 4. |0 - 4| = 4
+- Index 1: Another 1 is found at index 3. |1 - 3| = 2
+- Index 2: Two more 3s are found at indices 5 and 6. |2 - 5| + |2 - 6| = 7
+- Index 3: Another 1 is found at index 1. |3 - 1| = 2
+- Index 4: Another 2 is found at index 0. |4 - 0| = 4
+- Index 5: Two more 3s are found at indices 2 and 6. |5 - 2| + |5 - 6| = 4
+- Index 6: Two more 3s are found at indices 2 and 5. |6 - 2| + |6 - 5| = 5
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [10,5,10,10]
+<strong>Output:</strong> [5,0,3,4]
+<strong>Explanation:</strong>
+- Index 0: Two more 10s are found at indices 2 and 3. |0 - 2| + |0 - 3| = 5
+- Index 1: There is only one 5 in the array, so its sum of intervals to identical elements is 0.
+- Index 2: Two more 10s are found at indices 0 and 3. |2 - 0| + |2 - 3| = 3
+- Index 3: Two more 10s are found at indices 0 and 2. |3 - 0| + |3 - 2| = 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == arr.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</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/invert-binary-tree/README.md b/invert-binary-tree/README.md
new file mode 100644
index 0000000..124a904
--- /dev/null
+++ b/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/invert-binary-tree/invert-binary-tree.cpp b/invert-binary-tree/invert-binary-tree.cpp
new file mode 100644
index 0000000..7d0ed0d
--- /dev/null
+++ b/invert-binary-tree/invert-binary-tree.cpp
@@ -0,0 +1,27 @@
+/**
+ * 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:
+    TreeNode* invertTree(TreeNode* root) {
+        if(root == NULL)
+          return NULL;
+      
+      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/is-graph-bipartite/README.md b/is-graph-bipartite/README.md
new file mode 100644
index 0000000..9965b88
--- /dev/null
+++ b/is-graph-bipartite/README.md
@@ -0,0 +1,39 @@
+<h2>785. Is Graph Bipartite?</h2><h3>Medium</h3><hr><div><p>There is an <strong>undirected</strong> graph with <code>n</code> nodes, where each node is numbered between <code>0</code> and <code>n - 1</code>. You are given a 2D array <code>graph</code>, where <code>graph[u]</code> is an array of nodes that node <code>u</code> is adjacent to. More formally, for each <code>v</code> in <code>graph[u]</code>, there is an undirected edge between node <code>u</code> and node <code>v</code>. The graph has the following properties:</p>
+
+<ul>
+	<li>There are no self-edges (<code>graph[u]</code> does not contain <code>u</code>).</li>
+	<li>There are no parallel edges (<code>graph[u]</code> does not contain duplicate values).</li>
+	<li>If <code>v</code> is in <code>graph[u]</code>, then <code>u</code> is in <code>graph[v]</code> (the graph is undirected).</li>
+	<li>The graph may not be connected, meaning there may be two nodes <code>u</code> and <code>v</code> such that there is no path between them.</li>
+</ul>
+
+<p>A graph is <strong>bipartite</strong> if the nodes can be partitioned into two independent sets <code>A</code> and <code>B</code> such that <strong>every</strong> edge in the graph connects a node in set <code>A</code> and a node in set <code>B</code>.</p>
+
+<p>Return <code>true</code><em> if and only if it is <strong>bipartite</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/21/bi2.jpg" style="width: 222px; height: 222px;">
+<pre><strong>Input:</strong> graph = [[1,2,3],[0,2],[0,1,3],[0,2]]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> There is no way to partition the nodes into two independent sets such that every edge connects a node in one and a node in the other.</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/21/bi1.jpg" style="width: 222px; height: 222px;">
+<pre><strong>Input:</strong> graph = [[1,3],[0,2],[1,3],[0,2]]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> We can partition the nodes into two sets: {0, 2} and {1, 3}.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>graph.length == n</code></li>
+	<li><code>1 &lt;= n &lt;= 100</code></li>
+	<li><code>0 &lt;= graph[u].length &lt; n</code></li>
+	<li><code>0 &lt;= graph[u][i] &lt;= n - 1</code></li>
+	<li><code>graph[u]</code>&nbsp;does not contain&nbsp;<code>u</code>.</li>
+	<li>All the values of <code>graph[u]</code> are <strong>unique</strong>.</li>
+	<li>If <code>graph[u]</code> contains <code>v</code>, then <code>graph[v]</code> contains <code>u</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/is-graph-bipartite/is-graph-bipartite.cpp b/is-graph-bipartite/is-graph-bipartite.cpp
new file mode 100644
index 0000000..4fe43c3
--- /dev/null
+++ b/is-graph-bipartite/is-graph-bipartite.cpp
@@ -0,0 +1,53 @@
+class Solution {
+public:
+  
+  bool isBipartiteBFS(vector<vector<int>>& graph,bool * visited,int * color,int source)
+  {
+    color[source] = 0;
+    visited[source] = true;
+    
+    
+    queue <int> q;
+    q.push(source);
+    
+    while(!q.empty())
+    {
+      int front = q.front();
+      q.pop();
+      
+      for(auto nbrs:graph[front])
+      {
+        if(visited[nbrs]  ==  false)
+        {
+          visited[nbrs] = true;
+          color[nbrs] = !color[front];
+          q.push(nbrs);
+        }
+        else
+        {
+          if(color[nbrs] == color[front])
+            return false;
+        }
+        
+      }
+    }
+    return true;
+  }
+  
+    bool isBipartite(vector<vector<int>>& graph) {
+      bool * visited = new bool [graph.size()] {false};
+      int * color = new int  [graph.size()] {-1};
+      
+      
+      for(int i=0;i<graph.size();i++)
+      {
+        if(visited[i] == false)
+        {
+          if(isBipartiteBFS(graph,visited,color,i)==false)
+            return false;
+        }
+      }
+      return true;
+      
+    }
+};
\ No newline at end of file
diff --git a/is-subsequence/README.md b/is-subsequence/README.md
new file mode 100644
index 0000000..60fa767
--- /dev/null
+++ b/is-subsequence/README.md
@@ -0,0 +1,23 @@
+<h2>392. Is Subsequence</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/is-subsequence/is-subsequence.cpp b/is-subsequence/is-subsequence.cpp
new file mode 100644
index 0000000..14d5391
--- /dev/null
+++ b/is-subsequence/is-subsequence.cpp
@@ -0,0 +1,27 @@
+class Solution {
+public:
+    bool isSubsequence(string s, string t) {
+        if(s.size()>t.size())
+            return false;
+        
+        int i = 0;
+        int j = 0;
+        while(i< s.size() && j<t.size())
+        {
+            if(s[i] == t[j])
+            {
+                i++;
+                j++;
+            }
+            else
+            {
+                j++;
+            }
+                
+        }
+        
+        if(i != s.size())
+            return false;
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/isomorphic-strings/README.md b/isomorphic-strings/README.md
new file mode 100644
index 0000000..41cb64b
--- /dev/null
+++ b/isomorphic-strings/README.md
@@ -0,0 +1,26 @@
+<h2>205. Isomorphic Strings</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>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "egg", t = "add"
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "foo", t = "bar"
+<strong>Output:</strong> false
+</pre><p><strong>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/isomorphic-strings/isomorphic-strings.cpp b/isomorphic-strings/isomorphic-strings.cpp
new file mode 100644
index 0000000..f70031d
--- /dev/null
+++ b/isomorphic-strings/isomorphic-strings.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    bool isIsomorphic(string s, string t) {
+        int m1[256] = {0}, m2[256] = {0}, n = s.size();
+        for (int i = 0; i < n; ++i) {
+            if (m1[s[i]] != m2[t[i]]) return false;
+            m1[s[i]] = i + 1;
+            m2[t[i]] = i + 1;
+        }
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/iterator-for-combination/README.md b/iterator-for-combination/README.md
new file mode 100644
index 0000000..155bc99
--- /dev/null
+++ b/iterator-for-combination/README.md
@@ -0,0 +1,37 @@
+<h2>1286. Iterator for Combination</h2><h3>Medium</h3><hr><div><p>Design the <code>CombinationIterator</code> class:</p>
+
+<ul>
+	<li><code>CombinationIterator(string characters, int combinationLength)</code>&nbsp;Initializes the object with&nbsp;a string&nbsp;<code>characters</code>&nbsp;of <strong>sorted distinct</strong> lowercase English letters and a number&nbsp;<code>combinationLength</code> as arguments.</li>
+	<li><code>next()</code>&nbsp;Returns the next combination of length <code>combinationLength</code>&nbsp;in <strong>lexicographical order</strong>.</li>
+	<li><code>hasNext()</code>&nbsp;Returns <code>true</code>&nbsp;if and only if&nbsp;there exists a next combination.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["CombinationIterator", "next", "hasNext", "next", "hasNext", "next", "hasNext"]
+[["abc", 2], [], [], [], [], [], []]
+<strong>Output</strong>
+[null, "ab", true, "ac", true, "bc", false]
+
+<strong>Explanation</strong>
+CombinationIterator itr = new CombinationIterator("abc", 2);
+itr.next();    // return "ab"
+itr.hasNext(); // return True
+itr.next();    // return "ac"
+itr.hasNext(); // return True
+itr.next();    // return "bc"
+itr.hasNext(); // return False
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= combinationLength &lt;=&nbsp;characters.length &lt;= 15</code></li>
+	<li>All the characters of <code>characters</code> are <strong>unique</strong>.</li>
+	<li>At most <code>10<sup>4</sup></code>&nbsp;calls will be made to <code>next</code> and <code>hasNext</code>.</li>
+	<li>It's guaranteed that all&nbsp;calls&nbsp;of the function <code>next</code>&nbsp;are valid.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/iterator-for-combination/iterator-for-combination.cpp b/iterator-for-combination/iterator-for-combination.cpp
new file mode 100644
index 0000000..35f25fb
--- /dev/null
+++ b/iterator-for-combination/iterator-for-combination.cpp
@@ -0,0 +1,24 @@
+class CombinationIterator {
+    string s;
+    int n, L, mask = 0;
+    bool has_next = true;
+public:
+    CombinationIterator(string s, int n) : s(s), L(size(s)), n(n) {
+        for(int i = 0; i < n; i++) mask |= 1 << (L-1-i);
+    }
+    string next() {
+        string combination = "";
+        for(int j = L; j >= 0; j--)             // iterate over mask from MSB to LSB
+                if(mask & (1 << j))               // if a bit is set,
+                    combination += s[L-1-j];      // then add character corresponding to that bit
+        updateMask();                             // move to next mask
+        return combination;
+    }
+    // using Gospel's hack
+    void updateMask() {
+        int t = mask + 1, u = t ^ mask, v = t & mask;
+        mask = v - (v & -v) / (u + 1);
+        has_next = mask;
+    }
+    bool hasNext() { return has_next; }
+};
\ No newline at end of file
diff --git a/jewels-and-stones/README.md b/jewels-and-stones/README.md
new file mode 100644
index 0000000..1e29354
--- /dev/null
+++ b/jewels-and-stones/README.md
@@ -0,0 +1,21 @@
+<h2>771. Jewels and Stones</h2><h3>Easy</h3><hr><div><p>You're given strings <code>jewels</code> representing the types of stones that are jewels, and <code>stones</code> representing the stones you have. Each character in <code>stones</code> is a type of stone you have. You want to know how many of the stones you have are also jewels.</p>
+
+<p>Letters are case sensitive, so <code>"a"</code> is considered a different type of stone from <code>"A"</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> jewels = "aA", stones = "aAAbbbb"
+<strong>Output:</strong> 3
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> jewels = "z", stones = "ZZ"
+<strong>Output:</strong> 0
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;=&nbsp;jewels.length, stones.length &lt;= 50</code></li>
+	<li><code>jewels</code> and <code>stones</code> consist of only English letters.</li>
+	<li>All the characters of&nbsp;<code>jewels</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/jewels-and-stones/jewels-and-stones.cpp b/jewels-and-stones/jewels-and-stones.cpp
new file mode 100644
index 0000000..6211b4a
--- /dev/null
+++ b/jewels-and-stones/jewels-and-stones.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int numJewelsInStones(string jewels, string stones) {
+        
+        unordered_map<char,int> m;
+        
+        for(int i=0;i<stones.length();i++)
+        {
+            m[stones[i]]++;
+        }
+        
+        int ans = 0;
+       for(int i=0;i<jewels.length();i++)
+       {
+           if(m.count(jewels[i]))
+           {
+               ans += m[jewels[i]];
+           }
+       }
+        return ans;
+
+        
+    }
+};
\ No newline at end of file
diff --git a/jump-game-ii/README.md b/jump-game-ii/README.md
new file mode 100644
index 0000000..93f4240
--- /dev/null
+++ b/jump-game-ii/README.md
@@ -0,0 +1,30 @@
+<h2>45. Jump Game II</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/jump-game-ii/jump-game-ii.cpp b/jump-game-ii/jump-game-ii.cpp
new file mode 100644
index 0000000..2cc6688
--- /dev/null
+++ b/jump-game-ii/jump-game-ii.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int jump(vector<int>& nums) {
+        int n = size(nums), i = 0, maxReachable = 0, lastJumpedPos = 0, jumps = 0;
+	while(lastJumpedPos < n - 1) {  // loop till last jump hasn't taken us till the end
+		maxReachable = max(maxReachable, i + nums[i]);  // furthest index reachable on the next level from current level
+		if(i == lastJumpedPos) {			  // current level has been iterated & maxReachable position on next level has been finalised
+			lastJumpedPos = maxReachable;     // so just move to that maxReachable position
+			jumps++;                          // and increment the level
+	// NOTE: jump^ only gets updated after we iterate all possible jumps from previous level
+	//       This ensures jumps will only store minimum jump required to reach lastJumpedPos
+		}            
+		i++;
+	}
+	return jumps;
+    }
+};
\ No newline at end of file
diff --git a/jump-game/README.md b/jump-game/README.md
new file mode 100644
index 0000000..c9f4e2b
--- /dev/null
+++ b/jump-game/README.md
@@ -0,0 +1,27 @@
+<h2>55. Jump Game</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/k-closest-points-to-origin/README.md b/k-closest-points-to-origin/README.md
new file mode 100644
index 0000000..69b6c43
--- /dev/null
+++ b/k-closest-points-to-origin/README.md
@@ -0,0 +1,33 @@
+<h2>973. K Closest Points to Origin</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/k-closest-points-to-origin/k-closest-points-to-origin.cpp b/k-closest-points-to-origin/k-closest-points-to-origin.cpp
new file mode 100644
index 0000000..66d168c
--- /dev/null
+++ b/k-closest-points-to-origin/k-closest-points-to-origin.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    vector<vector<int>> kClosest(vector<vector<int>>& points, int K) {
+       // points.push_back({0,0});
+        partial_sort(points.begin(), points.begin() + K, points.end(), [](vector<int>& p, vector<int>& q) {
+            return p[0] * p[0] + p[1] * p[1] < q[0] * q[0] + q[1] * q[1];
+        });
+        
+        
+        return vector<vector<int>>(points.begin(), points.begin() + K);
+    }
+};
\ No newline at end of file
diff --git a/koko-eating-bananas/README.md b/koko-eating-bananas/README.md
new file mode 100644
index 0000000..311ecd1
--- /dev/null
+++ b/koko-eating-bananas/README.md
@@ -0,0 +1,36 @@
+<h2>875. Koko Eating Bananas</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/kth-largest-element-in-an-array/README.md b/kth-largest-element-in-an-array/README.md
new file mode 100644
index 0000000..88e18f4
--- /dev/null
+++ b/kth-largest-element-in-an-array/README.md
@@ -0,0 +1,20 @@
+<h2>  Kth Largest Element in an Array</h2><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/kth-smallest-element-in-a-bst/README.md b/kth-smallest-element-in-a-bst/README.md
new file mode 100644
index 0000000..4d6e137
--- /dev/null
+++ b/kth-smallest-element-in-a-bst/README.md
@@ -0,0 +1,27 @@
+<h2>230. Kth Smallest Element in a BST</h2><h3>Medium</h3><hr><div><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>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>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>
+</div>
\ No newline at end of file
diff --git a/kth-smallest-element-in-a-bst/kth-smallest-element-in-a-bst.cpp b/kth-smallest-element-in-a-bst/kth-smallest-element-in-a-bst.cpp
new file mode 100644
index 0000000..54c6eac
--- /dev/null
+++ b/kth-smallest-element-in-a-bst/kth-smallest-element-in-a-bst.cpp
@@ -0,0 +1,60 @@
+/**
+ * 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:
+    int kthSmallest(TreeNode* root, int k) {
+      if(root == NULL)
+          return -1;
+      int count = 0;
+      int kmin = INT_MAX;
+      TreeNode * curr = root;
+       TreeNode * pre;
+      while(curr)
+      {
+        if(curr->left==NULL)
+        {
+          count++;
+          if(k==count)
+          {
+            kmin= curr->val;
+          }
+          curr = curr->right;
+        }
+        else
+        {
+         pre = curr->left;
+          while(pre->right != NULL && pre->right != curr)
+          {
+            pre = pre->right;
+          }
+          
+          if(pre->right == NULL)
+          {
+            pre->right = curr;
+            curr = curr->left;
+          }
+          else
+          {
+            pre->right = NULL;
+            count++;
+            if(k == count)
+            {
+              kmin= curr->val;
+            }
+            curr = curr->right;
+          }
+        }
+      }
+      
+      return kmin;
+    }
+};
\ No newline at end of file
diff --git a/kth-smallest-element-in-a-sorted-matrix/README.md b/kth-smallest-element-in-a-sorted-matrix/README.md
new file mode 100644
index 0000000..45ee2d5
--- /dev/null
+++ b/kth-smallest-element-in-a-sorted-matrix/README.md
@@ -0,0 +1,30 @@
+<h2>378. Kth Smallest Element in a Sorted Matrix</h2><h3>Medium</h3><hr><div><p>Given an <code>n x n</code> <code>matrix</code> where each of the rows and columns are sorted in ascending order, return <em>the</em> <code>k<sup>th</sup></code> <em>smallest element in the matrix</em>.</p>
+
+<p>Note that it is the <code>k<sup>th</sup></code> smallest element <strong>in the sorted order</strong>, not the <code>k<sup>th</sup></code> <strong>distinct</strong> element.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8
+<strong>Output:</strong> 13
+<strong>Explanation:</strong> The elements in the matrix are [1,5,9,10,11,12,13,<u><strong>13</strong></u>,15], and the 8<sup>th</sup> smallest number is 13
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [[-5]], k = 1
+<strong>Output:</strong> -5
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == matrix.length</code></li>
+	<li><code>n == matrix[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 300</code></li>
+	<li><code>-10<sup>9</sup> &lt;= matrix[i][j] &lt;= 10<sup>9</sup></code></li>
+	<li>All the rows and columns of <code>matrix</code> are <strong>guaranteed</strong> to be sorted in <strong>non-decreasing order</strong>.</li>
+	<li><code>1 &lt;= k &lt;= n<sup>2</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/kth-smallest-element-in-a-sorted-matrix/kth-smallest-element-in-a-sorted-matrix.cpp b/kth-smallest-element-in-a-sorted-matrix/kth-smallest-element-in-a-sorted-matrix.cpp
new file mode 100644
index 0000000..b7bdafd
--- /dev/null
+++ b/kth-smallest-element-in-a-sorted-matrix/kth-smallest-element-in-a-sorted-matrix.cpp
@@ -0,0 +1,29 @@
+class Solution
+{
+public:
+	int kthSmallest(vector<vector<int>>& matrix, int k)
+	{
+		int n = matrix.size();
+		int le = matrix[0][0], ri = matrix[n - 1][n - 1];
+		int mid = 0;
+		while (le < ri)
+		{
+			mid = le + (ri-le)/2;
+			int num = 0;
+			for (int i = 0; i < n; i++)
+			{
+				int pos = upper_bound(matrix[i].begin(), matrix[i].end(), mid) - matrix[i].begin();
+				num += pos;
+			}
+			if (num < k)
+			{
+				le = mid + 1;
+			}
+			else
+			{
+				ri = mid;
+			}
+		}
+		return le;
+	}
+};
\ No newline at end of file
diff --git a/largest-component-size-by-common-factor/README.md b/largest-component-size-by-common-factor/README.md
new file mode 100644
index 0000000..ed887de
--- /dev/null
+++ b/largest-component-size-by-common-factor/README.md
@@ -0,0 +1,37 @@
+<h2>952. Largest Component Size by Common Factor</h2><h3>Hard</h3><hr><div><p>You are given an integer array of unique positive integers <code>nums</code>. Consider the following graph:</p>
+
+<ul>
+	<li>There are <code>nums.length</code> nodes, labeled <code>nums[0]</code> to <code>nums[nums.length - 1]</code>,</li>
+	<li>There is an undirected edge between <code>nums[i]</code> and <code>nums[j]</code> if <code>nums[i]</code> and <code>nums[j]</code> share a common factor greater than <code>1</code>.</li>
+</ul>
+
+<p>Return <em>the size of the largest connected component in the graph</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/01/ex1.png" style="width: 500px; height: 97px;">
+<pre><strong>Input:</strong> nums = [4,6,15,35]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/01/ex2.png" style="width: 500px; height: 85px;">
+<pre><strong>Input:</strong> nums = [20,50,9,63]
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2018/12/01/ex3.png" style="width: 500px; height: 260px;">
+<pre><strong>Input:</strong> nums = [2,3,6,7,4,12,21,39]
+<strong>Output:</strong> 8
+</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>5</sup></code></li>
+	<li>All the values of <code>nums</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/largest-component-size-by-common-factor/largest-component-size-by-common-factor.cpp b/largest-component-size-by-common-factor/largest-component-size-by-common-factor.cpp
new file mode 100644
index 0000000..5164025
--- /dev/null
+++ b/largest-component-size-by-common-factor/largest-component-size-by-common-factor.cpp
@@ -0,0 +1,45 @@
+class UnionFindSet {
+public:
+    UnionFindSet(int n) : _parent(n) {
+        for (int i=0; i<n; i++) {
+            _parent[i] = i;
+        }
+    }
+    
+    void Union(int x, int y) {
+        _parent[Find(x)] = _parent[Find(y)];
+    }
+    
+    int Find(int x) {
+        if (_parent[x] != x) {
+            _parent[x] = Find(_parent[x]);
+        }
+        return _parent[x];
+    }
+    
+private:
+    vector<int> _parent;
+};
+
+class Solution {
+public:
+    int largestComponentSize(vector<int>& A) {
+        int n = *max_element(A.begin(), A.end());
+        UnionFindSet ufs(n+1);
+        for (int &a : A) {
+            for (int k = 2; k <= sqrt(a); k++) {
+                if (a % k == 0) {
+                    ufs.Union(a, k);
+                    ufs.Union(a, a / k);
+                }
+            }
+        }
+        
+        unordered_map<int, int> mp;
+        int ans = 1;
+        for (int &a : A) {
+            ans = max(ans, ++mp[ufs.Find(a)]);
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/letter-combinations-of-a-phone-number/README.md b/letter-combinations-of-a-phone-number/README.md
new file mode 100644
index 0000000..c14d0ad
--- /dev/null
+++ b/letter-combinations-of-a-phone-number/README.md
@@ -0,0 +1,33 @@
+<h2>17. Letter Combinations of a Phone Number</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/letter-combinations-of-a-phone-number/letter-combinations-of-a-phone-number.cpp b/letter-combinations-of-a-phone-number/letter-combinations-of-a-phone-number.cpp
new file mode 100644
index 0000000..d65c402
--- /dev/null
+++ b/letter-combinations-of-a-phone-number/letter-combinations-of-a-phone-number.cpp
@@ -0,0 +1,24 @@
+class Solution {
+public:
+    const vector<string> pad = {
+        "", "", "abc", "def", "ghi", "jkl",
+        "mno", "pqrs", "tuv", "wxyz"
+    };
+    
+    vector<string> letterCombinations(string digits) {
+        if (digits.empty()) return {};
+		vector<string> result;
+        result.push_back("");
+        
+        for(auto digit: digits) {
+            vector<string> tmp;
+            for(auto candidate: pad[digit - '0']) {
+                for(auto s: result) {
+                    tmp.push_back(s + candidate);
+                }
+            }
+            result.swap(tmp);
+        }
+        return result;
+    }
+};
\ No newline at end of file
diff --git a/linked-list-cycle-ii/README.md b/linked-list-cycle-ii/README.md
new file mode 100644
index 0000000..d35ac2d
--- /dev/null
+++ b/linked-list-cycle-ii/README.md
@@ -0,0 +1,40 @@
+<h2>142. Linked List Cycle II</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/linked-list-cycle/README.md b/linked-list-cycle/README.md
new file mode 100644
index 0000000..3d904c7
--- /dev/null
+++ b/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/linked-list-cycle/linked-list-cycle.cpp b/linked-list-cycle/linked-list-cycle.cpp
new file mode 100644
index 0000000..b13da37
--- /dev/null
+++ b/linked-list-cycle/linked-list-cycle.cpp
@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasCycle(ListNode *head) {
+        if(head == NULL || head -> next == NULL)    
+            return false;
+ 
+        ListNode *fast = head;
+        ListNode *slow = head;
+        
+        while(fast -> next && fast -> next -> next){
+            fast = fast -> next -> next;
+            slow = slow -> next;
+            if(fast == slow)
+                return true;
+        }
+ 
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/longest-common-subsequence/README.md b/longest-common-subsequence/README.md
new file mode 100644
index 0000000..3f0785b
--- /dev/null
+++ b/longest-common-subsequence/README.md
@@ -0,0 +1,40 @@
+<h2>1143. Longest Common Subsequence</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/longest-common-subsequence/longest-common-subsequence.cpp b/longest-common-subsequence/longest-common-subsequence.cpp
new file mode 100644
index 0000000..039970f
--- /dev/null
+++ b/longest-common-subsequence/longest-common-subsequence.cpp
@@ -0,0 +1,11 @@
+class Solution {
+public:
+  int longestCommonSubsequence(string &a, string &b) {
+  vector<vector<short>> m(a.size() + 1, vector<short>(b.size() + 1));
+  for (auto i = 1; i <= a.size(); ++i)
+    for (auto j = 1; j <= b.size(); ++j)
+      if (a[i - 1] == b[j - 1]) m[i][j] = m[i - 1][j - 1] + 1;
+      else m[i][j] = max(m[i - 1][j], m[i][j - 1]);
+  return m[a.size()][b.size()];
+}
+};
\ No newline at end of file
diff --git a/longest-consecutive-sequence/README.md b/longest-consecutive-sequence/README.md
new file mode 100644
index 0000000..efe0a44
--- /dev/null
+++ b/longest-consecutive-sequence/README.md
@@ -0,0 +1,26 @@
+<h2>128. Longest Consecutive Sequence</h2><h3>Medium</h3><hr><div><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>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>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>&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>
+</div>
\ No newline at end of file
diff --git a/longest-consecutive-sequence/longest-consecutive-sequence.cpp b/longest-consecutive-sequence/longest-consecutive-sequence.cpp
new file mode 100644
index 0000000..54a4347
--- /dev/null
+++ b/longest-consecutive-sequence/longest-consecutive-sequence.cpp
@@ -0,0 +1,39 @@
+class Solution {
+public:
+    int longestConsecutive(vector<int>& nums) {
+        
+        if(nums.size() == 0)
+            return 0;
+        
+        int max = INT_MIN;
+        int count = 1;
+        map <int,int> m;
+        for(auto num:nums)
+        {
+            m[num]++;
+        }
+        auto it = m.begin();
+        int prev  = it->first;
+        it++;
+        
+        for(;it != m.end();it++)
+        {
+            //cout<<prev<<endl;
+            if( it->first - prev != 1)
+            {
+                if(count > max)
+                    max = count;
+                count  = 1;
+                
+            }
+            else
+                count++;
+            prev = it->first;
+        }
+        
+        if(count > max)
+            max  = count;
+        
+        return max;
+    }
+};
\ No newline at end of file
diff --git a/longest-increasing-subsequence/README.md b/longest-increasing-subsequence/README.md
new file mode 100644
index 0000000..60446c7
--- /dev/null
+++ b/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/longest-increasing-subsequence/longest-increasing-subsequence.cpp b/longest-increasing-subsequence/longest-increasing-subsequence.cpp
new file mode 100644
index 0000000..70b49dc
--- /dev/null
+++ b/longest-increasing-subsequence/longest-increasing-subsequence.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+   int lengthOfLIS(vector<int>& nums) {
+    vector<int> res;
+    for(int i=0; i<nums.size(); i++) {
+        auto it = std::lower_bound(res.begin(), res.end(), nums[i]);
+        if(it==res.end()) res.push_back(nums[i]);
+        else *it = nums[i];
+    }
+    return res.size();
+}
+};
\ No newline at end of file
diff --git a/longest-palindromic-subsequence/README.md b/longest-palindromic-subsequence/README.md
new file mode 100644
index 0000000..d31b752
--- /dev/null
+++ b/longest-palindromic-subsequence/README.md
@@ -0,0 +1,27 @@
+<h2>516. Longest Palindromic Subsequence</h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code>, find <em>the longest palindromic <strong>subsequence</strong>'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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "bbbab"
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> One possible longest palindromic subsequence is "bbbb".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "cbbd"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> One possible longest palindromic subsequence is "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> consists only of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/longest-palindromic-substring/README.md b/longest-palindromic-substring/README.md
new file mode 100644
index 0000000..2a30d2a
--- /dev/null
+++ b/longest-palindromic-substring/README.md
@@ -0,0 +1,24 @@
+<h2>5. Longest Palindromic Substring</h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code>, return <em>the longest palindromic substring</em> in <code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>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>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/longest-palindromic-substring/longest-palindromic-substring.cpp b/longest-palindromic-substring/longest-palindromic-substring.cpp
new file mode 100644
index 0000000..c3fd732
--- /dev/null
+++ b/longest-palindromic-substring/longest-palindromic-substring.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+   string longestPalindrome(string s) {
+    if (s.empty()) return "";
+    if (s.size() == 1) return s;
+    int min_start = 0, max_len = 1;
+    for (int i = 0; i < s.size();) {
+      if (s.size() - i <= max_len / 2) break;
+      int j = i, k = i;
+      while (k < s.size()-1 && s[k+1] == s[k]) ++k; // Skip duplicate characters.
+      i = k+1;
+      while (k < s.size()-1 && j > 0 && s[k + 1] == s[j - 1]) { ++k; --j; } // Expand.
+      int new_len = k - j + 1;
+      if (new_len > max_len) { min_start = j; max_len = new_len; }
+    }
+    return s.substr(min_start, max_len);
+}
+};
\ No newline at end of file
diff --git a/longest-repeating-character-replacement/README.md b/longest-repeating-character-replacement/README.md
new file mode 100644
index 0000000..33e8277
--- /dev/null
+++ b/longest-repeating-character-replacement/README.md
@@ -0,0 +1,29 @@
+<h2>424. Longest Repeating Character Replacement</h2><h3>Medium</h3><hr><div><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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "ABAB", k = 2
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Replace the two 'A's with two 'B's or vice versa.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "AABABBA", k = 1
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Replace the one 'A' in the middle with 'B' and form "AABBBBA".
+The substring "BBBB" has the longest repeating letters, which is 4.
+</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>
+</div>
\ No newline at end of file
diff --git a/longest-substring-without-repeating-characters/README.md b/longest-substring-without-repeating-characters/README.md
new file mode 100644
index 0000000..2c228b4
--- /dev/null
+++ b/longest-substring-without-repeating-characters/README.md
@@ -0,0 +1,39 @@
+<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 <b>longest substring</b> 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><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;= 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/longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.cpp b/longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.cpp
new file mode 100644
index 0000000..9a289c4
--- /dev/null
+++ b/longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.cpp
@@ -0,0 +1,36 @@
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        
+        if(s.size() <=1)
+            return s.size();
+        
+        int ans = 0;
+        int low = 0;
+        int right = 0;
+        vector <int> v(256,-1);
+        
+        while(right < s.size())
+        {
+            if(v[s[right]] != -1)
+            {
+               low = max(low,v[s[right]]+1);
+            }
+          
+                v[s[right]] = right;
+                ans = max(ans,right-low+1);
+            
+            right++;
+        }
+        
+        
+        return ans;
+    }
+};
+
+
+
+
+
+
+
diff --git a/longest-uncommon-subsequence-ii/README.md b/longest-uncommon-subsequence-ii/README.md
new file mode 100644
index 0000000..210f1e2
--- /dev/null
+++ b/longest-uncommon-subsequence-ii/README.md
@@ -0,0 +1,27 @@
+<h2>522. Longest Uncommon Subsequence II</h2><h3>Medium</h3><hr><div><p>Given an array of strings <code>strs</code>, return <em>the length of the <strong>longest uncommon subsequence</strong> between them</em>. If the longest uncommon subsequence does not exist, return <code>-1</code>.</p>
+
+<p>An <strong>uncommon subsequence</strong> between an array of strings is a string that is a <strong>subsequence of one string but not the others</strong>.</p>
+
+<p>A <strong>subsequence</strong> of a string <code>s</code> is a string that can be obtained after deleting any number of characters from <code>s</code>.</p>
+
+<ul>
+	<li>For example, <code>"abc"</code> is a subsequence of <code>"aebdc"</code> because you can delete the underlined characters in <code>"a<u>e</u>b<u>d</u>c"</code> to get <code>"abc"</code>. Other subsequences of <code>"aebdc"</code> include <code>"aebdc"</code>, <code>"aeb"</code>, and <code>""</code> (empty string).</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> strs = ["aba","cdc","eae"]
+<strong>Output:</strong> 3
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> strs = ["aaa","aaa","aa"]
+<strong>Output:</strong> -1
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= strs.length &lt;= 50</code></li>
+	<li><code>1 &lt;= strs[i].length &lt;= 10</code></li>
+	<li><code>strs[i]</code> consists of lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/lowest-common-ancestor-of-a-binary-search-tree/README.md b/lowest-common-ancestor-of-a-binary-search-tree/README.md
new file mode 100644
index 0000000..d52dc14
--- /dev/null
+++ b/lowest-common-ancestor-of-a-binary-search-tree/README.md
@@ -0,0 +1,36 @@
+<h2>235. Lowest Common Ancestor of a Binary Search Tree</h2><h3>Easy</h3><hr><div><p>Given a binary search tree (BST), find the lowest common ancestor (LCA) 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>: “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/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>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>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>
+</div>
\ No newline at end of file
diff --git a/lowest-common-ancestor-of-a-binary-search-tree/lowest-common-ancestor-of-a-binary-search-tree.cpp b/lowest-common-ancestor-of-a-binary-search-tree/lowest-common-ancestor-of-a-binary-search-tree.cpp
new file mode 100644
index 0000000..057a850
--- /dev/null
+++ b/lowest-common-ancestor-of-a-binary-search-tree/lowest-common-ancestor-of-a-binary-search-tree.cpp
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        
+        if(root==NULL)
+            return root;
+        
+        if(root == p || root ==q)
+            return root;
+        
+        if(root->val > p->val && root->val > q->val)
+            return lowestCommonAncestor(root->left,p,q);
+        if(root->val < p->val && root->val < q->val)
+           return lowestCommonAncestor(root->right,p,q);
+           
+          return root;
+        
+    }
+};
\ No newline at end of file
diff --git a/lowest-common-ancestor-of-a-binary-tree/README.md b/lowest-common-ancestor-of-a-binary-tree/README.md
new file mode 100644
index 0000000..4c0eb0a
--- /dev/null
+++ b/lowest-common-ancestor-of-a-binary-tree/README.md
@@ -0,0 +1,36 @@
+<h2>236. Lowest Common Ancestor of a Binary Tree</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/lowest-common-ancestor-of-a-binary-tree/lowest-common-ancestor-of-a-binary-tree.cpp b/lowest-common-ancestor-of-a-binary-tree/lowest-common-ancestor-of-a-binary-tree.cpp
new file mode 100644
index 0000000..0a4f605
--- /dev/null
+++ b/lowest-common-ancestor-of-a-binary-tree/lowest-common-ancestor-of-a-binary-tree.cpp
@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        
+        if(root == NULL)
+            return NULL;
+        
+        if(root == p || root == q)
+            return root;
+        
+        TreeNode * l = lowestCommonAncestor(root->left,p,q);
+        TreeNode * r = lowestCommonAncestor(root->right,p,q); 
+        
+        if(l != NULL && r != NULL)
+            return root;
+        
+        if(l == NULL)
+            return r;
+        return l;
+    }
+};
\ No newline at end of file
diff --git a/majority-element-ii/README.md b/majority-element-ii/README.md
new file mode 100644
index 0000000..bdceb3a
--- /dev/null
+++ b/majority-element-ii/README.md
@@ -0,0 +1,32 @@
+<h2>229. Majority Element II</h2><h3>Medium</h3><hr><div><p>Given an integer array of size <code>n</code>, find all elements that appear more than <code>⌊ n/3 ⌋</code> times.</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 = [1]
+<strong>Output:</strong> [1]
+</pre>
+
+<p><strong>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>
+</div>
\ No newline at end of file
diff --git a/majority-element-ii/majority-element-ii.cpp b/majority-element-ii/majority-element-ii.cpp
new file mode 100644
index 0000000..0eaa24c
--- /dev/null
+++ b/majority-element-ii/majority-element-ii.cpp
@@ -0,0 +1,59 @@
+class Solution {
+public:
+    vector<int> majorityElement(vector<int>& nums) {
+        
+      int c1 = 0;
+      int c2 = 0;
+      int ele1 = INT_MIN;
+      int ele2 = INT_MIN;
+      
+      for(auto num:nums)
+      {
+        if(num == ele1)
+          c1++;
+        else if(num == ele2)
+          c2++;
+        else if(c1==0)
+        {
+          ele1 = num;
+          c1 = 1;
+        }
+        else if(c2==0)
+        {
+          ele2 = num;
+          c2 =1 ;
+        }
+        else
+        {
+          c1--;
+          c2--;
+        }
+      }
+      vector<int> ans;
+      // if(ele1 != -1 )
+      // {
+      //   ans.push_back(ele1);
+      // }
+      // if(ele2 != -1)
+      // {
+      //   ans.push_back(ele2);
+      // }
+       c1 = 0;
+       c2 = 0;
+      for(auto num:nums)
+      {
+        if(num == ele1)
+          c1++;
+        if(num == ele2)
+          c2++;
+        
+      }
+        
+        if(c1>floor(nums.size()/3))
+          ans.push_back(ele1);
+        if(c2>floor(nums.size()/3))
+          ans.push_back(ele2);
+        
+      return ans;
+    }
+};
\ No newline at end of file
diff --git a/majority-element/README.md b/majority-element/README.md
new file mode 100644
index 0000000..6c4d3ff
--- /dev/null
+++ b/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/majority-element/majority-element.cpp b/majority-element/majority-element.cpp
new file mode 100644
index 0000000..9a16910
--- /dev/null
+++ b/majority-element/majority-element.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    int majorityElement(vector<int>& nums) {
+        
+      int counter  = 0;
+      int candidate  = 0;
+      
+      
+      for(auto num:nums)
+      {
+        if(counter == 0 )
+        candidate = num;
+        
+        candidate == num ? counter++: counter--;
+      }
+      
+      return candidate;
+    }
+};
\ No newline at end of file
diff --git a/make-the-string-great/README.md b/make-the-string-great/README.md
new file mode 100644
index 0000000..4751fd3
--- /dev/null
+++ b/make-the-string-great/README.md
@@ -0,0 +1,45 @@
+<h2>1544. Make The String Great</h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code> of lower and upper case English letters.</p>
+
+<p>A good string is a string which doesn't have&nbsp;<strong>two adjacent characters</strong> <code>s[i]</code> and <code>s[i + 1]</code> where:</p>
+
+<ul>
+	<li><code>0 &lt;= i &lt;= s.length - 2</code></li>
+	<li><code>s[i]</code> is a lower-case letter and <code>s[i + 1]</code> is the same letter but in upper-case&nbsp;or <strong>vice-versa</strong>.</li>
+</ul>
+
+<p>To make the string good, you can choose <strong>two adjacent</strong> characters that make the string bad and remove them. You can keep doing this until the string becomes good.</p>
+
+<p>Return <em>the string</em> after making it good. The answer is guaranteed to be unique under the given constraints.</p>
+
+<p><strong>Notice</strong> that an empty string is also good.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "leEeetcode"
+<strong>Output:</strong> "leetcode"
+<strong>Explanation:</strong> In the first step, either you choose i = 1 or i = 2, both will result "leEeetcode" to be reduced to "leetcode".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "abBAcC"
+<strong>Output:</strong> ""
+<strong>Explanation:</strong> We have many possible scenarios, and all lead to the same answer. For example:
+"abBAcC" --&gt; "aAcC" --&gt; "cC" --&gt; ""
+"abBAcC" --&gt; "abBA" --&gt; "aA" --&gt; ""
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "s"
+<strong>Output:</strong> "s"
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 100</code></li>
+	<li><code>s</code> contains only lower and upper case English letters.</li>
+</ul></div>
\ No newline at end of file
diff --git a/make-the-string-great/make-the-string-great.cpp b/make-the-string-great/make-the-string-great.cpp
new file mode 100644
index 0000000..f7a6101
--- /dev/null
+++ b/make-the-string-great/make-the-string-great.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+string makeGood(string s, int p = 0) {
+    for (int i = 0; i < s.size(); ++i) {
+        if (p > 0 && abs(s[i] - s[p - 1]) == 32)
+            --p;
+        else
+            s[p++] = s[i];
+    }
+    return s.substr(0, p);
+}
+};
\ No newline at end of file
diff --git a/matrix-block-sum/README.md b/matrix-block-sum/README.md
new file mode 100644
index 0000000..766a606
--- /dev/null
+++ b/matrix-block-sum/README.md
@@ -0,0 +1,31 @@
+<h2>1314. Matrix Block Sum</h2><h3>Medium</h3><hr><div><p>Given a <code>m x n</code> matrix <code>mat</code> and an integer <code>k</code>, return <em>a matrix</em> <code>answer</code> <em>where each</em> <code>answer[i][j]</code> <em>is the sum of all elements</em> <code>mat[r][c]</code> <em>for</em>:</p>
+
+<ul>
+	<li><code>i - k &lt;= r &lt;= i + k,</code></li>
+	<li><code>j - k &lt;= c &lt;= j + k</code>, and</li>
+	<li><code>(r, c)</code> is a valid position in the matrix.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> mat = [[1,2,3],[4,5,6],[7,8,9]], k = 1
+<strong>Output:</strong> [[12,21,16],[27,45,33],[24,39,28]]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> mat = [[1,2,3],[4,5,6],[7,8,9]], k = 2
+<strong>Output:</strong> [[45,45,45],[45,45,45],[45,45,45]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m ==&nbsp;mat.length</code></li>
+	<li><code>n ==&nbsp;mat[i].length</code></li>
+	<li><code>1 &lt;= m, n, k &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/matrix-block-sum/matrix-block-sum.cpp b/matrix-block-sum/matrix-block-sum.cpp
new file mode 100644
index 0000000..dfbc85e
--- /dev/null
+++ b/matrix-block-sum/matrix-block-sum.cpp
@@ -0,0 +1,81 @@
+class Solution {
+public:
+    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
+        int n=mat.size();
+        int m=mat[0].size();
+        vector<int> s(m,0);
+        vector<vector<int>> l(n,s);
+        for(int i=0;i<mat.size();i++){
+            for(int j=0;j<mat[0].size();j++){
+                if(i==0 || j==0){
+                    if(i==0 && j==0){
+                        l[i][j]=mat[i][j];
+                    }
+                    else if(i==0){
+                        l[i][j]=mat[i][j]+l[i][j-1];
+                    }
+                    else{
+                        l[i][j]=mat[i][j]+l[i-1][j];
+                    }
+                }
+                else{
+                    l[i][j]=l[i-1][j]+l[i][j-1]-l[i-1][j-1]+mat[i][j];
+                }
+            }
+        }
+        vector<int> s1(m,0);
+        vector<vector<int>> ans(n,s1);
+        for(int i=0;i<n;i++){
+            for(int j=0;j<m;j++){
+                int first;
+                if(i+k<n && j+k<m){
+                    first=l[i+k][j+k];
+                }
+                else{
+                    if(i+k<n){
+                        first=l[i+k][m-1];
+                    }
+                    else if(j+k<m){
+                        first=l[n-1][j+k];
+                    }
+                    else{
+                        first=l[n-1][m-1];
+                    }
+                }
+                int second;
+                if(i-k-1>=0){
+                    if(j+k<m){
+                        second=l[i-k-1][j+k];
+                    }
+                    else{
+                        second=l[i-k-1][m-1];
+                    }
+                }
+                else{
+                    second=0;
+                }
+                int third;
+                if(j-k-1>=0){
+                    if(i+k<n){
+                        third=l[i+k][j-k-1];
+                    }
+                    else{
+                        third=l[n-1][j-k-1];
+                    }
+                }
+                else{
+                    third=0;
+                }
+                int fourth;
+                if(i-k-1>=0 && j-k-1>=0){
+                    fourth=l[i-k-1][j-k-1];
+                }
+                else{
+                    fourth=0;
+                }
+                ans[i][j]=first-second-third+fourth;
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/max-area-of-island/README.md b/max-area-of-island/README.md
new file mode 100644
index 0000000..9cc5e6f
--- /dev/null
+++ b/max-area-of-island/README.md
@@ -0,0 +1,30 @@
+<h2>695. Max Area of Island</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/max-area-of-island/max-area-of-island.cpp b/max-area-of-island/max-area-of-island.cpp
new file mode 100644
index 0000000..3388d84
--- /dev/null
+++ b/max-area-of-island/max-area-of-island.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+        int AreaOfIsland(vector<vector<int>>& grid, int i, int j){
+        if( i >= 0 && i < grid.size() && j >= 0 && j < grid[0].size() && grid[i][j] == 1){
+            grid[i][j] = 0;
+            return 1 + AreaOfIsland(grid, i+1, j) + AreaOfIsland(grid, i-1, j) + AreaOfIsland(grid, i, j-1) + AreaOfIsland(grid, i, j+1);
+        }
+        return 0;
+    }
+   int maxAreaOfIsland(vector<vector<int>>& grid) {
+        int max_area = 0;
+        for(int i = 0; i < grid.size(); i++)
+            for(int j = 0; j < grid[0].size(); j++)
+                if(grid[i][j] == 1)max_area = max(max_area, AreaOfIsland(grid, i, j));
+        return max_area;
+    }
+    
+
+};
\ No newline at end of file
diff --git a/max-consecutive-ones-iii/README.md b/max-consecutive-ones-iii/README.md
new file mode 100644
index 0000000..49181d8
--- /dev/null
+++ b/max-consecutive-ones-iii/README.md
@@ -0,0 +1,27 @@
+<h2>1004. Max Consecutive Ones III</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>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>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/max-consecutive-ones-iii/max-consecutive-ones-iii.cpp b/max-consecutive-ones-iii/max-consecutive-ones-iii.cpp
new file mode 100644
index 0000000..054b631
--- /dev/null
+++ b/max-consecutive-ones-iii/max-consecutive-ones-iii.cpp
@@ -0,0 +1,28 @@
+class Solution {
+public:
+    int longestOnes(vector<int>& nums, int k) {
+        
+        int l = 0,r = 0;
+        int counter = 0;
+        int n = nums.size();
+        int ans = INT_MIN;
+         
+        while(r<n)
+        {
+           if(nums[r] == 0)
+               counter++;
+            
+            r++;
+            while(counter > k)
+            {
+                if(nums[l]==0)
+                    counter--;
+                
+                l++;
+            }
+            ans = max(ans,r-l);
+               
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/max-consecutive-ones/README.md b/max-consecutive-ones/README.md
new file mode 100644
index 0000000..3054700
--- /dev/null
+++ b/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/max-consecutive-ones/max-consecutive-ones.cpp b/max-consecutive-ones/max-consecutive-ones.cpp
new file mode 100644
index 0000000..e86b37b
--- /dev/null
+++ b/max-consecutive-ones/max-consecutive-ones.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int findMaxConsecutiveOnes(vector<int>& nums) {
+        
+        int ans = 0;
+        int start = 0;
+        int currones = 0;
+        while(start<nums.size())
+        {
+            if(nums[start] == 1)
+            {
+                currones++;
+            }
+            else
+            {
+                  if(currones>ans)
+                    ans = currones;
+                currones = 0;
+            }
+            start++;
+        }
+        
+        if(currones>ans)
+            ans = currones;
+        
+        return ans;
+        
+    }
+};
\ No newline at end of file
diff --git a/maximal-rectangle/README.md b/maximal-rectangle/README.md
new file mode 100644
index 0000000..e3a02b7
--- /dev/null
+++ b/maximal-rectangle/README.md
@@ -0,0 +1,44 @@
+<h2>85. Maximal Rectangle</h2><h3>Hard</h3><hr><div><p>Given a <code>rows x cols</code>&nbsp;binary <code>matrix</code> filled with <code>0</code>'s and <code>1</code>'s, find the largest rectangle containing only <code>1</code>'s and return <em>its area</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/14/maximal.jpg" style="width: 402px; height: 322px;">
+<pre><strong>Input:</strong> matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The maximal rectangle is shown in the above picture.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> matrix = []
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [["0"]]
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [["1"]]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [["0","0"]]
+<strong>Output:</strong> 0
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>rows == matrix.length</code></li>
+	<li><code>cols == matrix[i].length</code></li>
+	<li><code>0 &lt;= row, cols &lt;= 200</code></li>
+	<li><code>matrix[i][j]</code> is <code>'0'</code> or <code>'1'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/maximal-rectangle/maximal-rectangle.cpp b/maximal-rectangle/maximal-rectangle.cpp
new file mode 100644
index 0000000..23f560a
--- /dev/null
+++ b/maximal-rectangle/maximal-rectangle.cpp
@@ -0,0 +1,30 @@
+class Solution {public:
+int maximalRectangle(vector<vector<char> > &matrix) {
+    if(matrix.empty()) return 0;
+    const int m = matrix.size();
+    const int n = matrix[0].size();
+    int left[n], right[n], height[n];
+    fill_n(left,n,0); fill_n(right,n,n); fill_n(height,n,0);
+    int maxA = 0;
+    for(int i=0; i<m; i++) {
+        int cur_left=0, cur_right=n; 
+        for(int j=0; j<n; j++) { // compute height (can do this from either side)
+            if(matrix[i][j]=='1') height[j]++; 
+            else height[j]=0;
+        }
+        for(int j=0; j<n; j++) { // compute left (from left to right)
+            if(matrix[i][j]=='1') left[j]=max(left[j],cur_left);
+            else {left[j]=0; cur_left=j+1;}
+        }
+        // compute right (from right to left)
+        for(int j=n-1; j>=0; j--) {
+            if(matrix[i][j]=='1') right[j]=min(right[j],cur_right);
+            else {right[j]=n; cur_right=j;}    
+        }
+        // compute the area of rectangle (can do this from either side)
+        for(int j=0; j<n; j++)
+            maxA = max(maxA,(right[j]-left[j])*height[j]);
+    }
+    return maxA;
+}
+};
\ No newline at end of file
diff --git a/maximal-square/README.md b/maximal-square/README.md
new file mode 100644
index 0000000..b04c3c5
--- /dev/null
+++ b/maximal-square/README.md
@@ -0,0 +1,31 @@
+<h2>221. Maximal Square</h2><h3>Medium</h3><hr><div><p>Given an <code>m x n</code> binary <code>matrix</code> filled with <code>0</code>'s and <code>1</code>'s, <em>find the largest square containing only</em> <code>1</code>'s <em>and return its area</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/26/max1grid.jpg" style="width: 400px; height: 319px;">
+<pre><strong>Input:</strong> matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/26/max2grid.jpg" style="width: 165px; height: 165px;">
+<pre><strong>Input:</strong> matrix = [["0","1"],["1","0"]]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [["0"]]
+<strong>Output:</strong> 0
+</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;= 300</code></li>
+	<li><code>matrix[i][j]</code> is <code>'0'</code> or <code>'1'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/maximal-square/maximal-square.cpp b/maximal-square/maximal-square.cpp
new file mode 100644
index 0000000..b893edd
--- /dev/null
+++ b/maximal-square/maximal-square.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int maximalSquare(vector<vector<char>>& matrix) {
+        if (matrix.empty()) {
+            return 0;
+        }
+        int m = matrix.size(), n = matrix[0].size(), sz = 0, pre;
+        vector<int> cur(n, 0);
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                int temp = cur[j];
+                if (!i || !j || matrix[i][j] == '0') {
+                    cur[j] = matrix[i][j] - '0';
+                } else {
+                    cur[j] = min(pre, min(cur[j], cur[j - 1])) + 1;
+                }
+                sz = max(cur[j], sz);
+                pre = temp;
+            }
+        }
+        return sz*sz;
+    }
+};
\ No newline at end of file
diff --git a/maximum-69-number/README.md b/maximum-69-number/README.md
new file mode 100644
index 0000000..1c5f00a
--- /dev/null
+++ b/maximum-69-number/README.md
@@ -0,0 +1,36 @@
+<h2>1323. Maximum 69 Number</h2><h3>Easy</h3><hr><div><p>Given a positive integer <code>num</code> consisting only of digits 6 and 9.</p>
+
+<p>Return the maximum number you can get by changing <strong>at most</strong> one digit (6 becomes 9, and 9 becomes 6).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> num = 9669
+<strong>Output:</strong> 9969
+<strong>Explanation:</strong> 
+Changing the first digit results in 6669.
+Changing the second digit results in 9969.
+Changing the third digit results in 9699.
+Changing the fourth digit results in 9666.&nbsp;
+The maximum number is 9969.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> num = 9996
+<strong>Output:</strong> 9999
+<strong>Explanation:</strong> Changing the last digit 6 to 9 results in the maximum number.</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> num = 9999
+<strong>Output:</strong> 9999
+<strong>Explanation:</strong> It is better not to apply any change.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= num &lt;= 10^4</code></li>
+	<li><code>num</code>'s digits are 6 or 9.</li>
+</ul></div>
\ No newline at end of file
diff --git a/maximum-average-subarray-i/README.md b/maximum-average-subarray-i/README.md
new file mode 100644
index 0000000..51db272
--- /dev/null
+++ b/maximum-average-subarray-i/README.md
@@ -0,0 +1,27 @@
+<h2>643. Maximum Average Subarray I</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>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>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/maximum-average-subarray-i/maximum-average-subarray-i.cpp b/maximum-average-subarray-i/maximum-average-subarray-i.cpp
new file mode 100644
index 0000000..9e69369
--- /dev/null
+++ b/maximum-average-subarray-i/maximum-average-subarray-i.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    double findMaxAverage(vector<int>& nums, int k) {
+        double ans = 0;
+        
+        for(int i=0;i<k;i++)
+        {
+            ans += nums[i];
+        }
+        double temp = ans;
+        ans = ans / k;
+        
+        for(int i = k;i<nums.size();i++)
+        {
+          temp = temp + nums[i] - nums[i-k];
+            
+          ans = max(ans,temp/k);
+        }
+        
+        return ans;
+        
+    }
+};
\ No newline at end of file
diff --git a/maximum-binary-tree/README.md b/maximum-binary-tree/README.md
new file mode 100644
index 0000000..fbed789
--- /dev/null
+++ b/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/maximum-depth-of-binary-tree/README.md b/maximum-depth-of-binary-tree/README.md
new file mode 100644
index 0000000..3a9697e
--- /dev/null
+++ b/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/maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.cpp b/maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.cpp
new file mode 100644
index 0000000..f09af49
--- /dev/null
+++ b/maximum-depth-of-binary-tree/maximum-depth-of-binary-tree.cpp
@@ -0,0 +1,22 @@
+/**
+ * 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:
+    int maxDepth(TreeNode* root) {
+      
+      if(root == NULL)
+        return 0;
+      
+      return 1+ max(maxDepth(root->left) , maxDepth(root->right));
+      
+    }
+};
\ No newline at end of file
diff --git a/maximum-difference-between-node-and-ancestor/README.md b/maximum-difference-between-node-and-ancestor/README.md
new file mode 100644
index 0000000..1c8b3e4
--- /dev/null
+++ b/maximum-difference-between-node-and-ancestor/README.md
@@ -0,0 +1,30 @@
+<h2>1026. Maximum Difference Between Node and Ancestor</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/maximum-difference-between-node-and-ancestor/maximum-difference-between-node-and-ancestor.cpp b/maximum-difference-between-node-and-ancestor/maximum-difference-between-node-and-ancestor.cpp
new file mode 100644
index 0000000..0c91af2
--- /dev/null
+++ b/maximum-difference-between-node-and-ancestor/maximum-difference-between-node-and-ancestor.cpp
@@ -0,0 +1,19 @@
+/**
+ * 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:
+    
+    int maxAncestorDiff(TreeNode* r, int mn = 100000, int mx = 0) {
+        return r ? max(maxAncestorDiff(r->left, min(mn, r->val), max(mx, r->val)),
+        maxAncestorDiff(r->right, min(mn, r->val), max(mx, r->val))) : mx - mn;
+    }
+};
\ No newline at end of file
diff --git a/maximum-employees-to-be-invited-to-a-meeting/README.md b/maximum-employees-to-be-invited-to-a-meeting/README.md
new file mode 100644
index 0000000..873cadf
--- /dev/null
+++ b/maximum-employees-to-be-invited-to-a-meeting/README.md
@@ -0,0 +1,52 @@
+<h2>2127. Maximum Employees to Be Invited to a Meeting</h2><h3>Hard</h3><hr><div><p>A company is organizing a meeting and has a list of <code>n</code> employees, waiting to be invited. They have arranged for a large <strong>circular</strong> table, capable of seating <strong>any number</strong> of employees.</p>
+
+<p>The employees are numbered from <code>0</code> to <code>n - 1</code>. Each employee has a <strong>favorite</strong> person and they will attend the meeting <strong>only if</strong> they can sit next to their favorite person at the table. The favorite person of an employee is <strong>not</strong> themself.</p>
+
+<p>Given a <strong>0-indexed</strong> integer array <code>favorite</code>, where <code>favorite[i]</code> denotes the favorite person of the <code>i<sup>th</sup></code> employee, return <em>the <strong>maximum number of employees</strong> that can be invited to the meeting</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/14/ex1.png" style="width: 236px; height: 195px;">
+<pre><strong>Input:</strong> favorite = [2,2,1,2]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+The above figure shows how the company can invite employees 0, 1, and 2, and seat them at the round table.
+All employees cannot be invited because employee 2 cannot sit beside employees 0, 1, and 3, simultaneously.
+Note that the company can also invite employees 1, 2, and 3, and give them their desired seats.
+The maximum number of employees that can be invited to the meeting is 3. 
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> favorite = [1,2,0]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 
+Each employee is the favorite person of at least one other employee, and the only way the company can invite them is if they invite every employee.
+The seating arrangement will be the same as that in the figure given in example 1:
+- Employee 0 will sit between employees 2 and 1.
+- Employee 1 will sit between employees 0 and 2.
+- Employee 2 will sit between employees 1 and 0.
+The maximum number of employees that can be invited to the meeting is 3.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/12/14/ex2.png" style="width: 219px; height: 220px;">
+<pre><strong>Input:</strong> favorite = [3,0,1,4,1]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+The above figure shows how the company will invite employees 0, 1, 3, and 4, and seat them at the round table.
+Employee 2 cannot be invited because the two spots next to their favorite employee 0 are taken.
+So the company leaves them out of the meeting.
+The maximum number of employees that can be invited to the meeting is 4.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == favorite.length</code></li>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= favorite[i] &lt;=&nbsp;n - 1</code></li>
+	<li><code>favorite[i] != i</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/maximum-length-of-repeated-subarray/README.md b/maximum-length-of-repeated-subarray/README.md
new file mode 100644
index 0000000..fa53a1f
--- /dev/null
+++ b/maximum-length-of-repeated-subarray/README.md
@@ -0,0 +1,24 @@
+<h2>718. Maximum Length of Repeated Subarray</h2><h3>Medium</h3><hr><div><p>Given two integer arrays <code>nums1</code> and <code>nums2</code>, return <em>the maximum length of a subarray that appears in <strong>both</strong> arrays</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The repeated subarray with maximum length is [3,2,1].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
+<strong>Output:</strong> 5
+</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;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/maximum-length-of-subarray-with-positive-product/README.md b/maximum-length-of-subarray-with-positive-product/README.md
new file mode 100644
index 0000000..578197e
--- /dev/null
+++ b/maximum-length-of-subarray-with-positive-product/README.md
@@ -0,0 +1,48 @@
+<h2>1567. Maximum Length of Subarray With Positive Product</h2><h3>Medium</h3><hr><div><p>Given an array of integers&nbsp;<code>nums</code>, find&nbsp;the maximum length of a subarray where the product of all its elements is positive.</p>
+
+<p>A subarray of an array is a consecutive sequence of zero or more values taken out of that array.</p>
+
+<p>Return&nbsp;<em>the maximum length of a subarray with positive product</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,-2,-3,4]
+<strong>Output:</strong> 4
+<strong>Explanation: </strong>The array nums already has a positive product of 24.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1,-2,-3,-4]
+<strong>Output:</strong> 3
+<strong>Explanation: </strong>The longest subarray with positive product is [1,-2,-3] which has a product of 6.
+Notice that we cannot include 0 in the subarray since that'll make the product 0 which is not positive.</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,-2,-3,0,1]
+<strong>Output:</strong> 2
+<strong>Explanation: </strong>The longest subarray with positive product is [-1,-2] or [-2,-3].
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,2]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,5,-6,4,0,10]
+<strong>Output:</strong> 4
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 10^5</code></li>
+	<li><code>-10^9 &lt;= nums[i]&nbsp;&lt;= 10^9</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/maximum-product-subarray/README.md b/maximum-product-subarray/README.md
new file mode 100644
index 0000000..608ace2
--- /dev/null
+++ b/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/maximum-product-subarray/maximum-product-subarray.cpp b/maximum-product-subarray/maximum-product-subarray.cpp
new file mode 100644
index 0000000..d5974a1
--- /dev/null
+++ b/maximum-product-subarray/maximum-product-subarray.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+  
+
+    int maxProduct(vector<int>& nums) {
+        int r = nums[0];
+      int maxi = r,mini = r;
+      
+      for(int i=1;i<nums.size();i++)
+      {
+        if(nums[i]<0)
+        {
+          swap(maxi,mini);
+        }
+        
+        maxi =max(nums[i],maxi*nums[i]);
+         mini =min(nums[i],mini*nums[i]);
+        
+        r = max(r,maxi);
+      }
+      return r;
+    }
+};
\ No newline at end of file
diff --git a/maximum-profit-in-job-scheduling/README.md b/maximum-profit-in-job-scheduling/README.md
new file mode 100644
index 0000000..66f1fb5
--- /dev/null
+++ b/maximum-profit-in-job-scheduling/README.md
@@ -0,0 +1,44 @@
+<h2>1235. Maximum Profit in Job Scheduling</h2><h3>Hard</h3><hr><div><p>We have <code>n</code> jobs, where every job is scheduled to be done from <code>startTime[i]</code> to <code>endTime[i]</code>, obtaining a profit of <code>profit[i]</code>.</p>
+
+<p>You're given the <code>startTime</code>, <code>endTime</code> and <code>profit</code> arrays, return the maximum profit you can take such that there are no two jobs in the subset with overlapping time range.</p>
+
+<p>If you choose a job that ends at time <code>X</code> you will be able to start another job that starts at time <code>X</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/10/10/sample1_1584.png" style="width: 380px; height: 154px;"></strong></p>
+
+<pre><strong>Input:</strong> startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]
+<strong>Output:</strong> 120
+<strong>Explanation:</strong> The subset chosen is the first and fourth job. 
+Time range [1-3]+[3-6] , we get profit of 120 = 50 + 70.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/10/10/sample22_1584.png" style="width: 600px; height: 112px;"> </strong></p>
+
+<pre><strong>Input:</strong> startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]
+<strong>Output:</strong> 150
+<strong>Explanation:</strong> The subset chosen is the first, fourth and fifth job. 
+Profit obtained 150 = 20 + 70 + 60.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/10/10/sample3_1584.png" style="width: 400px; height: 112px;"></strong></p>
+
+<pre><strong>Input:</strong> startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]
+<strong>Output:</strong> 6
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= startTime.length == endTime.length == profit.length &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= startTime[i] &lt; endTime[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= profit[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/maximum-profit-in-job-scheduling/maximum-profit-in-job-scheduling.cpp b/maximum-profit-in-job-scheduling/maximum-profit-in-job-scheduling.cpp
new file mode 100644
index 0000000..e0f06f8
--- /dev/null
+++ b/maximum-profit-in-job-scheduling/maximum-profit-in-job-scheduling.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+  int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
+    vector<int> idx(startTime.size());
+    iota(begin(idx), end(idx), 0);
+    sort(begin(idx), end(idx), [&](int i, int j) { return startTime[i] > startTime[j]; });
+    map<int, int> memo;
+    int max_profit = 0;
+    for (auto i = 0; i < idx.size(); ++i) {
+        auto it = memo.lower_bound(endTime[idx[i]]);
+        max_profit = max(max_profit, (it == end(memo) ? 0 : it->second) + profit[idx[i]]);
+        memo[startTime[idx[i]]] = max_profit;
+    }
+    return max_profit;
+}
+};
\ No newline at end of file
diff --git a/maximum-score-from-removing-stones/README.md b/maximum-score-from-removing-stones/README.md
new file mode 100644
index 0000000..bf2d22f
--- /dev/null
+++ b/maximum-score-from-removing-stones/README.md
@@ -0,0 +1,49 @@
+<h2>1753. Maximum Score From Removing Stones</h2><h3>Medium</h3><hr><div><p>You are playing a solitaire game with <strong>three piles</strong> of stones of sizes <code>a</code>​​​​​​, <code>b</code>,​​​​​​ and <code>c</code>​​​​​​ respectively. Each turn you choose two <strong>different non-empty </strong>piles, take one stone from each, and add <code>1</code> point to your score. The game stops when there are <strong>fewer than two non-empty</strong> piles (meaning there are no more available moves).</p>
+
+<p>Given three integers <code>a</code>​​​​​, <code>b</code>,​​​​​ and <code>c</code>​​​​​, return <em>the</em> <strong><em>maximum</em> </strong><em><strong>score</strong> you can get.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> a = 2, b = 4, c = 6
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The starting state is (2, 4, 6). One optimal set of moves is:
+- Take from 1st and 3rd piles, state is now (1, 4, 5)
+- Take from 1st and 3rd piles, state is now (0, 4, 4)
+- Take from 2nd and 3rd piles, state is now (0, 3, 3)
+- Take from 2nd and 3rd piles, state is now (0, 2, 2)
+- Take from 2nd and 3rd piles, state is now (0, 1, 1)
+- Take from 2nd and 3rd piles, state is now (0, 0, 0)
+There are fewer than two non-empty piles, so the game ends. Total: 6 points.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> a = 4, b = 4, c = 6
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> The starting state is (4, 4, 6). One optimal set of moves is:
+- Take from 1st and 2nd piles, state is now (3, 3, 6)
+- Take from 1st and 3rd piles, state is now (2, 3, 5)
+- Take from 1st and 3rd piles, state is now (1, 3, 4)
+- Take from 1st and 3rd piles, state is now (0, 3, 3)
+- Take from 2nd and 3rd piles, state is now (0, 2, 2)
+- Take from 2nd and 3rd piles, state is now (0, 1, 1)
+- Take from 2nd and 3rd piles, state is now (0, 0, 0)
+There are fewer than two non-empty piles, so the game ends. Total: 7 points.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> a = 1, b = 8, c = 8
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> One optimal set of moves is to take from the 2nd and 3rd piles for 8 turns until they are empty.
+After that, there are fewer than two non-empty piles, so the game ends.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= a, b, c &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/maximum-subarray/README.md b/maximum-subarray/README.md
new file mode 100644
index 0000000..d2ab332
--- /dev/null
+++ b/maximum-subarray/README.md
@@ -0,0 +1,32 @@
+<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>&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;= 3 * 10<sup>4</sup></code></li>
+	<li><code>-10<sup>5</sup> &lt;= nums[i] &lt;= 10<sup>5</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 using the <strong>divide and conquer</strong> approach, which is more subtle.</div>
\ No newline at end of file
diff --git a/maximum-subarray/maximum-subarray.cpp b/maximum-subarray/maximum-subarray.cpp
new file mode 100644
index 0000000..c7aaf81
--- /dev/null
+++ b/maximum-subarray/maximum-subarray.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int maxSubArray(vector<int>& nums) {
+        int max_sum=nums[0], sum=nums[0];
+        for(int i=1; i<nums.size(); i++) {
+            sum = max(nums[i], sum+nums[i]);
+            if(sum>max_sum) {
+                max_sum=sum;
+            }
+        }
+        
+        return max_sum;
+    }
+};
\ No newline at end of file
diff --git a/maximum-sum-circular-subarray/README.md b/maximum-sum-circular-subarray/README.md
new file mode 100644
index 0000000..231217f
--- /dev/null
+++ b/maximum-sum-circular-subarray/README.md
@@ -0,0 +1,51 @@
+<h2>918. Maximum Sum Circular Subarray</h2><h3>Medium</h3><hr><div><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>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>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>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,-1,2,-1]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> Subarray [2,-1,3] has maximum sum 2 + (-1) + 3 = 4
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> nums = [3,-2,2,-3]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Subarray [3] and [3,-2,2] both have maximum sum 3
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-2,-3,-1]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> Subarray [-1] has maximum sum -1
+</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>
+</div>
\ No newline at end of file
diff --git a/maximum-sum-circular-subarray/maximum-sum-circular-subarray.cpp b/maximum-sum-circular-subarray/maximum-sum-circular-subarray.cpp
new file mode 100644
index 0000000..9d11e06
--- /dev/null
+++ b/maximum-sum-circular-subarray/maximum-sum-circular-subarray.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int maxSubarraySumCircular(vector<int>& A) {
+        if(A.size() == 0) return 0;
+        int sum = A[0];
+        int maxSoFar = A[0];
+        int maxTotal = A[0];
+        int minSoFar = A[0];
+        int minTotal = A[0];
+        for(int i = 1; i< A.size();i++){
+            maxSoFar = max(A[i], maxSoFar + A[i]);
+            maxTotal = max(maxTotal, maxSoFar);
+            
+            minSoFar = min(A[i], minSoFar + A[i]);
+            minTotal = min(minTotal, minSoFar);
+            sum += A[i];
+
+        }
+        if(sum == minTotal) return maxTotal;
+        return max(sum - minTotal, maxTotal);
+    }
+};
\ No newline at end of file
diff --git a/maximum-units-on-a-truck/README.md b/maximum-units-on-a-truck/README.md
new file mode 100644
index 0000000..506b020
--- /dev/null
+++ b/maximum-units-on-a-truck/README.md
@@ -0,0 +1,39 @@
+<h2>1710. Maximum Units on a Truck</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/maximum-units-on-a-truck/maximum-units-on-a-truck.cpp b/maximum-units-on-a-truck/maximum-units-on-a-truck.cpp
new file mode 100644
index 0000000..8776409
--- /dev/null
+++ b/maximum-units-on-a-truck/maximum-units-on-a-truck.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    static bool myfunction(vector<int>& a, vector<int>& b){
+        return a[1] > b[1];
+    }
+    int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {
+	    //custom sort (in increasing order of numberOfUnitsPerBox as we have to return  maximum total number of units )
+        sort(boxTypes.begin(),boxTypes.end(),myfunction);
+		//greedily pick boxes till capacity is full
+        int ans=0;
+        for(auto box: boxTypes){
+            int x=min(box[0],truckSize);  //choose minimum boxes from available boxes and capacity left
+            ans+=(x*box[1]);  //adding units in ans
+            truckSize-=x;  //reduce the capacity
+            if(!truckSize) break;  //capacity full
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/median-of-two-sorted-arrays/README.md b/median-of-two-sorted-arrays/README.md
new file mode 100644
index 0000000..9bed02b
--- /dev/null
+++ b/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/median-of-two-sorted-arrays/median-of-two-sorted-arrays.cpp b/median-of-two-sorted-arrays/median-of-two-sorted-arrays.cpp
new file mode 100644
index 0000000..83fd5f4
--- /dev/null
+++ b/median-of-two-sorted-arrays/median-of-two-sorted-arrays.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+  double findMedianSortedArrays(std::vector<int>& nums1, std::vector<int>& nums2) {
+        int temp, median_pos;
+        double median; 
+        std::vector<int> nums3 = nums1; 
+
+        nums3.insert( nums3.end(), nums2.begin(), nums2.end() );        
+        for (int i = 0; i < nums3.size() -1; i++) { 
+            for (int j = i + 1; j < nums3.size(); j++) {
+                if (nums3[i] > nums3[j]) {
+                    temp = nums3[i]; 
+                    nums3[i] = nums3[j]; 
+                    nums3[j] = temp;
+                }
+            }
+        }
+
+        if (nums3.size() % 2 != 0)
+            median = nums3[ ((nums3.size() + 1) >> 1) - 1 ]; 
+        else { 
+            int lhs = nums3[(nums3.size() >> 1) - 1]; 
+            int rhs = nums3[(nums3.size() >> 1)]; 
+            median = (lhs + rhs) / 2.0;  
+        }
+
+        return median+1-1; 
+    }
+};
\ No newline at end of file
diff --git a/merge-intervals/README.md b/merge-intervals/README.md
new file mode 100644
index 0000000..408c422
--- /dev/null
+++ b/merge-intervals/README.md
@@ -0,0 +1,26 @@
+<h2>56. Merge Intervals</h2><h3>Medium</h3><hr><div><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>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] overlaps, merge them into [1,6].
+</pre>
+
+<p><strong>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>
+</div>
\ No newline at end of file
diff --git a/merge-intervals/merge-intervals.cpp b/merge-intervals/merge-intervals.cpp
new file mode 100644
index 0000000..981fe67
--- /dev/null
+++ b/merge-intervals/merge-intervals.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    vector<vector<int>> merge(vector<vector<int>>& intervals) {
+      vector<vector<int>> merged ;  
+      sort(intervals.begin(),intervals.end());
+      
+      for(auto interval:intervals)
+      {
+        if(merged.size() == 0 || merged.back()[1] < interval[0])
+        {
+          merged.push_back(interval);
+        }
+        else
+        {
+          merged.back()[1] = max(merged.back()[1],interval[1]);
+        }
+        
+      }
+      return merged;
+      
+    }
+};
\ No newline at end of file
diff --git a/merge-k-sorted-lists/README.md b/merge-k-sorted-lists/README.md
new file mode 100644
index 0000000..a436b33
--- /dev/null
+++ b/merge-k-sorted-lists/README.md
@@ -0,0 +1,43 @@
+<h2>23. Merge k Sorted Lists</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/merge-k-sorted-lists/merge-k-sorted-lists.cpp b/merge-k-sorted-lists/merge-k-sorted-lists.cpp
new file mode 100644
index 0000000..271d541
--- /dev/null
+++ b/merge-k-sorted-lists/merge-k-sorted-lists.cpp
@@ -0,0 +1,59 @@
+/**
+ * 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* 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;
+        
+        while(l2 != NULL && l1 != NULL)
+        {
+            ListNode * temp = NULL;
+            while(l1 != NULL && l2->val >= l1->val)
+            {
+                temp = l1;
+                l1 = l1->next;
+            }
+            temp -> next = l2;
+            
+            ListNode * tem = l1;
+            l1 = l2;
+            l2 = tem;
+            
+        }
+        return res;
+        
+    }
+    ListNode* mergeKLists(vector<ListNode*>& lists) {
+        
+      if (lists.size() == 0) return NULL;
+        
+        ListNode* head = lists[0];
+        
+        for (int i = 1; i < lists.size(); i++)
+            head = mergeTwoLists(head, lists[i]);
+        
+        return head;
+    }
+};
\ No newline at end of file
diff --git a/merge-sorted-array/README.md b/merge-sorted-array/README.md
new file mode 100644
index 0000000..35a9ff3
--- /dev/null
+++ b/merge-sorted-array/README.md
@@ -0,0 +1,46 @@
+<h2>88. Merge Sorted Array</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/merge-sorted-array/merge-sorted-array.cpp b/merge-sorted-array/merge-sorted-array.cpp
new file mode 100644
index 0000000..caa9bd3
--- /dev/null
+++ b/merge-sorted-array/merge-sorted-array.cpp
@@ -0,0 +1,32 @@
+class Solution {
+public:
+    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
+      vector<int> ans(n+m);
+      
+      int i=0;
+      int j =0;
+      int k=0;
+      while(i != m && j != n)
+      {
+        if(nums1[i]>= nums2[j])
+          ans[k++] = nums2[j++];
+        else
+          ans[k++] = nums1[i++];
+      }
+      
+      if(i == m)
+      {
+        while(j != n)
+          ans[k++] = nums2[j++];
+      }
+      if(j == n)
+      {
+        while(i != m)
+          ans[k++] = nums1[i++];
+      }
+      
+      for(int l=0;l<(n+m);l++)
+        nums1[l] = ans[l];
+      
+    }
+};
\ No newline at end of file
diff --git a/merge-two-binary-trees/README.md b/merge-two-binary-trees/README.md
new file mode 100644
index 0000000..eb2a305
--- /dev/null
+++ b/merge-two-binary-trees/README.md
@@ -0,0 +1,29 @@
+<h2>617. Merge Two Binary Trees</h2><h3>Easy</h3><hr><div><p>You are given two binary trees <code>root1</code> and <code>root2</code>.</p>
+
+<p>Imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not. You need to merge the two trees into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of the new tree.</p>
+
+<p>Return <em>the merged tree</em>.</p>
+
+<p><strong>Note:</strong> The merging process must start from the root nodes of both trees.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/05/merge.jpg" style="width: 600px; height: 163px;">
+<pre><strong>Input:</strong> root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
+<strong>Output:</strong> [3,4,5,5,4,null,7]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root1 = [1], root2 = [1,2]
+<strong>Output:</strong> [2,2]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in both trees is in the range <code>[0, 2000]</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/merge-two-binary-trees/merge-two-binary-trees.cpp b/merge-two-binary-trees/merge-two-binary-trees.cpp
new file mode 100644
index 0000000..06590af
--- /dev/null
+++ b/merge-two-binary-trees/merge-two-binary-trees.cpp
@@ -0,0 +1,29 @@
+/**
+ * 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:
+    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
+        if(root1 == NULL && root2 == NULL )
+          return NULL;
+        if(root1 == NULL)
+          return root2;
+        if(root2 == NULL)
+          return root1;
+      
+      root1->val  = root1->val + root2->val;
+      
+      root1->left =  mergeTrees(root1->left,root2->left);
+      root1->right = mergeTrees(root1->right,root2->right);
+      
+      return root1;
+    }
+};
\ No newline at end of file
diff --git a/merge-two-sorted-lists/README.md b/merge-two-sorted-lists/README.md
new file mode 100644
index 0000000..0a79189
--- /dev/null
+++ b/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/merge-two-sorted-lists/merge-two-sorted-lists.cpp b/merge-two-sorted-lists/merge-two-sorted-lists.cpp
new file mode 100644
index 0000000..dbf58a0
--- /dev/null
+++ b/merge-two-sorted-lists/merge-two-sorted-lists.cpp
@@ -0,0 +1,54 @@
+/**
+ * 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* 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 * dummy = new ListNode(0);
+        ListNode * temp = dummy;
+        dummy->next = l1;
+        
+        while(l1 !=NULL && l2 != NULL)
+        {
+            while(l1 != NULL && l1->val <= l2->val)
+            {
+                l1 = l1->next;
+                temp = temp->next;
+            }
+            if(l1 != NULL && l1->val > l2->val)
+            {
+                temp->next = l2;
+             //   temp = temp->next;
+                ListNode * re  = l2;
+                l2 = l1;
+                l1 = re;
+            }
+        
+        }
+        
+        if(l1 == NULL)
+            temp->next = l2;
+        if(l2 == NULL)
+            temp->next = l1;
+        
+        return dummy->next;
+    }
+};
\ No newline at end of file
diff --git a/middle-of-the-linked-list/README.md b/middle-of-the-linked-list/README.md
new file mode 100644
index 0000000..5ac8a92
--- /dev/null
+++ b/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/middle-of-the-linked-list/middle-of-the-linked-list.cpp b/middle-of-the-linked-list/middle-of-the-linked-list.cpp
new file mode 100644
index 0000000..a0dac35
--- /dev/null
+++ b/middle-of-the-linked-list/middle-of-the-linked-list.cpp
@@ -0,0 +1,26 @@
+/**
+ * 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* middleNode(ListNode* head) {
+        if(head == NULL || head->next == NULL)return 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/min-cost-climbing-stairs/README.md b/min-cost-climbing-stairs/README.md
new file mode 100644
index 0000000..12f03b4
--- /dev/null
+++ b/min-cost-climbing-stairs/README.md
@@ -0,0 +1,38 @@
+<h2>746. Min Cost Climbing Stairs</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/min-cost-climbing-stairs/min-cost-climbing-stairs.cpp b/min-cost-climbing-stairs/min-cost-climbing-stairs.cpp
new file mode 100644
index 0000000..6f08ff4
--- /dev/null
+++ b/min-cost-climbing-stairs/min-cost-climbing-stairs.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+   int minCostClimbingStairs(vector<int>& cost) {
+       int n = cost.size();
+       vector<int> dp(n);
+       dp[n-1] = cost[n-1];
+       dp[n-2] = cost[n-2];
+       if(n<=2)return min(dp[n-1],dp[n-2]);
+       for(int i=n-3;i>=0;i--)
+       {
+           dp[i] = min(dp[i+1],dp[i+2])+cost[i];
+       }
+       // for(int i=0;i<n;i++)
+       //     cout<<dp[i]<<" ";
+       
+       return min(dp[0],dp[1]);
+    }
+};
\ No newline at end of file
diff --git a/minimum-absolute-difference-in-bst/README.md b/minimum-absolute-difference-in-bst/README.md
new file mode 100644
index 0000000..7f8028a
--- /dev/null
+++ b/minimum-absolute-difference-in-bst/README.md
@@ -0,0 +1,26 @@
+<h2>530. Minimum Absolute Difference in BST</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a Binary Search Tree (BST), return <em>the minimum absolute difference between the values of any two different nodes in the tree</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/05/bst1.jpg" style="width: 292px; height: 301px;">
+<pre><strong>Input:</strong> root = [4,2,6,1,3]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/05/bst2.jpg" style="width: 282px; height: 301px;">
+<pre><strong>Input:</strong> root = [1,0,48,null,null,12,49]
+<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>4</sup>]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as 783: <a href="https://leetcode.com/problems/minimum-distance-between-bst-nodes/" target="_blank">https://leetcode.com/problems/minimum-distance-between-bst-nodes/</a></p>
+</div>
\ No newline at end of file
diff --git a/minimum-absolute-difference-in-bst/minimum-absolute-difference-in-bst.cpp b/minimum-absolute-difference-in-bst/minimum-absolute-difference-in-bst.cpp
new file mode 100644
index 0000000..2b0d301
--- /dev/null
+++ b/minimum-absolute-difference-in-bst/minimum-absolute-difference-in-bst.cpp
@@ -0,0 +1,41 @@
+/**
+ * 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:
+    int getMinimumDifference(TreeNode* root) {
+      if(root == NULL)
+          return -1;
+      int mini = INT_MAX;
+      int prev = INT_MIN;
+      stack <TreeNode *> s;
+      TreeNode * temp = root;
+      
+      while(temp || !s.empty())
+      {
+        if(temp)
+        {
+          s.push(temp);
+          temp = temp->left;
+        }
+        else
+        {
+          temp = s.top();
+          s.pop();
+          if(prev != INT_MIN)
+          mini = min(mini,abs(prev-temp->val));
+          prev = temp->val;
+          temp = temp->right;
+        }
+      }
+      return mini;
+    }
+};
\ No newline at end of file
diff --git a/minimum-cost-to-move-chips-to-the-same-position/README.md b/minimum-cost-to-move-chips-to-the-same-position/README.md
new file mode 100644
index 0000000..03393dc
--- /dev/null
+++ b/minimum-cost-to-move-chips-to-the-same-position/README.md
@@ -0,0 +1,42 @@
+<h2>1217. Minimum Cost to Move Chips to The Same Position</h2><h3>Easy</h3><hr><div><p>We have <code>n</code> chips, where the position of the <code>i<sup>th</sup></code> chip is <code>position[i]</code>.</p>
+
+<p>We need to move all the chips to <strong>the same position</strong>. In one step, we can change the position of the <code>i<sup>th</sup></code> chip from <code>position[i]</code> to:</p>
+
+<ul>
+	<li><code>position[i] + 2</code> or <code>position[i] - 2</code> with <code>cost = 0</code>.</li>
+	<li><code>position[i] + 1</code> or <code>position[i] - 1</code> with <code>cost = 1</code>.</li>
+</ul>
+
+<p>Return <em>the minimum cost</em> needed to move all the chips to the same position.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/15/chips_e1.jpg" style="width: 750px; height: 217px;">
+<pre><strong>Input:</strong> position = [1,2,3]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> First step: Move the chip at position 3 to position 1 with cost = 0.
+Second step: Move the chip at position 2 to position 1 with cost = 1.
+Total cost is 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/15/chip_e2.jpg" style="width: 750px; height: 306px;">
+<pre><strong>Input:</strong> position = [2,2,2,3,3]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> We can move the two chips at position  3 to position 2. Each move has cost = 1. The total cost = 2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> position = [1,1000000000]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= position.length &lt;= 100</code></li>
+	<li><code>1 &lt;= position[i] &lt;= 10^9</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/minimum-cost-to-move-chips-to-the-same-position/minimum-cost-to-move-chips-to-the-same-position.cpp b/minimum-cost-to-move-chips-to-the-same-position/minimum-cost-to-move-chips-to-the-same-position.cpp
new file mode 100644
index 0000000..e258aec
--- /dev/null
+++ b/minimum-cost-to-move-chips-to-the-same-position/minimum-cost-to-move-chips-to-the-same-position.cpp
@@ -0,0 +1,9 @@
+class Solution {
+public:
+    int minCostToMoveChips(vector<int>& P) {
+        int oddPos = 0, evenPos = 0;
+        for(int p : P)
+            p & 1 ? oddPos++ : evenPos++;
+        return min(oddPos, evenPos);
+    }
+};
\ No newline at end of file
diff --git a/minimum-depth-of-binary-tree/README.md b/minimum-depth-of-binary-tree/README.md
new file mode 100644
index 0000000..449f6c6
--- /dev/null
+++ b/minimum-depth-of-binary-tree/README.md
@@ -0,0 +1,27 @@
+<h2>111. Minimum Depth of Binary Tree</h2><h3>Easy</h3><hr><div><p>Given a binary tree, find its minimum depth.</p>
+
+<p>The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.</p>
+
+<p><strong>Note:</strong>&nbsp;A leaf is a node with no children.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg" style="width: 432px; height: 302px;">
+<pre><strong>Input:</strong> root = [3,9,20,null,null,15,7]
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> root = [2,null,3,null,4,null,5,null,6]
+<strong>Output:</strong> 5
+</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>5</sup>]</code>.</li>
+	<li><code>-1000 &lt;= Node.val &lt;= 1000</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/minimum-depth-of-binary-tree/minimum-depth-of-binary-tree.cpp b/minimum-depth-of-binary-tree/minimum-depth-of-binary-tree.cpp
new file mode 100644
index 0000000..e7759b3
--- /dev/null
+++ b/minimum-depth-of-binary-tree/minimum-depth-of-binary-tree.cpp
@@ -0,0 +1,44 @@
+/**
+ * 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:
+    int minDepth(TreeNode* root) {
+        
+        if(root == NULL)
+            return 0;
+        queue <TreeNode*> q;
+        int ans = 0;
+        q.push(root);
+        while(q.size())
+        {
+            int n = q.size();
+            ans++;
+            
+            for(int i=0;i<n;i++)
+            {
+            TreeNode * front = q.front();
+            q.pop();
+            
+            if(front->left == NULL && front->right == NULL)
+                return ans;
+                
+            if(front->left)
+                q.push(front->left);
+            if(front->right)
+                q.push(front->right);
+            
+            }  
+            
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/minimum-distance-between-bst-nodes/README.md b/minimum-distance-between-bst-nodes/README.md
new file mode 100644
index 0000000..c32258d
--- /dev/null
+++ b/minimum-distance-between-bst-nodes/README.md
@@ -0,0 +1,26 @@
+<h2>783. Minimum Distance Between BST Nodes</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a Binary Search Tree (BST), return <em>the minimum difference between the values of any two different nodes in the tree</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/05/bst1.jpg" style="width: 292px; height: 301px;">
+<pre><strong>Input:</strong> root = [4,2,6,1,3]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/05/bst2.jpg" style="width: 282px; height: 301px;">
+<pre><strong>Input:</strong> root = [1,0,48,null,null,12,49]
+<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, 100]</code>.</li>
+	<li><code>0 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Note:</strong> This question is the same as 530: <a href="https://leetcode.com/problems/minimum-absolute-difference-in-bst/" target="_blank">https://leetcode.com/problems/minimum-absolute-difference-in-bst/</a></p>
+</div>
\ No newline at end of file
diff --git a/minimum-distance-between-bst-nodes/minimum-distance-between-bst-nodes.cpp b/minimum-distance-between-bst-nodes/minimum-distance-between-bst-nodes.cpp
new file mode 100644
index 0000000..66661f0
--- /dev/null
+++ b/minimum-distance-between-bst-nodes/minimum-distance-between-bst-nodes.cpp
@@ -0,0 +1,38 @@
+/**
+ * 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:
+    int minDiffInBST(TreeNode* root) {
+        if(root == NULL)
+            return INT_MAX;
+        
+        int mini = INT_MAX;
+        stack <TreeNode * > s;
+        TreeNode * temp = NULL;
+        
+        while(root != NULL || !s.empty() )
+        {
+            while(root != NULL)
+            {
+                s.push(root);
+                root = root->left;
+            }
+            root = s.top();
+            s.pop();
+            if(temp != NULL && abs(temp->val - root->val) < mini )
+                mini = abs(temp->val - root->val) ;
+            temp = root;
+            root = root->right;
+        }
+        return mini;
+    }
+};
\ No newline at end of file
diff --git a/minimum-falling-path-sum/README.md b/minimum-falling-path-sum/README.md
new file mode 100644
index 0000000..ab22a5d
--- /dev/null
+++ b/minimum-falling-path-sum/README.md
@@ -0,0 +1,28 @@
+<h2>931. Minimum Falling Path Sum</h2><h3>Medium</h3><hr><div><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>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>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>
+</div>
\ No newline at end of file
diff --git a/minimum-falling-path-sum/minimum-falling-path-sum.cpp b/minimum-falling-path-sum/minimum-falling-path-sum.cpp
new file mode 100644
index 0000000..f9b6aab
--- /dev/null
+++ b/minimum-falling-path-sum/minimum-falling-path-sum.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int minFallingPathSum(vector<vector<int>>& A) {
+    vector<vector<int>> dp(A.size(),vector<int>(A.size(),INT_MAX));
+    for(int i=0;i<A.size();i++){
+        dp[0][i] = A[0][i];
+    }
+    for(int i=1;i<A.size();i++){
+        for(int j=0;j<A.size();j++){
+            if(j>0 and j<A.size()-1){
+                dp[i][j] = min(dp[i-1][j-1]+A[i][j],dp[i-1][j]+A[i][j]);
+                dp[i][j] = min(dp[i-1][j+1]+A[i][j],dp[i][j]);
+            }
+            else if(j==0){
+                dp[i][j] = min(dp[i-1][j+1]+A[i][j],dp[i-1][j]+A[i][j]);
+            }
+            else if(j == A.size()-1){
+                dp[i][j] = min(dp[i-1][j-1]+A[i][j],dp[i-1][j]+A[i][j]);
+            }
+        }
+    }
+    
+    int ans = INT_MAX;
+    for(auto& x:dp[dp.size()-1]){
+            ans = min(ans,x);
+    }
+    return ans;
+    }
+};
\ No newline at end of file
diff --git a/minimum-height-trees/README.md b/minimum-height-trees/README.md
new file mode 100644
index 0000000..5ba4d9d
--- /dev/null
+++ b/minimum-height-trees/README.md
@@ -0,0 +1,46 @@
+<h2>310. Minimum Height Trees</h2><h3>Medium</h3><hr><div><p>A tree is an undirected graph in which any two vertices are connected by&nbsp;<i>exactly</i>&nbsp;one path. In other words, any connected graph without simple cycles is a tree.</p>
+
+<p>Given a tree of <code>n</code> nodes&nbsp;labelled from <code>0</code> to <code>n - 1</code>, and an array of&nbsp;<code>n - 1</code>&nbsp;<code>edges</code> where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an undirected edge between the two nodes&nbsp;<code>a<sub>i</sub></code> and&nbsp;<code>b<sub>i</sub></code> in the tree,&nbsp;you can choose any node of the tree as the root. When you select a node <code>x</code> as the root, the result tree has height <code>h</code>. Among all possible rooted trees, those with minimum height (i.e. <code>min(h)</code>)&nbsp; are called <strong>minimum height trees</strong> (MHTs).</p>
+
+<p>Return <em>a list of all <strong>MHTs'</strong> root labels</em>.&nbsp;You can return the answer in <strong>any order</strong>.</p>
+
+<p>The <strong>height</strong> of a rooted tree is the number of edges on the longest downward path between the root and a leaf.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/e1.jpg" style="width: 800px; height: 213px;">
+<pre><strong>Input:</strong> n = 4, edges = [[1,0],[1,2],[1,3]]
+<strong>Output:</strong> [1]
+<strong>Explanation:</strong> As shown, the height of the tree is 1 when the root is the node with label 1 which is the only MHT.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/01/e2.jpg" style="width: 800px; height: 321px;">
+<pre><strong>Input:</strong> n = 6, edges = [[3,0],[3,1],[3,2],[3,4],[5,4]]
+<strong>Output:</strong> [3,4]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 1, edges = []
+<strong>Output:</strong> [0]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> n = 2, edges = [[0,1]]
+<strong>Output:</strong> [0,1]
+</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>edges.length == n - 1</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>All the pairs <code>(a<sub>i</sub>, b<sub>i</sub>)</code> are distinct.</li>
+	<li>The given input is <strong>guaranteed</strong> to be a tree and there will be <strong>no repeated</strong> edges.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/minimum-number-of-buckets-required-to-collect-rainwater-from-houses/README.md b/minimum-number-of-buckets-required-to-collect-rainwater-from-houses/README.md
new file mode 100644
index 0000000..8edddbd
--- /dev/null
+++ b/minimum-number-of-buckets-required-to-collect-rainwater-from-houses/README.md
@@ -0,0 +1,64 @@
+<h2>2086. Minimum Number of Buckets Required to Collect Rainwater from Houses</h2><h3>Medium</h3><hr><div><p>You are given a <b>0-index</b><strong>ed</strong> string <code>street</code>. Each character in <code>street</code> is either <code>'H'</code> representing a house or <code>'.'</code> representing an empty space.</p>
+
+<p>You can place buckets on the <strong>empty spaces</strong> to collect rainwater that falls from the adjacent houses. The rainwater from a house at index <code>i</code> is collected if a bucket is placed at index <code>i - 1</code> <strong>and/or</strong> index <code>i + 1</code>. A single bucket, if placed adjacent to two houses, can collect the rainwater from <strong>both</strong> houses.</p>
+
+<p>Return <em>the <strong>minimum </strong>number of buckets needed so that for <strong>every</strong> house, there is <strong>at least</strong> one bucket collecting rainwater from it, or </em><code>-1</code><em> if it is impossible.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> street = "H..H"
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+We can put buckets at index 1 and index 2.
+"H..H" -&gt; "HBBH" ('B' denotes where a bucket is placed).
+The house at index 0 has a bucket to its right, and the house at index 3 has a bucket to its left.
+Thus, for every house, there is at least one bucket collecting rainwater from it.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> street = ".H.H."
+<strong>Output:</strong> 1
+<strong>Explanation:</strong>
+We can put a bucket at index 2.
+".H.H." -&gt; ".HBH." ('B' denotes where a bucket is placed).
+The house at index 1 has a bucket to its right, and the house at index 3 has a bucket to its left.
+Thus, for every house, there is at least one bucket collecting rainwater from it.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> street = ".HHH."
+<strong>Output:</strong> -1
+<strong>Explanation:</strong>
+There is no empty space to place a bucket to collect the rainwater from the house at index 2.
+Thus, it is impossible to collect the rainwater from all the houses.
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> street = "H"
+<strong>Output:</strong> -1
+<strong>Explanation:</strong>
+There is no empty space to place a bucket.
+Thus, it is impossible to collect the rainwater from the house.
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> street = "."
+<strong>Output:</strong> 0
+<strong>Explanation:</strong>
+There is no house to collect water from.
+Thus, 0 buckets are needed.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= street.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>street[i]</code>&nbsp;is either<code>'H'</code>&nbsp;or&nbsp;<code>'.'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/minimum-number-of-steps-to-make-two-strings-anagram/README.md b/minimum-number-of-steps-to-make-two-strings-anagram/README.md
new file mode 100644
index 0000000..91c6477
--- /dev/null
+++ b/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/minimum-number-of-steps-to-make-two-strings-anagram/minimum-number-of-steps-to-make-two-strings-anagram.cpp b/minimum-number-of-steps-to-make-two-strings-anagram/minimum-number-of-steps-to-make-two-strings-anagram.cpp
new file mode 100644
index 0000000..f8f65f2
--- /dev/null
+++ b/minimum-number-of-steps-to-make-two-strings-anagram/minimum-number-of-steps-to-make-two-strings-anagram.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+   int minSteps(string s, string t) {
+        vector<int> mp(26, 0);
+        for(int i = 0; i < s.size(); i++) {
+            mp[s[i] - 'a']++;
+            mp[t[i] - 'a']--;
+        }
+        int pos = 0, neg = 0;
+        for(auto it : mp) {
+            if(it > 0) pos += it;
+            if(it < 0) neg -= it;
+        }
+        return max(pos, neg); 
+   }
+};
\ No newline at end of file
diff --git a/minimum-operations-to-make-array-equal/README.md b/minimum-operations-to-make-array-equal/README.md
new file mode 100644
index 0000000..ba9efd6
--- /dev/null
+++ b/minimum-operations-to-make-array-equal/README.md
@@ -0,0 +1,28 @@
+<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. <code>0 &lt;= i &lt; n</code>).</p>
+
+<p>In one operation, you can select two indices <code>x</code>&nbsp;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>&nbsp;(i.e. perform <code>arr[x] -=1&nbsp;</code>and <code>arr[y] += 1</code>).&nbsp;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&nbsp;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^4</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/minimum-operations-to-make-the-array-k-increasing/README.md b/minimum-operations-to-make-the-array-k-increasing/README.md
new file mode 100644
index 0000000..45d9f1c
--- /dev/null
+++ b/minimum-operations-to-make-the-array-k-increasing/README.md
@@ -0,0 +1,61 @@
+<h2>2111. Minimum Operations to Make the Array K-Increasing</h2><h3>Hard</h3><hr><div><p>You are given a <strong>0-indexed</strong> array <code>arr</code> consisting of <code>n</code> positive integers, and a positive integer <code>k</code>.</p>
+
+<p>The array <code>arr</code> is called <strong>K-increasing</strong> if <code>arr[i-k] &lt;= arr[i]</code> holds for every index <code>i</code>, where <code>k &lt;= i &lt;= n-1</code>.</p>
+
+<ul>
+	<li>For example, <code>arr = [4, 1, 5, 2, 6, 2]</code> is K-increasing for <code>k = 2</code> because:
+
+	<ul>
+		<li><code>arr[0] &lt;= arr[2] (4 &lt;= 5)</code></li>
+		<li><code>arr[1] &lt;= arr[3] (1 &lt;= 2)</code></li>
+		<li><code>arr[2] &lt;= arr[4] (5 &lt;= 6)</code></li>
+		<li><code>arr[3] &lt;= arr[5] (2 &lt;= 2)</code></li>
+	</ul>
+	</li>
+	<li>However, the same <code>arr</code> is not K-increasing for <code>k = 1</code> (because <code>arr[0] &gt; arr[1]</code>) or <code>k = 3</code> (because <code>arr[0] &gt; arr[3]</code>).</li>
+</ul>
+
+<p>In one <strong>operation</strong>, you can choose an index <code>i</code> and <strong>change</strong> <code>arr[i]</code> into <strong>any</strong> positive integer.</p>
+
+<p>Return <em>the <strong>minimum number of operations</strong> required to make the array K-increasing for the given </em><code>k</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [5,4,3,2,1], k = 1
+<strong>Output:</strong> 4
+<strong>Explanation:
+</strong>For k = 1, the resultant array has to be non-decreasing.
+Some of the K-increasing arrays that can be formed are [5,<u><strong>6</strong></u>,<u><strong>7</strong></u>,<u><strong>8</strong></u>,<u><strong>9</strong></u>], [<u><strong>1</strong></u>,<u><strong>1</strong></u>,<u><strong>1</strong></u>,<u><strong>1</strong></u>,1], [<u><strong>2</strong></u>,<u><strong>2</strong></u>,3,<u><strong>4</strong></u>,<u><strong>4</strong></u>]. All of them require 4 operations.
+It is suboptimal to change the array to, for example, [<u><strong>6</strong></u>,<u><strong>7</strong></u>,<u><strong>8</strong></u>,<u><strong>9</strong></u>,<u><strong>10</strong></u>] because it would take 5 operations.
+It can be shown that we cannot make the array K-increasing in less than 4 operations.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [4,1,5,2,6,2], k = 2
+<strong>Output:</strong> 0
+<strong>Explanation:</strong>
+This is the same example as the one in the problem description.
+Here, for every index i where 2 &lt;= i &lt;= 5, arr[i-2] &lt;=<b> </b>arr[i].
+Since the given array is already K-increasing, we do not need to perform any operations.</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [4,1,5,2,6,2], k = 3
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+Indices 3 and 5 are the only ones not satisfying arr[i-3] &lt;= arr[i] for 3 &lt;= i &lt;= 5.
+One of the ways we can make the array K-increasing is by changing arr[3] to 4 and arr[5] to 5.
+The array will now be [4,1,5,<u><strong>4</strong></u>,6,<u><strong>5</strong></u>].
+Note that there can be other ways to make the array K-increasing, but none of them require less than 2 operations.
+</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], k &lt;= arr.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/minimum-operations-to-make-the-array-k-increasing/minimum-operations-to-make-the-array-k-increasing.cpp b/minimum-operations-to-make-the-array-k-increasing/minimum-operations-to-make-the-array-k-increasing.cpp
new file mode 100644
index 0000000..c244537
--- /dev/null
+++ b/minimum-operations-to-make-the-array-k-increasing/minimum-operations-to-make-the-array-k-increasing.cpp
@@ -0,0 +1,25 @@
+class Solution {
+public:
+    int kIncreasing(vector<int>& arr, int k) {
+        int ans = 0;
+        
+        for(int i=0;i<k;i++)
+        {
+            vector<int> lis;
+            for(int j=i;j<arr.size();j+=k)
+            {
+                if(lis.size()==0 || lis.back() <= arr[j])
+                {
+                    lis.push_back(arr[j]);
+                }
+                else
+                {
+                    *upper_bound(lis.begin(),lis.end(),arr[j]) = arr[j];
+                }
+            }
+            ans += lis.size();
+        }
+        return arr.size()-ans;
+        
+    }
+};
\ No newline at end of file
diff --git a/minimum-path-sum/README.md b/minimum-path-sum/README.md
new file mode 100644
index 0000000..75e1973
--- /dev/null
+++ b/minimum-path-sum/README.md
@@ -0,0 +1,28 @@
+<h2>64. Minimum Path Sum</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/minimum-path-sum/minimum-path-sum.cpp b/minimum-path-sum/minimum-path-sum.cpp
new file mode 100644
index 0000000..b553be7
--- /dev/null
+++ b/minimum-path-sum/minimum-path-sum.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int minPathSum(vector<vector<int>>& grid) {
+        int m = grid.size();
+        int n = grid[0].size();
+        vector<vector<int>> dp(m, vector<int> (n));
+        dp[0][0] = grid[0][0];
+        for(int i=0;i<m;i++)
+        {
+            for(int j=0;j<n;j++)
+            {
+                if(j==0 && i>0)
+                {
+                    dp[i][j] = dp[i-1][j]+grid[i][j];
+                }
+                else if(j>0 && i==0)
+                {
+                    dp[i][j] = dp[i][j-1] + grid[i][j];
+                }
+                else if(i!=0 && j!=0)
+                {
+                    dp[i][j] = min(dp[i-1][j],dp[i][j-1])+grid[i][j];
+                }
+            }
+        }
+        return dp[m-1][n-1];
+        
+    }
+};
\ No newline at end of file
diff --git a/minimum-size-subarray-sum/README.md b/minimum-size-subarray-sum/README.md
new file mode 100644
index 0000000..ea315ea
--- /dev/null
+++ b/minimum-size-subarray-sum/README.md
@@ -0,0 +1,33 @@
+<h2>209. Minimum Size Subarray Sum</h2><h3>Medium</h3><hr><div><p>Given an array of positive integers <code>nums</code> and a positive integer <code>target</code>, return the minimal length of a <strong>contiguous subarray</strong> <code>[nums<sub>l</sub>, nums<sub>l+1</sub>, ..., nums<sub>r-1</sub>, nums<sub>r</sub>]</code> of which the sum is greater than or equal to <code>target</code>. If there is no such subarray, return <code>0</code> instead.</p>
+
+<p>&nbsp;</p>
+<p><strong>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>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> target = 4, nums = [1,4,4]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>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>5</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>.</div>
\ No newline at end of file
diff --git a/minimum-size-subarray-sum/minimum-size-subarray-sum.cpp b/minimum-size-subarray-sum/minimum-size-subarray-sum.cpp
new file mode 100644
index 0000000..28da110
--- /dev/null
+++ b/minimum-size-subarray-sum/minimum-size-subarray-sum.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    int minSubArrayLen(int target, vector<int>& nums) {
+        
+        int left= 0;
+        int right = 0;
+        int minlen = INT_MAX;
+        int sum = 0;
+         
+        while(right<nums.size())
+        {
+            sum+=nums[right++];
+            while(sum>=target)
+            {
+                minlen=min(minlen,right - left);
+                sum-=nums[left++];
+            }
+        
+        }
+        return minlen == INT_MAX ? 0 : minlen;
+        
+    }
+};
\ No newline at end of file
diff --git a/minimum-value-to-get-positive-step-by-step-sum/README.md b/minimum-value-to-get-positive-step-by-step-sum/README.md
new file mode 100644
index 0000000..faa7d8f
--- /dev/null
+++ b/minimum-value-to-get-positive-step-by-step-sum/README.md
@@ -0,0 +1,41 @@
+<h2>1413. Minimum Value to Get Positive Step by Step Sum</h2><h3>Easy</h3><hr><div><p>Given an array of integers&nbsp;<code>nums</code>, you start with an initial <strong>positive</strong> value <em>startValue</em><em>.</em></p>
+
+<p>In each iteration, you calculate the step by step sum of <em>startValue</em>&nbsp;plus&nbsp;elements in <code>nums</code>&nbsp;(from left to right).</p>
+
+<p>Return the minimum <strong>positive</strong> value of&nbsp;<em>startValue</em> such that the step by step sum is never less than 1.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-3,2,-3,4,2]
+<strong>Output:</strong> 5
+<strong>Explanation: </strong>If you choose startValue = 4, in the third iteration your step by step sum is less than 1.
+<strong>                step by step sum
+&nbsp;               startValue = 4 | startValue = 5 | nums
+</strong>&nbsp;                 (4 <strong>-3</strong> ) = 1  | (5 <strong>-3</strong> ) = 2    |  -3
+&nbsp;                 (1 <strong>+2</strong> ) = 3  | (2 <strong>+2</strong> ) = 4    |   2
+&nbsp;                 (3 <strong>-3</strong> ) = 0  | (4 <strong>-3</strong> ) = 1    |  -3
+&nbsp;                 (0 <strong>+4</strong> ) = 4  | (1 <strong>+4</strong> ) = 5    |   4
+&nbsp;                 (4 <strong>+2</strong> ) = 6  | (5 <strong>+2</strong> ) = 7    |   2
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> Minimum start value should be positive. 
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,-2,-3]
+<strong>Output:</strong> 5
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>-100 &lt;= nums[i] &lt;= 100</code></li>
+</ul></div>
\ No newline at end of file
diff --git a/minimum-value-to-get-positive-step-by-step-sum/minimum-value-to-get-positive-step-by-step-sum.cpp b/minimum-value-to-get-positive-step-by-step-sum/minimum-value-to-get-positive-step-by-step-sum.cpp
new file mode 100644
index 0000000..7d84a85
--- /dev/null
+++ b/minimum-value-to-get-positive-step-by-step-sum/minimum-value-to-get-positive-step-by-step-sum.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+   int minStartValue(vector<int>& nums) {
+        int ans = 0 , minAns=0;
+        for(int x : nums){
+            ans+= x;
+            if(ans < minAns)
+                minAns = ans;
+        }
+        return -minAns+1;
+    }
+};
\ No newline at end of file
diff --git a/minimum-window-substring/README.md b/minimum-window-substring/README.md
new file mode 100644
index 0000000..4bbfe2b
--- /dev/null
+++ b/minimum-window-substring/README.md
@@ -0,0 +1,41 @@
+<h2>76. Minimum Window Substring</h2><h3>Hard</h3><hr><div><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 substring</strong> 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. If there is no such substring</em><em>, return the empty string </em><code>""</code><em>.</em></p>
+
+<p>The testcases will be generated such that the answer is <strong>unique</strong>.</p>
+
+<p>A <strong>substring</strong> is a contiguous sequence of characters within the string.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "ADOBECODEBANC", t = "ABC"
+<strong>Output:</strong> "BANC"
+<strong>Explanation:</strong> The minimum window substring "BANC" includes 'A', 'B', and 'C' from string t.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "a", t = "a"
+<strong>Output:</strong> "a"
+<strong>Explanation:</strong> The entire string s is the minimum window.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "a", t = "aa"
+<strong>Output:</strong> ""
+<strong>Explanation:</strong> Both 'a's from t must be included in the window.
+Since the largest window of s only has one 'a', 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&nbsp;&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>
+<strong>Follow up:</strong> Could you find an algorithm that runs in <code>O(m + n)</code> time?</div>
\ No newline at end of file
diff --git a/minimum-window-substring/minimum-window-substring.cpp b/minimum-window-substring/minimum-window-substring.cpp
new file mode 100644
index 0000000..fd08628
--- /dev/null
+++ b/minimum-window-substring/minimum-window-substring.cpp
@@ -0,0 +1,52 @@
+// Including climits, which allows for usage of INT_MIN constant in C++
+#include <climits>
+class Solution {
+  public:
+    string minWindow(string searchString, string t) {
+      
+      // Our hashtable of characters filled with occurences in our string
+      vector<int> table(128, 0);
+      
+      // Store the frequency of characters in string t
+      for(auto character : t) {
+        table[character]++;
+      }
+      
+      int start = 0;
+      int end = 0;
+      int counter = t.size();
+      int startMin = 0;
+      int minimum = INT_MAX;
+      
+      // Here we use the 2 pointer approach
+      while(end < searchString.size()) {
+          if(table[searchString[end]] > 0) {
+            counter--;
+          }
+          
+          table[searchString[end]]--;
+          end++;
+          
+          while(counter == 0) {
+            if(end - start < minimum) {
+                startMin = start;
+                minimum = end - start;
+            }
+            
+            table[searchString[start]]++;
+            
+            if(table[searchString[start]] > 0) {
+              counter++;
+            }
+            start++;
+          }
+      }
+      
+      // Case when no substring satisfies
+      if(minimum == INT_MAX) {
+          return "";
+      }
+      
+      return searchString.substr(startMin, minimum);
+  }
+};
diff --git a/move-zeroes/README.md b/move-zeroes/README.md
new file mode 100644
index 0000000..a9f88f3
--- /dev/null
+++ b/move-zeroes/README.md
@@ -0,0 +1,22 @@
+<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/move-zeroes/move-zeroes.cpp b/move-zeroes/move-zeroes.cpp
new file mode 100644
index 0000000..5090aa3
--- /dev/null
+++ b/move-zeroes/move-zeroes.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+        int counter = 0;
+        int j = 0;
+        for(int i=0;i<nums.size();i++)
+        {
+            if(nums[i] != 0)
+            {
+                nums[j++] = nums[i];
+            }
+        }
+        for(int k = j;k<nums.size();k++)
+        {
+            nums[k] = 0;
+        }
+    }
+};
\ No newline at end of file
diff --git a/multiply-strings/README.md b/multiply-strings/README.md
new file mode 100644
index 0000000..3c63233
--- /dev/null
+++ b/multiply-strings/README.md
@@ -0,0 +1,21 @@
+<h2>43. Multiply Strings</h2><h3>Medium</h3><hr><div><p>Given two non-negative integers <code>num1</code> and <code>num2</code> represented as strings, return the product of <code>num1</code> and <code>num2</code>, also represented as a string.</p>
+
+<p><strong>Note:</strong>&nbsp;You must not use any built-in BigInteger library or convert the inputs to integer directly.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> num1 = "2", num2 = "3"
+<strong>Output:</strong> "6"
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> num1 = "123", num2 = "456"
+<strong>Output:</strong> "56088"
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= num1.length, num2.length &lt;= 200</code></li>
+	<li><code>num1</code> and <code>num2</code> consist of digits only.</li>
+	<li>Both <code>num1</code> and <code>num2</code>&nbsp;do not contain any leading zero, except the number <code>0</code> itself.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/multiply-strings/multiply-strings.cpp b/multiply-strings/multiply-strings.cpp
new file mode 100644
index 0000000..5dadeee
--- /dev/null
+++ b/multiply-strings/multiply-strings.cpp
@@ -0,0 +1,23 @@
+class Solution {
+public:
+    string multiply(string num1, string num2) {
+        if (num1 == "0" || num2 == "0") return "0";
+        
+        vector<int> res(num1.size()+num2.size(), 0);
+        
+        for (int i = num1.size()-1; i >= 0; i--) {
+            for (int j = num2.size()-1; j >= 0; j--) {
+                res[i + j + 1] += (num1[i]-'0') * (num2[j]-'0');
+                res[i + j] += res[i + j + 1] / 10;
+                res[i + j + 1] %= 10;
+            }
+        }
+        
+        int i = 0;
+        string ans = "";
+        while (res[i] == 0) i++;
+        while (i < res.size()) ans += to_string(res[i++]);
+        
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/n-ary-tree-level-order-traversal/README.md b/n-ary-tree-level-order-traversal/README.md
new file mode 100644
index 0000000..ed3de5a
--- /dev/null
+++ b/n-ary-tree-level-order-traversal/README.md
@@ -0,0 +1,29 @@
+<h2>429. N-ary Tree Level Order Traversal</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/n-ary-tree-level-order-traversal/n-ary-tree-level-order-traversal.cpp b/n-ary-tree-level-order-traversal/n-ary-tree-level-order-traversal.cpp
new file mode 100644
index 0000000..74488a2
--- /dev/null
+++ b/n-ary-tree-level-order-traversal/n-ary-tree-level-order-traversal.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    void rec(Node* root, int level) {
+        if (!root) return;
+        if (level == res.size()) res.push_back({});
+        res[level].push_back(root->val);
+        for (auto child : root->children)
+            rec(child, level+1);
+    }
+    
+    vector<vector<int>> levelOrder(Node* root) {
+        rec(root, 0);
+        return res;
+    }
+    
+private:
+    vector<vector<int>> res;
+};
\ No newline at end of file
diff --git a/n-ary-tree-preorder-traversal/README.md b/n-ary-tree-preorder-traversal/README.md
new file mode 100644
index 0000000..d20897a
--- /dev/null
+++ b/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/n-ary-tree-preorder-traversal/n-ary-tree-preorder-traversal.cpp b/n-ary-tree-preorder-traversal/n-ary-tree-preorder-traversal.cpp
new file mode 100644
index 0000000..cd006a0
--- /dev/null
+++ b/n-ary-tree-preorder-traversal/n-ary-tree-preorder-traversal.cpp
@@ -0,0 +1,41 @@
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> children;
+
+    Node() {}
+
+    Node(int _val) {
+        val = _val;
+    }
+
+    Node(int _val, vector<Node*> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+#include <bits/stdc++.h>
+using namespace std;
+  
+class Solution {
+public:
+    vector<int> preorder(Node* root) {
+        if(root == NULL)
+            return {};
+            
+        vector <int> ans;
+            for(int i=0;i<root->children.size();i++)
+            {
+                vector <int> an = preorder(root->children[i]);
+              ans.insert(ans.end(),an.begin() , an.end()); 
+            }
+        
+        ans.insert(ans.begin(),root->val);
+        
+        return ans;
+            
+    }
+};
\ No newline at end of file
diff --git a/n-th-tribonacci-number/README.md b/n-th-tribonacci-number/README.md
new file mode 100644
index 0000000..514ab2e
--- /dev/null
+++ b/n-th-tribonacci-number/README.md
@@ -0,0 +1,29 @@
+<h2>1137. N-th Tribonacci Number</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/n-th-tribonacci-number/n-th-tribonacci-number.cpp b/n-th-tribonacci-number/n-th-tribonacci-number.cpp
new file mode 100644
index 0000000..25aa56a
--- /dev/null
+++ b/n-th-tribonacci-number/n-th-tribonacci-number.cpp
@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int tribonacci(int n) {
+         vector <int> a;
+      a.push_back(0);
+      a.push_back(1);
+      a.push_back(1);
+      for(int i=3;i<=n;i++)
+      {
+        a.push_back(a[i-1]+a[i-2]+a[i-3]);
+      }
+      return a[n];
+    }
+};
\ No newline at end of file
diff --git a/nCr mod M _ Part 1 - GFG/README.md b/nCr mod M _ Part 1 - GFG/README.md
new file mode 100644
index 0000000..5b6a635
--- /dev/null
+++ b/nCr mod M _ Part 1 - GFG/README.md	
@@ -0,0 +1,34 @@
+# nCr mod M | Part 1
+## Hard 
+<div class="problem-statement">
+                <p></p><p><span style="font-size:18px">Given 2&nbsp;integers n and r. You task is to calculate <sup>n</sup>C</span><span style="font-size:15px">r</span><span style="font-size:18px">%1000003.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Example 1:</strong></span></p>
+
+<pre><strong><span style="font-size:18px">Input: </span></strong><span style="font-size:18px">n = 5, r = 2
+<strong>Output: </strong>10
+<strong>Explanation: </strong><sup>5</sup>C2 = 5! / (2! * 3!) = 10</span>
+</pre>
+
+<p><span style="font-size:18px"><strong>Example 2:</strong></span></p>
+
+<pre><span style="font-size:18px"><strong>Input: </strong>n = 3, r = 2
+<strong>Output: </strong>3
+<strong>Explanation: </strong><sup>3</sup>C2 = 3! / (2! * 1!) = 3</span>
+</pre>
+
+<p>&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Your Task:</strong><br>
+You don't need to read or print anything. Your task is to complete the function&nbsp;<strong>nCr()&nbsp;</strong>which takes n and r as input parameter and returns nCr modulo 1000003.</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Expected Time Complexity:&nbsp;</strong>O(m&nbsp;* log<sub>m</sub>n) where m = 1000003<br>
+<strong>Expected Space Complexity:&nbsp;</strong>O(m)</span><br>
+&nbsp;</p>
+
+<p><span style="font-size:18px"><strong>Constraints:</strong><br>
+1 &lt;= n &lt;= r &lt;= 10<sup>16</sup></span></p>
+ <p></p>
+            </div>
\ No newline at end of file
diff --git a/nCr mod M _ Part 1 - GFG/n-cr-mod-m-part-1.cpp b/nCr mod M _ Part 1 - GFG/n-cr-mod-m-part-1.cpp
new file mode 100644
index 0000000..3ebc2ea
--- /dev/null
+++ b/nCr mod M _ Part 1 - GFG/n-cr-mod-m-part-1.cpp	
@@ -0,0 +1,69 @@
+// { Driver Code Starts
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+ // } Driver Code Ends
+
+class Solution {
+private:
+    int mod = 1000003;
+    vector<int> fac;
+    vector<int> fac_inv;
+    int power(int n, int m) {
+        int res = 1;
+        n %= mod;
+        while(m > 0) {
+            if(m & 1) {
+                res = (1LL * res * n)%mod;
+                m--;
+            } else {
+                n = (1LL * n * n)%mod;
+                m /= 2;
+            }
+        }
+        return res%mod;
+    }
+    int fermat(int n, int r) {
+        n %= mod, r %= mod;
+        if(n < r) return 0;
+        if(r == 0 || n == r) return 1;
+        return (1LL * fac[n] * fac_inv[r] * fac_inv[n-r])%mod;
+    }
+    long long lucas(long long n,long long r){
+        if(r == 0) return 1;
+        int ni = n % mod, ri = r % mod;
+        return (lucas(n/mod,r/mod) * fermat(ni,ri)) % mod;
+    }
+public:
+    Solution() {
+        fac.resize(mod);
+        fac_inv.resize(mod);
+
+        fac[0] = 1;
+        for(int i=1; i<mod; i++)
+            fac[i] = (1LL * fac[i-1] * i)%mod;
+
+        fac_inv[mod-1] = power(fac[mod-1], mod-2); // mod inverse
+        for(int i=mod-2; i>0; i--)
+            fac_inv[i] = (1LL * fac_inv[i+1] * (i+1))%mod;
+    }
+    int nCr(long long n, long long r) {
+        return lucas(n, r);
+    }
+};
+
+// { Driver Code Starts.
+int main(){
+	int tc;
+	cin >> tc;
+	while(tc--){
+		long long n, r;
+		cin >> n >> r;
+		Solution obj;
+		int ans = obj.nCr(n, r);
+		cout << ans << "\n";
+	}
+	return 0;
+}  // } Driver Code Ends
\ No newline at end of file
diff --git a/next-greater-element-i/README.md b/next-greater-element-i/README.md
new file mode 100644
index 0000000..00d3d7f
--- /dev/null
+++ b/next-greater-element-i/README.md
@@ -0,0 +1,40 @@
+<h2>496. Next Greater Element I</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/next-greater-element-i/next-greater-element-i.cpp b/next-greater-element-i/next-greater-element-i.cpp
new file mode 100644
index 0000000..370e12b
--- /dev/null
+++ b/next-greater-element-i/next-greater-element-i.cpp
@@ -0,0 +1,51 @@
+class Solution {
+public:
+    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
+        
+        stack <int> s;
+        map <int,int> m;
+        vector <int> res(nums1.size(),-1);
+        
+        for(int i=0;i<nums2.size();i++)
+        {
+            int ele = nums2[i];
+            
+            // if( s.empty() == false && ele <= s.top())
+            // {
+            //     s.push(ele);
+            // }
+            // else
+            // {
+            //     while(s.empty() != true)
+            //     {
+            //         m[s.top()] = ele;
+            //         s.pop();
+            //     }
+            // }
+            
+            while(!s.empty() && ele > s.top())
+            {
+                m[s.top()] = ele;
+                s.pop();
+            }
+            s.push(ele);
+            
+        }
+        
+        for(int i=0;i<nums1.size();i++)
+        {
+            int num = nums1[i];
+            
+            if(m.find(num) != m.end())
+            {
+                int val = m[num];
+                res[i] = val;
+            }
+            
+        }
+        return res;
+        
+        
+        
+    }
+};
\ No newline at end of file
diff --git a/next-greater-element-ii/README.md b/next-greater-element-ii/README.md
new file mode 100644
index 0000000..bea237b
--- /dev/null
+++ b/next-greater-element-ii/README.md
@@ -0,0 +1,28 @@
+<h2>503. Next Greater Element II</h2><h3>Medium</h3><hr><div><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't exist, return <code>-1</code> for this number.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,1]
+<strong>Output:</strong> [2,-1,2]
+Explanation: The first 1's next greater number is 2; 
+The number 2 can't find next greater number. 
+The second 1's next greater number needs to search circularly, which is also 2.
+</pre>
+
+<p><strong>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>
+</div>
\ No newline at end of file
diff --git a/next-greater-element-ii/next-greater-element-ii.cpp b/next-greater-element-ii/next-greater-element-ii.cpp
new file mode 100644
index 0000000..c771e41
--- /dev/null
+++ b/next-greater-element-ii/next-greater-element-ii.cpp
@@ -0,0 +1,29 @@
+class Solution {
+public:
+    vector<int> nextGreaterElements(vector<int>& nums) {
+        
+        vector <int> temp(nums);
+        
+        vector <int> res(nums.size(),-1);
+        
+        for(int i=0;i<nums.size();i++)
+            temp.push_back(nums[i]);
+        
+          // for(int j = 0; j<temp.size();j++)
+          //     cout<<temp[j]<<" ";
+        for(int i=0;i<nums.size();i++)
+        {
+            for(int j = i+1; j<temp.size();j++)
+            {
+                if(temp[j] > nums[i])
+                {
+                     res[i] = temp[j];
+                     break;
+                }
+            }
+        }
+        
+         return res;
+        
+    }
+};
\ No newline at end of file
diff --git a/next-permutation/README.md b/next-permutation/README.md
new file mode 100644
index 0000000..6219648
--- /dev/null
+++ b/next-permutation/README.md
@@ -0,0 +1,28 @@
+<h2>31. Next Permutation</h2><h3>Medium</h3><hr><div><p>Implement <strong>next permutation</strong>, which rearranges numbers into the lexicographically next greater permutation of numbers.</p>
+
+<p>If such an arrangement is not possible, it must rearrange it as the lowest possible order (i.e., sorted in ascending order).</p>
+
+<p>The replacement must be <strong><a href="http://en.wikipedia.org/wiki/In-place_algorithm" target="_blank">in place</a></strong> and use only constant&nbsp;extra memory.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,2,3]
+<strong>Output:</strong> [1,3,2]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [3,2,1]
+<strong>Output:</strong> [1,2,3]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> nums = [1,1,5]
+<strong>Output:</strong> [1,5,1]
+</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>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/next-permutation/next-permutation.cpp b/next-permutation/next-permutation.cpp
new file mode 100644
index 0000000..fec61a2
--- /dev/null
+++ b/next-permutation/next-permutation.cpp
@@ -0,0 +1,36 @@
+class Solution {
+public:
+    void nextPermutation(vector<int>& nums) {
+        int index = 0;
+        
+        for(int i=nums.size()-1;i>=1;i--)
+        {
+            if(nums[i] > nums[i-1])
+            {
+                index = i;
+                break;
+            }
+        }
+        
+        if(index)
+        {
+            int index2 = index;
+            for(int i=nums.size()-1;i>=index;i--)
+            {
+                if(nums[i]>nums[index-1] && nums[i]<=nums[index])
+                {
+                    index2 = i;
+                    break;
+                }
+            }
+            swap(nums[index-1],nums[index2]);
+            sort(nums.begin()+index,nums.end());
+            
+        }
+        else
+        {
+            sort(nums.begin(),nums.end());
+            
+        }
+    }
+};
\ No newline at end of file
diff --git a/number-of-1-bits/README.md b/number-of-1-bits/README.md
new file mode 100644
index 0000000..5082363
--- /dev/null
+++ b/number-of-1-bits/README.md
@@ -0,0 +1,40 @@
+<h2>191. Number of 1 Bits</h2><h3>Easy</h3><hr><div><p>Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the <a href="http://en.wikipedia.org/wiki/Hamming_weight" target="_blank">Hamming weight</a>).</p>
+
+<p><strong>Note:</strong></p>
+
+<ul>
+	<li>Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. It should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.</li>
+	<li>In Java, the compiler represents the signed integers using <a href="https://en.wikipedia.org/wiki/Two%27s_complement" target="_blank">2's complement notation</a>. Therefore, in <strong>Example 3</strong>, the input represents the signed integer. <code>-3</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 00000000000000000000000000001011
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The input binary string <strong>00000000000000000000000000001011</strong> has a total of three '1' bits.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 00000000000000000000000010000000
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The input binary string <strong>00000000000000000000000010000000</strong> has a total of one '1' bit.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> n = 11111111111111111111111111111101
+<strong>Output:</strong> 31
+<strong>Explanation:</strong> The input binary string <strong>11111111111111111111111111111101</strong> has a total of thirty one '1' bits.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The input must be a <strong>binary string</strong> of length <code>32</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> If this function is called many times, how would you optimize it?</div>
\ No newline at end of file
diff --git a/number-of-islands/README.md b/number-of-islands/README.md
new file mode 100644
index 0000000..bb3597e
--- /dev/null
+++ b/number-of-islands/README.md
@@ -0,0 +1,37 @@
+<h2>200. Number of Islands</h2><h3>Medium</h3><hr><div><p>Given an <code>m x n</code> 2D binary grid <code>grid</code> which represents a map of <code>'1'</code>s (land) and <code>'0'</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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> grid = [
+  ["1","1","1","1","0"],
+  ["1","1","0","1","0"],
+  ["1","1","0","0","0"],
+  ["0","0","0","0","0"]
+]
+<strong>Output:</strong> 1
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> grid = [
+  ["1","1","0","0","0"],
+  ["1","1","0","0","0"],
+  ["0","0","1","0","0"],
+  ["0","0","0","1","1"]
+]
+<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>'0'</code> or <code>'1'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/number-of-islands/number-of-islands.cpp b/number-of-islands/number-of-islands.cpp
new file mode 100644
index 0000000..2a345d2
--- /dev/null
+++ b/number-of-islands/number-of-islands.cpp
@@ -0,0 +1,33 @@
+class Solution {
+public:
+  
+  void dfs(vector<vector<char>>& grid,int r,int c)
+  {
+    if(r>=0 && c>=0 && r<grid.size() && c < grid[0].size() && grid[r][c] == '1')
+    {
+      grid[r][c] = '2';
+      dfs(grid,r-1,c);
+       dfs(grid,r+1,c);
+      dfs(grid,r,c-1);
+      dfs(grid,r,c+1);
+
+    }
+  }
+  
+    int numIslands(vector<vector<char>>& grid) {
+        int count = 0;
+      
+      for(int i=0;i<grid.size();i++)
+    {
+      for(int j =0;j<grid[i].size();j++)
+      {
+        if(grid[i][j] == '1') {
+        dfs(grid,i,j);
+        count++;
+        }
+      }
+   }
+return count;
+
+    }
+};
\ No newline at end of file
diff --git a/number-of-provinces/README.md b/number-of-provinces/README.md
new file mode 100644
index 0000000..1450dd3
--- /dev/null
+++ b/number-of-provinces/README.md
@@ -0,0 +1,33 @@
+<h2>547. Number of Provinces</h2><h3>Medium</h3><hr><div><p>There are <code>n</code> cities. Some of them are connected, while some are not. If city <code>a</code> is connected directly with city <code>b</code>, and city <code>b</code> is connected directly with city <code>c</code>, then city <code>a</code> is connected indirectly with city <code>c</code>.</p>
+
+<p>A <strong>province</strong> is a group of directly or indirectly connected cities and no other cities outside of the group.</p>
+
+<p>You are given an <code>n x n</code> matrix <code>isConnected</code> where <code>isConnected[i][j] = 1</code> if the <code>i<sup>th</sup></code> city and the <code>j<sup>th</sup></code> city are directly connected, and <code>isConnected[i][j] = 0</code> otherwise.</p>
+
+<p>Return <em>the total number of <strong>provinces</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/24/graph1.jpg" style="width: 222px; height: 142px;">
+<pre><strong>Input:</strong> isConnected = [[1,1,0],[1,1,0],[0,0,1]]
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/12/24/graph2.jpg" style="width: 222px; height: 142px;">
+<pre><strong>Input:</strong> isConnected = [[1,0,0],[0,1,0],[0,0,1]]
+<strong>Output:</strong> 3
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 200</code></li>
+	<li><code>n == isConnected.length</code></li>
+	<li><code>n == isConnected[i].length</code></li>
+	<li><code>isConnected[i][j]</code> is <code>1</code> or <code>0</code>.</li>
+	<li><code>isConnected[i][i] == 1</code></li>
+	<li><code>isConnected[i][j] == isConnected[j][i]</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/number-of-provinces/number-of-provinces.cpp b/number-of-provinces/number-of-provinces.cpp
new file mode 100644
index 0000000..1e85ef4
--- /dev/null
+++ b/number-of-provinces/number-of-provinces.cpp
@@ -0,0 +1,37 @@
+class Solution {
+public:
+  
+  
+    void dfs(int source,vector<vector<int>>& isConnected,int n,bool * visited)
+    {
+      visited[source] = true;
+      for(int i = 0;i<n;i++)
+      {
+        if(i+1 == source)
+          continue;
+        if(!visited[i+1] && isConnected[source-1][i] == 1 )
+        {
+          dfs(i+1,isConnected,n,visited);
+        }
+      }
+      return;
+    }
+  
+    int findCircleNum(vector<vector<int>>& isConnected) {
+      int n = isConnected.size();
+      bool * visited = new bool[n+1];
+      int count = 0;
+      for(int i=0;i<=n;i++)
+        visited[i] = false;
+      
+      for(int i=1;i<=n ;i++)
+      {
+        if(!visited[i])
+        {
+          dfs(i,isConnected,n,visited);
+          count++;
+        }
+      }
+      return count;
+    }
+};
\ No newline at end of file
diff --git a/number-of-valid-words-for-each-puzzle/README.md b/number-of-valid-words-for-each-puzzle/README.md
new file mode 100644
index 0000000..e0339e6
--- /dev/null
+++ b/number-of-valid-words-for-each-puzzle/README.md
@@ -0,0 +1,43 @@
+<h2>1178. Number of Valid Words for Each Puzzle</h2><h3>Hard</h3><hr><div>With respect to a given <code>puzzle</code> string, a <code>word</code> is <em>valid</em> if both the following conditions are satisfied:
+<ul>
+	<li><code>word</code> contains the first letter of <code>puzzle</code>.</li>
+	<li>For each letter in <code>word</code>, that letter is in <code>puzzle</code>.
+	<ul>
+		<li>For example, if the puzzle is <code>"abcdefg"</code>, then valid words are <code>"faced"</code>, <code>"cabbage"</code>, and <code>"baggage"</code>, while</li>
+		<li>invalid words are <code>"beefed"</code> (does not include <code>'a'</code>) and <code>"based"</code> (includes <code>'s'</code> which is not in the puzzle).</li>
+	</ul>
+	</li>
+</ul>
+Return <em>an array </em><code>answer</code><em>, where </em><code>answer[i]</code><em> is the number of words in the given word list </em><code>words</code><em> that is valid with respect to the puzzle </em><code>puzzles[i]</code>.
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> words = ["aaaa","asas","able","ability","actt","actor","access"], puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]
+<strong>Output:</strong> [1,1,3,2,4,0]
+<strong>Explanation:</strong> 
+1 valid word for "aboveyz" : "aaaa" 
+1 valid word for "abrodyz" : "aaaa"
+3 valid words for "abslute" : "aaaa", "asas", "able"
+2 valid words for "absoryz" : "aaaa", "asas"
+4 valid words for "actresz" : "aaaa", "asas", "actt", "access"
+There are no valid words for "gaswxyz" cause none of the words in the list contains letter 'g'.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> words = ["apple","pleas","please"], puzzles = ["aelwxyz","aelpxyz","aelpsxy","saelpxy","xaelpsy"]
+<strong>Output:</strong> [0,1,3,2,0]
+</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>4 &lt;= words[i].length &lt;= 50</code></li>
+	<li><code>1 &lt;= puzzles.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>puzzles[i].length == 7</code></li>
+	<li><code>words[i]</code> and <code>puzzles[i]</code> consist of lowercase English letters.</li>
+	<li>Each <code>puzzles[i] </code>does not contain repeated characters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/odd-even-linked-list/README.md b/odd-even-linked-list/README.md
new file mode 100644
index 0000000..734ab69
--- /dev/null
+++ b/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/odd-even-linked-list/odd-even-linked-list.cpp b/odd-even-linked-list/odd-even-linked-list.cpp
new file mode 100644
index 0000000..2c1dbaa
--- /dev/null
+++ b/odd-even-linked-list/odd-even-linked-list.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* oddEvenList(ListNode* head) {
+      
+      if(head == NULL || head->next == NULL)return head;
+       ListNode* f = head;
+      ListNode * g= f;
+      ListNode* s = head->next;
+      ListNode * d  = s;
+      
+      while(f  &&f->next && s && s->next)
+      {
+        if(f->next && f->next->next)
+        {
+            f->next = f->next->next;
+          f = f->next;
+         // cout<<"a"<<endl;
+        } 
+        if(s->next)
+        {
+          s->next = s->next->next;
+          s = s->next;
+        //  cout<<"v"<<endl;
+        } 
+      }
+      
+      f->next = d;
+      return g;
+      
+    }
+};
\ No newline at end of file
diff --git a/pairs-of-songs-with-total-durations-divisible-by-60/README.md b/pairs-of-songs-with-total-durations-divisible-by-60/README.md
new file mode 100644
index 0000000..05ff88a
--- /dev/null
+++ b/pairs-of-songs-with-total-durations-divisible-by-60/README.md
@@ -0,0 +1,30 @@
+<h2>1010. Pairs of Songs With Total Durations Divisible by 60</h2><h3>Medium</h3><hr><div><p>You are given a list of songs where the i<sup>th</sup> song has a duration of <code>time[i]</code> seconds.</p>
+
+<p>Return <em>the number of pairs of songs for which their total duration in seconds is divisible by</em> <code>60</code>. Formally, we want the number of indices <code>i</code>, <code>j</code> such that <code>i &lt; j</code> with <code>(time[i] + time[j]) % 60 == 0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> time = [30,20,150,100,40]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> Three pairs have a total duration divisible by 60:
+(time[0] = 30, time[2] = 150): total duration 180
+(time[1] = 20, time[3] = 100): total duration 120
+(time[1] = 20, time[4] = 40): total duration 60
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> time = [60,60,60]
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> All three pairs have a total duration of 120, which is divisible by 60.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= time.length &lt;= 6 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= time[i] &lt;= 500</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/pairs-of-songs-with-total-durations-divisible-by-60/pairs-of-songs-with-total-durations-divisible-by-60.cpp b/pairs-of-songs-with-total-durations-divisible-by-60/pairs-of-songs-with-total-durations-divisible-by-60.cpp
new file mode 100644
index 0000000..8648ced
--- /dev/null
+++ b/pairs-of-songs-with-total-durations-divisible-by-60/pairs-of-songs-with-total-durations-divisible-by-60.cpp
@@ -0,0 +1,13 @@
+class Solution {
+public:
+    int numPairsDivisibleBy60(vector<int>& t) {
+        vector<int> v(60);
+        int ans   =0;
+        for(int i=0;i<t.size();i++)
+        {
+            ans += v[(600-t[i])%60];
+            v[t[i]%60]++;
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/palindrome-linked-list/README.md b/palindrome-linked-list/README.md
new file mode 100644
index 0000000..c5558e6
--- /dev/null
+++ b/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/palindrome-linked-list/palindrome-linked-list.cpp b/palindrome-linked-list/palindrome-linked-list.cpp
new file mode 100644
index 0000000..ef84d80
--- /dev/null
+++ b/palindrome-linked-list/palindrome-linked-list.cpp
@@ -0,0 +1,60 @@
+/**
+ * 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 * reverse(ListNode * head)
+    {
+        if(head == NULL || head->next == NULL)
+            return head;
+        ListNode * curr = head;
+        ListNode * pre = NULL;
+        ListNode * nex = NULL;
+        
+        while(curr != NULL)
+        {
+            nex = curr->next;
+            curr->next = pre;
+            pre = curr;
+            curr = nex;
+        }
+        
+        return pre;
+    }
+    bool isPalindrome(ListNode* head) {
+        
+        if(head == NULL || head->next == NULL)
+            return true;
+        ListNode * slow = head;
+        ListNode * fast = head;
+       // cout<<slow->val<<endl;
+        while(fast->next != NULL && fast->next->next != NULL)
+        {
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+       // cout<<slow->val<<endl;
+        slow->next = reverse(slow->next);
+        slow = slow->next;
+        //cout<<slow->val<<endl;
+        ListNode * start = head;
+        while(slow != NULL)
+        {
+           // cout<<slow->val<<" a "<<endl;
+          //  cout<<start->val<<" d "<<endl;
+            if(slow->val != start->val)
+                return false;
+            
+            slow = slow->next;
+            start = start->next;
+        }
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/palindrome-partitioning-ii/README.md b/palindrome-partitioning-ii/README.md
new file mode 100644
index 0000000..71e01de
--- /dev/null
+++ b/palindrome-partitioning-ii/README.md
@@ -0,0 +1,32 @@
+<h2>132. Palindrome Partitioning II</h2><h3>Hard</h3><hr><div><p>Given a string <code>s</code>, partition <code>s</code> such that every substring of the partition is a palindrome.</p>
+
+<p>Return <em>the minimum cuts needed</em> for a palindrome partitioning of <code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "aab"
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The palindrome partitioning ["aa","b"] could be produced using 1 cut.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "a"
+<strong>Output:</strong> 0
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "ab"
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 2000</code></li>
+	<li><code>s</code> consists of lower-case English letters only.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/partition-array-for-maximum-sum/README.md b/partition-array-for-maximum-sum/README.md
new file mode 100644
index 0000000..f00e8d1
--- /dev/null
+++ b/partition-array-for-maximum-sum/README.md
@@ -0,0 +1,33 @@
+<h2>1043. Partition Array for Maximum Sum</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>arr</code>, partition the array into (contiguous) subarrays of length <strong>at most</strong> <code>k</code>. After partitioning, each subarray has their values changed to become the maximum value of that subarray.</p>
+
+<p>Return <em>the largest sum of the given array after partitioning. Test cases are generated so that the answer fits in a <strong>32-bit</strong> integer.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,15,7,9,2,5,10], k = 3
+<strong>Output:</strong> 84
+<strong>Explanation:</strong> arr becomes [15,15,15,9,10,10,10]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1,4,1,5,7,3,6,1,9,9,3], k = 4
+<strong>Output:</strong> 83
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1], k = 1
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 500</code></li>
+	<li><code>0 &lt;= arr[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= k &lt;= arr.length</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/partition-array-for-maximum-sum/partition-array-for-maximum-sum.cpp b/partition-array-for-maximum-sum/partition-array-for-maximum-sum.cpp
new file mode 100644
index 0000000..710bbf3
--- /dev/null
+++ b/partition-array-for-maximum-sum/partition-array-for-maximum-sum.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+   int dp[501] = {};
+int maxSumAfterPartitioning(vector<int>& A, int K, int pos = 0, int res = 0) {
+  if (pos < A.size() && dp[pos] != 0) return dp[pos];
+  for (int i = 1, mv = 0; i <= K && pos + i <= A.size(); ++i) {
+    mv = max(mv, A[pos + i - 1]);
+    res = max(res, mv * i + maxSumAfterPartitioning(A, K, pos + i));
+  }
+  return dp[pos] = res;
+}
+};
\ No newline at end of file
diff --git a/partition-array-into-disjoint-intervals/README.md b/partition-array-into-disjoint-intervals/README.md
new file mode 100644
index 0000000..56de9af
--- /dev/null
+++ b/partition-array-into-disjoint-intervals/README.md
@@ -0,0 +1,42 @@
+<h2>915. Partition Array into Disjoint Intervals</h2><h3>Medium</h3><hr><div><p>Given an array <code>nums</code>, partition it&nbsp;into two (contiguous) subarrays&nbsp;<code>left</code>&nbsp;and <code>right</code>&nbsp;so that:</p>
+
+<ul>
+	<li>Every element in <code>left</code>&nbsp;is less than or equal to every element in <code>right</code>.</li>
+	<li><code>left</code> and <code>right</code> are non-empty.</li>
+	<li><code>left</code>&nbsp;has the smallest possible size.</li>
+</ul>
+
+<p>Return the <strong>length</strong> of <code>left</code> after such a partitioning.&nbsp; It is guaranteed that such a partitioning exists.</p>
+
+<p>&nbsp;</p>
+
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input: </strong>nums = <span id="example-input-1-1">[5,0,3,8,6]</span>
+<strong>Output: </strong><span id="example-output-1">3</span>
+<strong>Explanation: </strong>left = [5,0,3], right = [8,6]
+</pre>
+
+<div>
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input: </strong>nums = <span id="example-input-2-1">[1,1,1,0,6,12]</span>
+<strong>Output: </strong><span id="example-output-2">4</span>
+<strong>Explanation: </strong>left = [1,1,1,0], right = [6,12]
+</pre>
+
+<p>&nbsp;</p>
+</div>
+
+<p><strong>Note:</strong></p>
+
+<ol>
+	<li><code>2 &lt;= nums.length&nbsp;&lt;= 30000</code></li>
+	<li><code>0 &lt;= nums[i] &lt;= 10<sup>6</sup></code></li>
+	<li>It is guaranteed there is at least one way to partition <code>nums</code> as described.</li>
+</ol>
+
+<div>
+<div>&nbsp;</div>
+</div>
+</div>
\ No newline at end of file
diff --git a/partition-array-into-disjoint-intervals/partition-array-into-disjoint-intervals.cpp b/partition-array-into-disjoint-intervals/partition-array-into-disjoint-intervals.cpp
new file mode 100644
index 0000000..d2f058e
--- /dev/null
+++ b/partition-array-into-disjoint-intervals/partition-array-into-disjoint-intervals.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int partitionDisjoint(vector<int>& A) {
+        vector<int> mx(A.size()), mi(A.size());
+        mx[0]=A[0]; mi[A.size()-1]=A.back();
+        for(int i=1; i<A.size(); i++)
+            mx[i]=max(A[i], mx[i-1]);
+        for(int i=A.size()-2; i>=0; i--)
+            mi[i]=min(A[i], mi[i+1]);
+        int i;
+        for(i=0; i<A.size()-1; i++)
+            if(mx[i]<=mi[i+1])
+                break;
+        return i+1;
+    }
+};
\ No newline at end of file
diff --git a/pascals-triangle-ii/README.md b/pascals-triangle-ii/README.md
new file mode 100644
index 0000000..3b2fb2d
--- /dev/null
+++ b/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/pascals-triangle/README.md b/pascals-triangle/README.md
new file mode 100644
index 0000000..a1948e8
--- /dev/null
+++ b/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/pascals-triangle/pascals-triangle.cpp b/pascals-triangle/pascals-triangle.cpp
new file mode 100644
index 0000000..3c82199
--- /dev/null
+++ b/pascals-triangle/pascals-triangle.cpp
@@ -0,0 +1,38 @@
+class Solution {
+public:
+    vector<vector<int>> generate(int numRows) {
+        vector<vector<int>> r(numRows);
+        
+        for(int i=0;i<numRows;i++)
+        {
+            r[i].resize(i+1);
+            r[i][0] = 1;
+            r[i][i] = 1;
+            
+            for(int j = 1;j<i;j++)
+            {
+                r[i][j] = r[i-1][j-1] + r[i-1][j];
+            }
+            
+        }
+//       vector <int> a;
+//       a.resize(numRows);
+//         a[0] = 1;
+//       a[numRows-1] =1;
+      
+//       for(int i=1;i<numRows-1;i++)
+//       {
+//         a[i] = a[i-1]*(numRows-i);
+//         a[i] = a[i] / i;
+//       }
+      
+//       for(auto ax:a)
+//         cout<<ax<<" ";
+//       cout<<endl;
+      
+
+        
+        return r;
+      
+    }
+};
\ No newline at end of file
diff --git a/patching-array/README.md b/patching-array/README.md
new file mode 100644
index 0000000..97239ab
--- /dev/null
+++ b/patching-array/README.md
@@ -0,0 +1,39 @@
+<h2>330. Patching Array</h2><h3>Hard</h3><hr><div><p>Given a sorted integer array <code>nums</code> and an integer <code>n</code>, add/patch elements to the array such that any number in the range <code>[1, n]</code> inclusive can be formed by the sum of some elements in the array.</p>
+
+<p>Return <em>the minimum number of patches required</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,3], n = 6
+<strong>Output:</strong> 1
+Explanation:
+Combinations of nums are [1], [3], [1,3], which form possible sums of: 1, 3, 4.
+Now if we add/patch 2 to nums, the combinations are: [1], [2], [3], [1,3], [2,3], [1,2,3].
+Possible sums are 1, 2, 3, 4, 5, 6, which now covers the range [1, 6].
+So we only need 1 patch.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,5,10], n = 20
+<strong>Output:</strong> 2
+Explanation: The two patches can be [2, 4].
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,2], n = 5
+<strong>Output:</strong> 0
+</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;= 10<sup>4</sup></code></li>
+	<li><code>nums</code> is sorted in <strong>ascending order</strong>.</li>
+	<li><code>1 &lt;= n &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/patching-array/patching-array.cpp b/patching-array/patching-array.cpp
new file mode 100644
index 0000000..1a4ed6e
--- /dev/null
+++ b/patching-array/patching-array.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+int minPatches(vector<int>& nums, int n) {
+    int cnt=0,i=0;
+    long long maxNum=0;
+    while (maxNum<n){
+       if (i<nums.size() && nums[i]<=maxNum+1)
+            maxNum+=nums[i++];
+       else{
+            maxNum+=maxNum+1;cnt++;
+       }
+   }
+   return cnt;
+}
+};
\ No newline at end of file
diff --git a/path-sum-ii/README.md b/path-sum-ii/README.md
new file mode 100644
index 0000000..f63cda3
--- /dev/null
+++ b/path-sum-ii/README.md
@@ -0,0 +1,35 @@
+<h2>113. Path Sum II</h2><h3>Medium</h3><hr><div><p>Given the <code>root</code> of a binary tree and an integer <code>targetSum</code>, return <em>all <strong>root-to-leaf</strong> paths where the sum of the node values in the path equals </em><code>targetSum</code><em>. Each path should be returned as a list of the node <strong>values</strong>, not node references</em>.</p>
+
+<p>A <strong>root-to-leaf</strong> path is a path starting from the root and ending at any leaf node. 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/pathsumii1.jpg" style="width: 500px; height: 356px;">
+<pre><strong>Input:</strong> root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
+<strong>Output:</strong> [[5,4,11,2],[5,8,4,5]]
+<strong>Explanation:</strong> There are two paths whose sum equals targetSum:
+5 + 4 + 11 + 2 = 22
+5 + 8 + 4 + 5 = 22
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg" style="width: 212px; height: 181px;">
+<pre><strong>Input:</strong> root = [1,2,3], targetSum = 5
+<strong>Output:</strong> []
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,2], targetSum = 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, 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/path-sum-ii/path-sum-ii.cpp b/path-sum-ii/path-sum-ii.cpp
new file mode 100644
index 0000000..0559ec3
--- /dev/null
+++ b/path-sum-ii/path-sum-ii.cpp
@@ -0,0 +1,30 @@
+/**
+ * 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:
+    vector<vector<int>> pathSum(TreeNode* root, int sum) {
+        vector<vector<int> > paths;
+        vector<int> path;
+        findPaths(root, sum, path, paths);
+        return paths;  
+    }
+private:
+    void findPaths(TreeNode* node, int sum, vector<int>& path, vector<vector<int> >& paths) {
+        if (!node) return;
+        path.push_back(node -> val);
+        if (!(node -> left) && !(node -> right) && sum == node -> val)
+            paths.push_back(path);
+        findPaths(node -> left, sum - node -> val, path, paths);
+        findPaths(node -> right, sum - node -> val, path, paths);
+        path.pop_back();
+    }
+};
\ No newline at end of file
diff --git a/path-sum/README.md b/path-sum/README.md
new file mode 100644
index 0000000..484fdce
--- /dev/null
+++ b/path-sum/README.md
@@ -0,0 +1,32 @@
+<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
+</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
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,2], targetSum = 0
+<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>[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/path-sum/path-sum.cpp b/path-sum/path-sum.cpp
new file mode 100644
index 0000000..83bea79
--- /dev/null
+++ b/path-sum/path-sum.cpp
@@ -0,0 +1,23 @@
+/**
+ * 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:
+    bool hasPathSum(TreeNode* root, int targetSum) {
+        if(root == NULL)
+            return false;
+        
+        if(root->right == NULL && root->left == NULL && root->val  == targetSum)
+            return true;
+        
+        return hasPathSum(root->left,targetSum - root->val) ||  hasPathSum(root->right,targetSum - root->val);
+    }
+};
\ No newline at end of file
diff --git a/perfect-squares/README.md b/perfect-squares/README.md
new file mode 100644
index 0000000..1ae0ade
--- /dev/null
+++ b/perfect-squares/README.md
@@ -0,0 +1,26 @@
+<h2>279. Perfect Squares</h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, return <em>the least number of perfect square numbers that sum to</em> <code>n</code>.</p>
+
+<p>A <strong>perfect square</strong> is an integer that is the square of an integer; in other words, it is the product of some integer with itself. For example, <code>1</code>, <code>4</code>, <code>9</code>, and <code>16</code> are perfect squares while <code>3</code> and <code>11</code> are not.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 12
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> 12 = 4 + 4 + 4.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 13
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> 13 = 4 + 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/perfect-squares/perfect-squares.cpp b/perfect-squares/perfect-squares.cpp
new file mode 100644
index 0000000..9d76bdd
--- /dev/null
+++ b/perfect-squares/perfect-squares.cpp
@@ -0,0 +1,27 @@
+class Solution {
+public:
+    int numSquares(int n) {
+      
+      if(n<=3)
+        return n;
+         vector<int> v(n + 1);
+  v[0] = 0;
+  v[1] = 1;
+  v[2] = 2;
+  v[3] = 3;
+
+  for (int i = 4; i <= n; i++)
+  {
+    v[i] = i;
+    for (int j = 1; j <= ceil(sqrt(i)); j++)
+    {
+      int temp = j * j;
+      if (temp > i)
+        break;
+
+      v[i] = min(v[i], 1 + v[i - temp]);
+    }
+  }
+  return v[n];
+    }
+};
\ No newline at end of file
diff --git a/permutations-ii/README.md b/permutations-ii/README.md
new file mode 100644
index 0000000..0a772d3
--- /dev/null
+++ b/permutations-ii/README.md
@@ -0,0 +1,26 @@
+<h2>47. Permutations II</h2><h3>Medium</h3><hr><div><p>Given a collection of numbers, <code>nums</code>,&nbsp;that might contain duplicates, return <em>all possible unique permutations <strong>in any order</strong>.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,1,2]
+<strong>Output:</strong>
+[[1,1,2],
+ [1,2,1],
+ [2,1,1]]
+</pre>
+
+<p><strong>Example 2:</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>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 8</code></li>
+	<li><code>-10 &lt;= nums[i] &lt;= 10</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/permutations-ii/permutations-ii.cpp b/permutations-ii/permutations-ii.cpp
new file mode 100644
index 0000000..3d3f9ae
--- /dev/null
+++ b/permutations-ii/permutations-ii.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+
+    void permuteUniqueHelper(int i, vector<int>& nums, vector<vector<int> >& result) {
+        if (i == nums.size()) { result.emplace_back(nums); return; }
+        unordered_set<int> st;
+        for (int j = i; j < nums.size(); ++j) {
+            if (st.count(nums[j]) == 1) { continue; }
+            st.insert(nums[j]);
+            std::swap(nums[i], nums[j]);
+            permuteUniqueHelper(i + 1, nums, result);
+            std::swap(nums[i], nums[j]);
+        }
+    }
+    
+    vector<vector<int>> permuteUnique(vector<int>& nums) {
+        vector<vector<int> > result;
+        permuteUniqueHelper(0, nums, result);
+        return result;
+    }
+};
\ No newline at end of file
diff --git a/populating-next-right-pointers-in-each-node/README.md b/populating-next-right-pointers-in-each-node/README.md
new file mode 100644
index 0000000..2143e6d
--- /dev/null
+++ b/populating-next-right-pointers-in-each-node/README.md
@@ -0,0 +1,44 @@
+<h2>116. Populating Next Right Pointers in Each Node</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/populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node.cpp b/populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node.cpp
new file mode 100644
index 0000000..e9dcbe4
--- /dev/null
+++ b/populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node.cpp
@@ -0,0 +1,34 @@
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* left;
+    Node* right;
+    Node* next;
+
+    Node() : val(0), left(NULL), right(NULL), next(NULL) {}
+
+    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
+
+    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) {
+      if (root->left) {
+        root->left->next = root->right;
+        if (root->next)
+          root->right->next = root->next->left;
+        connect(root->left);
+        connect(root->right);
+            
+      }
+    }
+    return root;
+  }
+};
\ No newline at end of file
diff --git a/populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node.java b/populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node.java
new file mode 100644
index 0000000..735f8fe
--- /dev/null
+++ b/populating-next-right-pointers-in-each-node/populating-next-right-pointers-in-each-node.java
@@ -0,0 +1,18 @@
+class Solution {
+    public Node connect(Node root) {
+        
+        if (root == null || root.left == null) {
+            return root;
+        }
+        
+        root.left.next = root.right;
+        if (root.next != null) {
+            root.right.next = root.next.left;
+        }
+        
+        connect (root.left);
+        connect (root.right);
+        
+        return root;
+    }
+}
\ No newline at end of file
diff --git a/power-of-four/README.md b/power-of-four/README.md
new file mode 100644
index 0000000..f537239
--- /dev/null
+++ b/power-of-four/README.md
@@ -0,0 +1,24 @@
+<h2>342. Power of Four</h2><h3>Easy</h3><hr><div><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>Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 16
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 5
+<strong>Output:</strong> false
+</pre><p><strong>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?</div>
\ No newline at end of file
diff --git a/power-of-four/power-of-four.cpp b/power-of-four/power-of-four.cpp
new file mode 100644
index 0000000..ca362fe
--- /dev/null
+++ b/power-of-four/power-of-four.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    bool isPowerOfFour(int n) {
+        if(n == 0)
+            return false;
+        if(n ==1)
+            return true;  
+        if(n%4 == 0)
+        return isPowerOfFour(n/4);
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/power-of-three/README.md b/power-of-three/README.md
new file mode 100644
index 0000000..1efabf6
--- /dev/null
+++ b/power-of-three/README.md
@@ -0,0 +1,27 @@
+<h2>326. Power of Three</h2><h3>Easy</h3><hr><div><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>Example 1:</strong></p>
+<pre><strong>Input:</strong> n = 27
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> n = 0
+<strong>Output:</strong> false
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> n = 9
+<strong>Output:</strong> true
+</pre><p><strong>Example 4:</strong></p>
+<pre><strong>Input:</strong> n = 45
+<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/power-of-three/power-of-three.cpp b/power-of-three/power-of-three.cpp
new file mode 100644
index 0000000..bc89321
--- /dev/null
+++ b/power-of-three/power-of-three.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    bool isPowerOfThree(int n) {
+        
+        if(n==0)
+            return false;
+        if(n==1)
+        {
+            return true;
+        }
+        
+        int x = n/3;
+        
+        if(isPowerOfThree(x) && (x*3 == n))
+            return true;
+        return false;
+        
+    }
+};
\ No newline at end of file
diff --git a/power-of-two/README.md b/power-of-two/README.md
new file mode 100644
index 0000000..58d82a9
--- /dev/null
+++ b/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/power-of-two/power-of-two.cpp b/power-of-two/power-of-two.cpp
new file mode 100644
index 0000000..33edf20
--- /dev/null
+++ b/power-of-two/power-of-two.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    bool isPowerOfTwo(int n) {
+    //    n = abs(n);
+        
+        if(n <= 0)
+            return false;
+        
+        if(n%2 == 0)
+            return isPowerOfTwo(n/2);
+        
+        if(n == 1)
+            return true;
+        
+        return false;
+        
+    }
+};
\ No newline at end of file
diff --git a/powx-n/README.md b/powx-n/README.md
new file mode 100644
index 0000000..6a9e8aa
--- /dev/null
+++ b/powx-n/README.md
@@ -0,0 +1,31 @@
+<h2>50. Pow(x, n)</h2><h3>Medium</h3><hr><div><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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> x = 2.00000, n = 10
+<strong>Output:</strong> 1024.00000
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> x = 2.10000, n = 3
+<strong>Output:</strong> 9.26100
+</pre>
+
+<p><strong>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;&nbsp;x&nbsp;&lt; 100.0</code></li>
+	<li><code>-2<sup>31</sup>&nbsp;&lt;= n &lt;=&nbsp;2<sup>31</sup>-1</code></li>
+	<li><code>-10<sup>4</sup> &lt;= x<sup>n</sup> &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/powx-n/powx-n.cpp b/powx-n/powx-n.cpp
new file mode 100644
index 0000000..f83fe07
--- /dev/null
+++ b/powx-n/powx-n.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    double myPow(double x, int n) {
+        if (n == std::numeric_limits<int>::lowest()) {
+            return myPow(1 / x, -(n + 1)) / x;
+        }
+        if (n < 0) {
+            return myPow(1 / x, -n);
+        }
+    	double ans = 1;
+		while (n) {
+			if (n & 1 == 1) ans *= x;
+			x *= x;
+			n >>= 1;
+		}
+		return ans;
+    }
+};
\ No newline at end of file
diff --git a/product-of-array-except-self/README.md b/product-of-array-except-self/README.md
new file mode 100644
index 0000000..9888518
--- /dev/null
+++ b/product-of-array-except-self/README.md
@@ -0,0 +1,26 @@
+<h2>238. Product of Array Except Self</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/product-of-array-except-self/product-of-array-except-self.cpp b/product-of-array-except-self/product-of-array-except-self.cpp
new file mode 100644
index 0000000..9d31ff7
--- /dev/null
+++ b/product-of-array-except-self/product-of-array-except-self.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    vector<int> productExceptSelf(vector<int>& nums) {
+      vector <int> pre(nums.size());
+       vector <int> post(nums.size());
+      
+      pre[0] = 1;
+      for(int i=1;i<nums.size();i++)
+      {
+        pre[i] = pre[i-1]*nums[i-1];
+      }
+      
+      post[nums.size()-1] = 1;
+      for(int i=nums.size()-2;i>=0;i--)
+      {
+        post[i] = post[i+1]*nums[i+1];
+      }
+      
+      for(int i=0;i<nums.size();i++)
+      {
+        post[i] = post[i]*pre[i];
+      }
+      return post;
+    
+    }
+};
\ No newline at end of file
diff --git a/product-of-the-last-k-numbers/README.md b/product-of-the-last-k-numbers/README.md
new file mode 100644
index 0000000..32091ed
--- /dev/null
+++ b/product-of-the-last-k-numbers/README.md
@@ -0,0 +1,46 @@
+<h2>1352. Product of the Last K Numbers</h2><h3>Medium</h3><hr><div><p>Design an algorithm that accepts a stream of integers and retrieves the product of the last <code>k</code> integers of the stream.</p>
+
+<p>Implement the <code>ProductOfNumbers</code> class:</p>
+
+<ul>
+	<li><code>ProductOfNumbers()</code> Initializes the object with an empty stream.</li>
+	<li><code>void add(int num)</code> Appends the integer <code>num</code> to the stream.</li>
+	<li><code>int getProduct(int k)</code> Returns the product of the last <code>k</code> numbers in the current list. You can assume that always the current list has at least <code>k</code> numbers.</li>
+</ul>
+
+<p>The test cases are generated so that, at any time, the product of any contiguous sequence of numbers will fit into a single 32-bit integer without overflowing.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example:</strong></p>
+
+<pre><strong>Input</strong>
+["ProductOfNumbers","add","add","add","add","add","getProduct","getProduct","getProduct","add","getProduct"]
+[[],[3],[0],[2],[5],[4],[2],[3],[4],[8],[2]]
+
+<strong>Output</strong>
+[null,null,null,null,null,null,20,40,0,null,32]
+
+<strong>Explanation</strong>
+ProductOfNumbers productOfNumbers = new ProductOfNumbers();
+productOfNumbers.add(3);        // [3]
+productOfNumbers.add(0);        // [3,0]
+productOfNumbers.add(2);        // [3,0,2]
+productOfNumbers.add(5);        // [3,0,2,5]
+productOfNumbers.add(4);        // [3,0,2,5,4]
+productOfNumbers.getProduct(2); // return 20. The product of the last 2 numbers is 5 * 4 = 20
+productOfNumbers.getProduct(3); // return 40. The product of the last 3 numbers is 2 * 5 * 4 = 40
+productOfNumbers.getProduct(4); // return 0. The product of the last 4 numbers is 0 * 2 * 5 * 4 = 0
+productOfNumbers.add(8);        // [3,0,2,5,4,8]
+productOfNumbers.getProduct(2); // return 32. The product of the last 2 numbers is 4 * 8 = 32 
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= num &lt;= 100</code></li>
+	<li><code>1 &lt;= k &lt;= 4 * 10<sup>4</sup></code></li>
+	<li>At most <code>4 * 10<sup>4</sup></code> calls will be made to <code>add</code> and <code>getProduct</code>.</li>
+	<li>The product of the stream at any point in time will fit in a <strong>32-bit</strong> integer.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/push-dominoes/README.md b/push-dominoes/README.md
new file mode 100644
index 0000000..f083055
--- /dev/null
+++ b/push-dominoes/README.md
@@ -0,0 +1,41 @@
+<h2>838. Push Dominoes</h2><h3>Medium</h3><hr><div><p>There are <code>n</code> dominoes in a line, and we place each domino vertically upright. In the beginning, we simultaneously push some of the dominoes either to the left or to the right.</p>
+
+<p>After each second, each domino that is falling to the left pushes the adjacent domino on the left. Similarly, the dominoes falling to the right push their adjacent dominoes standing on the right.</p>
+
+<p>When a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces.</p>
+
+<p>For the purposes of this question, we will consider that a falling domino expends no additional force to a falling or already fallen domino.</p>
+
+<p>You are given a string <code>dominoes</code> representing the initial state where:</p>
+
+<ul>
+	<li><code>dominoes[i] = 'L'</code>, if the <code>i<sup>th</sup></code> domino has been pushed to the left,</li>
+	<li><code>dominoes[i] = 'R'</code>, if the <code>i<sup>th</sup></code> domino has been pushed to the right, and</li>
+	<li><code>dominoes[i] = '.'</code>, if the <code>i<sup>th</sup></code> domino has not been pushed.</li>
+</ul>
+
+<p>Return <em>a string representing the final state</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> dominoes = "RR.L"
+<strong>Output:</strong> "RR.L"
+<strong>Explanation:</strong> The first domino expends no additional force on the second domino.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://s3-lc-upload.s3.amazonaws.com/uploads/2018/05/18/domino.png" style="height: 196px; width: 512px;">
+<pre><strong>Input:</strong> dominoes = ".L.R...LR..L.."
+<strong>Output:</strong> "LL.RR.LLRRLL.."
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == dominoes.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>dominoes[i]</code> is either <code>'L'</code>, <code>'R'</code>, or <code>'.'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/push-dominoes/push-dominoes.cpp b/push-dominoes/push-dominoes.cpp
new file mode 100644
index 0000000..1659bfe
--- /dev/null
+++ b/push-dominoes/push-dominoes.cpp
@@ -0,0 +1,37 @@
+class Solution {
+public:
+    string pushDominoes(string dominoes) {
+        int n = dominoes.size();
+        vector<int> left_r_dis(n + 1, 0);
+        vector<int> right_l_dis(n + 1, 0);
+        int r_pos = n + 1;
+        for (int i = 0; i < n; ++i) {
+            if (dominoes[i] == 'R') {
+                r_pos = i;
+            }
+            else if (dominoes[i] == 'L') {
+                r_pos = n + 1;
+            }
+            left_r_dis[i] = r_pos == n + 1 ? n + 1 : i - r_pos;
+        }
+        int l_pos = -1;
+        for (int i = n - 1; i >= 0; --i) {
+            if (dominoes[i] == 'L') {
+                l_pos = i;
+            }
+            else if (dominoes[i] == 'R') {
+                l_pos = -1;
+            }
+            right_l_dis[i] = l_pos == -1 ? n + 1 : l_pos - i;
+        }
+        
+        string result = dominoes;
+        for (int i = 0; i < n; ++i) {
+            if (left_r_dis[i] < right_l_dis[i]) result[i] = 'R';
+            else if (left_r_dis[i] > right_l_dis[i]) result[i] = 'L';
+            //else
+        }
+
+        return result;
+    } 
+};
\ No newline at end of file
diff --git a/range-addition-ii/README.md b/range-addition-ii/README.md
new file mode 100644
index 0000000..399a67f
--- /dev/null
+++ b/range-addition-ii/README.md
@@ -0,0 +1,35 @@
+<h2>598. Range Addition II</h2><h3>Easy</h3><hr><div><p>You are given an <code>m x n</code> matrix <code>M</code> initialized with all <code>0</code>'s and an array of operations <code>ops</code>, where <code>ops[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> means <code>M[x][y]</code> should be incremented by one for all <code>0 &lt;= x &lt; a<sub>i</sub></code> and <code>0 &lt;= y &lt; b<sub>i</sub></code>.</p>
+
+<p>Count and return <em>the number of maximum integers in the matrix after performing all the operations</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/02/ex1.jpg" style="width: 750px; height: 176px;">
+<pre><strong>Input:</strong> m = 3, n = 3, ops = [[2,2],[3,3]]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The maximum integer in M is 2, and there are four of it in M. So return 4.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> m = 3, n = 3, ops = [[2,2],[3,3],[3,3],[3,3],[2,2],[3,3],[3,3],[3,3],[2,2],[3,3],[3,3],[3,3]]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> m = 3, n = 3, ops = []
+<strong>Output:</strong> 9
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= m, n &lt;= 4 * 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= ops.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>ops[i].length == 2</code></li>
+	<li><code>1 &lt;= a<sub>i</sub> &lt;= m</code></li>
+	<li><code>1 &lt;= b<sub>i</sub> &lt;= n</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/range-addition-ii/range-addition-ii.cpp b/range-addition-ii/range-addition-ii.cpp
new file mode 100644
index 0000000..fc9b53d
--- /dev/null
+++ b/range-addition-ii/range-addition-ii.cpp
@@ -0,0 +1,10 @@
+class Solution {
+public:
+    int maxCount(int m, int n, vector<vector<int>>& ops) {
+        for (int i = 0; i < ops.size(); ++i) {
+            m = min(m, ops[i][0]);
+            n = min(n, ops[i][1]);
+        }
+        return m*n;
+    }
+};
\ No newline at end of file
diff --git a/range-sum-of-bst/README.md b/range-sum-of-bst/README.md
new file mode 100644
index 0000000..2436e88
--- /dev/null
+++ b/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/range-sum-of-bst/range-sum-of-bst.cpp b/range-sum-of-bst/range-sum-of-bst.cpp
new file mode 100644
index 0000000..43d7b48
--- /dev/null
+++ b/range-sum-of-bst/range-sum-of-bst.cpp
@@ -0,0 +1,32 @@
+/**
+ * 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:
+    int rangeSumBST(TreeNode* root, int low, int high) {
+        int sum = 0;
+        if(root == NULL)
+          return sum;
+      
+      if(root->val < low)
+      {
+        return rangeSumBST(root->right,low,high);
+      }
+      
+      if(root->val > high)
+      {
+         return rangeSumBST(root->left,low,high);
+      }
+      sum += root->val;
+      return sum +rangeSumBST(root->left,low,high)+ rangeSumBST(root->right,low,high);
+        
+    }
+};
\ No newline at end of file
diff --git a/range-sum-query-2d-immutable/README.md b/range-sum-query-2d-immutable/README.md
new file mode 100644
index 0000000..730e5cf
--- /dev/null
+++ b/range-sum-query-2d-immutable/README.md
@@ -0,0 +1,42 @@
+<h2>304. Range Sum Query 2D - Immutable</h2><h3>Medium</h3><hr><div><p>Given a 2D matrix <code>matrix</code>, handle multiple queries of the following type:</p>
+
+<ul>
+	<li>Calculate the <strong>sum</strong> of the elements of <code>matrix</code> inside the rectangle defined by its <strong>upper left corner</strong> <code>(row1, col1)</code> and <strong>lower right corner</strong> <code>(row2, col2)</code>.</li>
+</ul>
+
+<p>Implement the NumMatrix class:</p>
+
+<ul>
+	<li><code>NumMatrix(int[][] matrix)</code> Initializes the object with the integer matrix <code>matrix</code>.</li>
+	<li><code>int sumRegion(int row1, int col1, int row2, int col2)</code> Returns the <strong>sum</strong> of the elements of <code>matrix</code> inside the rectangle defined by its <strong>upper left corner</strong> <code>(row1, col1)</code> and <strong>lower right corner</strong> <code>(row2, col2)</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/14/sum-grid.jpg" style="width: 415px; height: 415px;">
+<pre><strong>Input</strong>
+["NumMatrix", "sumRegion", "sumRegion", "sumRegion"]
+[[[[3, 0, 1, 4, 2], [5, 6, 3, 2, 1], [1, 2, 0, 1, 5], [4, 1, 0, 1, 7], [1, 0, 3, 0, 5]]], [2, 1, 4, 3], [1, 1, 2, 2], [1, 2, 2, 4]]
+<strong>Output</strong>
+[null, 8, 11, 12]
+
+<strong>Explanation</strong>
+NumMatrix numMatrix = new NumMatrix([[3, 0, 1, 4, 2], [5, 6, 3, 2, 1], [1, 2, 0, 1, 5], [4, 1, 0, 1, 7], [1, 0, 3, 0, 5]]);
+numMatrix.sumRegion(2, 1, 4, 3); // return 8 (i.e sum of the red rectangle)
+numMatrix.sumRegion(1, 1, 2, 2); // return 11 (i.e sum of the green rectangle)
+numMatrix.sumRegion(1, 2, 2, 4); // return 12 (i.e sum of the blue rectangle)
+</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;= 200</code></li>
+	<li><code>-10<sup>5</sup> &lt;= matrix[i][j] &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= row1 &lt;= row2 &lt; m</code></li>
+	<li><code>0 &lt;= col1 &lt;= col2 &lt; n</code></li>
+	<li>At most <code>10<sup>4</sup></code> calls will be made to <code>sumRegion</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/range-sum-query-2d-immutable/range-sum-query-2d-immutable.cpp b/range-sum-query-2d-immutable/range-sum-query-2d-immutable.cpp
new file mode 100644
index 0000000..dced07f
--- /dev/null
+++ b/range-sum-query-2d-immutable/range-sum-query-2d-immutable.cpp
@@ -0,0 +1,26 @@
+class NumMatrix {private:
+    int row, col;
+    vector<vector<int>> sums;
+public:
+    NumMatrix(vector<vector<int>> &matrix) {
+        row = matrix.size();
+        col = row>0 ? matrix[0].size() : 0;
+        sums = vector<vector<int>>(row+1, vector<int>(col+1, 0));
+        for(int i=1; i<=row; i++) {
+            for(int j=1; j<=col; j++) {
+                sums[i][j] = matrix[i-1][j-1] + 
+                             sums[i-1][j] + sums[i][j-1] - sums[i-1][j-1] ;
+            }
+        }
+    }
+
+    int sumRegion(int row1, int col1, int row2, int col2) {
+        return sums[row2+1][col2+1] - sums[row2+1][col1] - sums[row1][col2+1] + sums[row1][col1];
+    }
+};
+
+/**
+ * Your NumMatrix object will be instantiated and called as such:
+ * NumMatrix* obj = new NumMatrix(matrix);
+ * int param_1 = obj->sumRegion(row1,col1,row2,col2);
+ */
\ No newline at end of file
diff --git a/range-sum-query-immutable/README.md b/range-sum-query-immutable/README.md
new file mode 100644
index 0000000..c3d6a3a
--- /dev/null
+++ b/range-sum-query-immutable/README.md
@@ -0,0 +1,39 @@
+<h2>303. Range Sum Query - Immutable</h2><h3>Easy</h3><hr><div><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>Example 1:</strong></p>
+
+<pre><strong>Input</strong>
+["NumArray", "sumRange", "sumRange", "sumRange"]
+[[[-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>
+</div>
\ No newline at end of file
diff --git a/rank-transform-of-a-matrix/README.md b/rank-transform-of-a-matrix/README.md
new file mode 100644
index 0000000..516f9e9
--- /dev/null
+++ b/rank-transform-of-a-matrix/README.md
@@ -0,0 +1,58 @@
+<h2>1632. Rank Transform of a Matrix</h2><h3>Hard</h3><hr><div><p>Given an <code>m x n</code> <code>matrix</code>, return <em>a new matrix </em><code>answer</code><em> where </em><code>answer[row][col]</code><em> is the </em><em><strong>rank</strong> of </em><code>matrix[row][col]</code>.</p>
+
+<p>The <strong>rank</strong> is an <strong>integer</strong> that represents how large an element is compared to other elements. It is calculated using the following rules:</p>
+
+<ul>
+	<li>The rank is an integer starting from <code>1</code>.</li>
+	<li>If two elements <code>p</code> and <code>q</code> are in the <strong>same row or column</strong>, then:
+	<ul>
+		<li>If <code>p &lt; q</code> then <code>rank(p) &lt; rank(q)</code></li>
+		<li>If <code>p == q</code> then <code>rank(p) == rank(q)</code></li>
+		<li>If <code>p &gt; q</code> then <code>rank(p) &gt; rank(q)</code></li>
+	</ul>
+	</li>
+	<li>The <strong>rank</strong> should be as <strong>small</strong> as possible.</li>
+</ul>
+
+<p>It is guaranteed that <code>answer</code> is unique under the given rules.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/18/rank1.jpg" style="width: 442px; height: 162px;">
+<pre><strong>Input:</strong> matrix = [[1,2],[3,4]]
+<strong>Output:</strong> [[1,2],[2,3]]
+<strong>Explanation:</strong>
+The rank of matrix[0][0] is 1 because it is the smallest integer in its row and column.
+The rank of matrix[0][1] is 2 because matrix[0][1] &gt; matrix[0][0] and matrix[0][0] is rank 1.
+The rank of matrix[1][0] is 2 because matrix[1][0] &gt; matrix[0][0] and matrix[0][0] is rank 1.
+The rank of matrix[1][1] is 3 because matrix[1][1] &gt; matrix[0][1], matrix[1][1] &gt; matrix[1][0], and both matrix[0][1] and matrix[1][0] are rank 2.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/18/rank2.jpg" style="width: 442px; height: 162px;">
+<pre><strong>Input:</strong> matrix = [[7,7],[7,7]]
+<strong>Output:</strong> [[1,1],[1,1]]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/18/rank3.jpg" style="width: 601px; height: 322px;">
+<pre><strong>Input:</strong> matrix = [[20,-21,14],[-19,4,19],[22,-47,24],[-19,4,19]]
+<strong>Output:</strong> [[4,2,3],[1,3,4],[5,1,6],[1,3,4]]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/18/rank4.jpg" style="width: 601px; height: 242px;">
+<pre><strong>Input:</strong> matrix = [[7,3,6],[1,4,5],[9,8,2]]
+<strong>Output:</strong> [[5,1,4],[1,2,3],[6,3,1]]
+</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;= 500</code></li>
+	<li><code>-10<sup>9</sup> &lt;= matrix[row][col] &lt;= 10<sup>9</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/rank-transform-of-a-matrix/rank-transform-of-a-matrix.cpp b/rank-transform-of-a-matrix/rank-transform-of-a-matrix.cpp
new file mode 100644
index 0000000..c46d4d5
--- /dev/null
+++ b/rank-transform-of-a-matrix/rank-transform-of-a-matrix.cpp
@@ -0,0 +1,124 @@
+class Solution {
+public:
+    
+#define lop(i,s,e)                                  for(int i=s;i<(int)e;i++)
+#define pii                                         pair<int,int>
+#define ff                                          first
+#define ss                                          second
+
+    pii par[501][501];                          // par[i][j] -> parent of cell {i, j}
+    int sz[501][501];                           // sz[i][j] -> size of set whose leader/parent is {i, j}
+    
+    // DSU IMPLEMENTATION below
+    // void build(int n, int m);               // Initialising DSU
+    // pii find(pii a) ;                      // Finding leader/parent of cell {i, j}
+    // void make_union(pii a, pii b);        // Uniting 2 cells 
+    
+     vector<vector<int>> matrixRankTransform(vector<vector<int>>& mat) {
+        int n = mat.size(), m = mat[0].size();
+        vector < vector<int> > ans(n, vector<int> (m, -1) );
+        
+        // Initialising DSU
+        build(n, m);
+        
+        // Uniting All cells with rank value in same row
+        lop(i, 0, n){
+            map<int, pii> mp;
+            lop(j, 0, m){
+                int val = mat[i][j];
+                if( mp.count( val ) ) make_union( {i,j} , mp[val]);
+                mp[val] = {i, j};
+            }
+        }
+        
+        // Uniting all cells with rank value in same column
+        lop(j, 0, m){
+            map<int, pii> mp;
+            lop(i, 0, n){
+                int val = mat[i][j];
+                if( mp.count( val ) ) make_union( {i,j} , mp[val]);
+                mp[val] = {i, j};
+            }
+        }
+        
+        
+        // Keeping cells with same rank in a vector of their parent/leader
+        vector<pii> all[n][m];
+        lop(i, 0, n)lop(j, 0, m){
+            pii x = {i, j};
+            pii p = find(x);
+            all[p.ff][p.ss].push_back( x );
+        }
+        
+        // Storing vectors in a map  with their parent value as key
+        map<int, vector< vector<pii> > > mp;
+        lop(i, 0, n){
+            lop(j,0,m){
+                if( (int)all[i][j].size() == 0 ) continue;
+                int val = mat[i][j];
+                mp[ val ].push_back( all[i][j] );
+            }
+        }
+        vector<int> row(n, 0), col(m, 0);
+         
+        // row[i] = largest rank till now in ith row
+        // col[i] = largest rank till now in ith column
+         
+
+        for(auto &i: mp){   // first assigning ranks to smaller elements then larger elements
+            
+            for(auto &j: i.ss){ 
+                
+                // x -> answer for current vector of cells ( all these cells will get the same rank )
+                int x = 0;
+                
+                for(auto &k: j){
+                    int r = k.ff, c = k.ss;         // {r,c} -> current cell
+                    
+                    // ans should be >= max(row[r], row[c]) + 1 ,
+                    // because largest rank of smaller elements in this row/column is == max(row[r], row[c])
+                    
+                    x = max(x,  max(row[r], col[c]) + 1 );
+                }
+                
+                for(auto &k: j){
+                    int r = k.ff, c = k.ss;
+                    ans[r][c] = x;
+                   
+                    // Updating largest rank in row and column for the current row and column
+                    row[r] = max(row[r], x);
+                    col[c] = max(col[c], x);
+                }
+            }
+        }
+
+        return ans;
+    }
+    
+    /// DSU IMPLEMENTATION
+    void build(int n, int m) {
+        for(int i = 0; i < n; i++){
+            for(int j = 0; j < m; j++){
+                par[i][j] = {i, j};
+                sz[i][j] = 1;
+            }
+        }
+    }
+
+    pii find(pii a) {                   // finding leader/parent of cell {i, j}
+        if( par[a.ff][a.ss] == a) return a;
+        return par[a.ff][a.ss] = find( par[a.ff][a.ss] );
+    }
+
+    void make_union(pii a, pii b) {         // Uniting 2 cells 
+        pii pa = find(a), pb = find(b);
+
+        if( pa != pb ) {
+            if( sz[pa.ff][pa.ss] < sz[pb.ff][pb.ss] ) swap(pa,pb);
+            par[pb.ff][pb.ss] = pa;
+            sz[pa.ff][pb.ss] += sz[pb.ff][pb.ss];
+        }
+    }
+
+    
+};
diff --git a/remove-boxes/README.md b/remove-boxes/README.md
new file mode 100644
index 0000000..a67bcb5
--- /dev/null
+++ b/remove-boxes/README.md
@@ -0,0 +1,39 @@
+<h2>546. Remove Boxes</h2><h3>Hard</h3><hr><div><p>You are given several <code>boxes</code> with different colors represented by different positive numbers.</p>
+
+<p>You may experience several rounds to remove boxes until there is no box left. Each time you can choose some continuous boxes with the same color (i.e., composed of <code>k</code> boxes, <code>k &gt;= 1</code>), remove them and get <code>k * k</code> points.</p>
+
+<p>Return <em>the maximum points you can get</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> boxes = [1,3,2,2,2,3,4,3,1]
+<strong>Output:</strong> 23
+<strong>Explanation:</strong>
+[1, 3, 2, 2, 2, 3, 4, 3, 1] 
+----&gt; [1, 3, 3, 4, 3, 1] (3*3=9 points) 
+----&gt; [1, 3, 3, 3, 1] (1*1=1 points) 
+----&gt; [1, 1] (3*3=9 points) 
+----&gt; [] (2*2=4 points)
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> boxes = [1,1,1]
+<strong>Output:</strong> 9
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> boxes = [1]
+<strong>Output:</strong> 1
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= boxes.length &lt;= 100</code></li>
+	<li><code>1 &lt;= boxes[i]&nbsp;&lt;= 100</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/remove-duplicates-from-sorted-array/README.md b/remove-duplicates-from-sorted-array/README.md
new file mode 100644
index 0000000..d170b12
--- /dev/null
+++ b/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/remove-duplicates-from-sorted-array/remove-duplicates-from-sorted-array.cpp b/remove-duplicates-from-sorted-array/remove-duplicates-from-sorted-array.cpp
new file mode 100644
index 0000000..0ea5bda
--- /dev/null
+++ b/remove-duplicates-from-sorted-array/remove-duplicates-from-sorted-array.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        
+        if(nums.size()<=1)
+            return nums.size();
+        int low = 0;
+        int high = 0;
+        
+        while(high<nums.size())
+        {
+            if(nums[low] == nums[high])
+            {
+                high++;
+            }
+            else
+            {
+                low++;
+                nums[low] = nums[high];
+                high++;
+            }
+        }
+        return low+1;
+        
+    }
+};
\ No newline at end of file
diff --git a/remove-linked-list-elements/README.md b/remove-linked-list-elements/README.md
new file mode 100644
index 0000000..3bfd36e
--- /dev/null
+++ b/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/remove-linked-list-elements/remove-linked-list-elements.cpp b/remove-linked-list-elements/remove-linked-list-elements.cpp
new file mode 100644
index 0000000..35c7339
--- /dev/null
+++ b/remove-linked-list-elements/remove-linked-list-elements.cpp
@@ -0,0 +1,38 @@
+/**
+ * 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* removeElements(ListNode* head, int val) {
+        if(head  == NULL)return NULL;
+      
+      ListNode * temp = new ListNode(-1);
+      temp->next = head;
+      
+      ListNode * ans = temp;
+      
+      while(temp->next != NULL)
+      {
+        if(temp->next->val == val)
+        {
+          ListNode * del = temp->next;
+          temp->next = temp->next->next;
+          del->next = NULL;
+          delete del;
+        }
+        else
+        {
+          temp = temp->next;
+        }
+      }
+      
+      return ans->next;
+    }
+};
\ No newline at end of file
diff --git a/remove-nth-node-from-end-of-list/README.md b/remove-nth-node-from-end-of-list/README.md
new file mode 100644
index 0000000..8f0abb0
--- /dev/null
+++ b/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/remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.cpp b/remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.cpp
new file mode 100644
index 0000000..01f797f
--- /dev/null
+++ b/remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.cpp
@@ -0,0 +1,39 @@
+/**
+ * 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* removeNthFromEnd(ListNode* head, int n) {
+      
+        ListNode *dummy = new ListNode();
+        dummy->next = head;
+        
+        ListNode * slow = dummy;
+        ListNode * fast = dummy;
+        
+        while(n--)
+        {
+            fast = fast->next;
+        }
+        
+        while(fast ->next != NULL)
+        {
+            fast = fast->next;
+            slow = slow->next;
+        }
+        
+        ListNode * node = slow->next;
+        slow->next = slow->next->next;
+        delete node;
+        
+        return dummy->next;
+        
+    }
+};
\ No newline at end of file
diff --git a/reorder-list/README.md b/reorder-list/README.md
new file mode 100644
index 0000000..3ee80eb
--- /dev/null
+++ b/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/reverse-linked-list/README.md b/reverse-linked-list/README.md
new file mode 100644
index 0000000..243642c
--- /dev/null
+++ b/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/reverse-linked-list/reverse-linked-list.cpp b/reverse-linked-list/reverse-linked-list.cpp
new file mode 100644
index 0000000..1ce85ef
--- /dev/null
+++ b/reverse-linked-list/reverse-linked-list.cpp
@@ -0,0 +1,22 @@
+/**
+ * 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* reverseList(ListNode* head) {
+        if(head == NULL || head->next == NULL)
+            return head;
+        ListNode * nextp = head->next;
+        ListNode * reversed = reverseList(head->next);
+        nextp->next = head;
+        head->next = NULL;
+        return reversed;
+    }
+};
\ No newline at end of file
diff --git a/reverse-nodes-in-k-group/README.md b/reverse-nodes-in-k-group/README.md
new file mode 100644
index 0000000..bb3fa90
--- /dev/null
+++ b/reverse-nodes-in-k-group/README.md
@@ -0,0 +1,43 @@
+<h2>25. Reverse Nodes in k-Group</h2><h3>Hard</h3><hr><div><p>Given a linked list, reverse the nodes of a linked list <em>k</em> at a time and return its modified list.</p>
+
+<p><em>k</em> 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 <em>k</em> then left-out nodes, in the end, should remain as it is.</p>
+
+<p>You may&nbsp;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><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> head = [1,2,3,4,5], k = 1
+<strong>Output:</strong> [1,2,3,4,5]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> head = [1], k = 1
+<strong>Output:</strong> [1]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the list&nbsp;is in the range <code>sz</code>.</li>
+	<li><code>1 &lt;= sz &lt;= 5000</code></li>
+	<li><code>0 &lt;= Node.val &lt;= 1000</code></li>
+	<li><code>1 &lt;= k &lt;= sz</code></li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow-up:</strong> Can you solve the problem in O(1) extra memory space?</div>
\ No newline at end of file
diff --git a/reverse-nodes-in-k-group/reverse-nodes-in-k-group.cpp b/reverse-nodes-in-k-group/reverse-nodes-in-k-group.cpp
new file mode 100644
index 0000000..823a177
--- /dev/null
+++ b/reverse-nodes-in-k-group/reverse-nodes-in-k-group.cpp
@@ -0,0 +1,25 @@
+class Solution {
+public:
+    ListNode *reverseKGroup(ListNode *head, int k) {
+        if(head==NULL||k==1) return head;
+        int num=0;
+        ListNode *preheader = new ListNode(-1);
+        preheader->next = head;
+        ListNode *cur = preheader, *nex, *pre = preheader;
+        while(cur = cur->next) 
+            num++;
+        while(num>=k) {
+            cur = pre->next;
+            nex = cur->next;
+            for(int i=1;i<k;++i) {
+                cur->next=nex->next;
+                nex->next=pre->next;
+                pre->next=nex;
+                nex=cur->next;
+            }
+            pre = cur;
+            num-=k;
+        }
+        return preheader->next;
+    }
+};
\ No newline at end of file
diff --git a/reverse-pairs/README.md b/reverse-pairs/README.md
new file mode 100644
index 0000000..27f6743
--- /dev/null
+++ b/reverse-pairs/README.md
@@ -0,0 +1,20 @@
+<h2>493. Reverse Pairs</h2><h3>Hard</h3><hr><div><p>Given an integer array <code>nums</code>, return <em>the number of <strong>reverse pairs</strong> in the array</em>.</p>
+
+<p>A reverse pair is a pair <code>(i, j)</code> where <code>0 &lt;= i &lt; j &lt; nums.length</code> and <code>nums[i] &gt; 2 * nums[j]</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> nums = [1,3,2,3,1]
+<strong>Output:</strong> 2
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> nums = [2,4,3,5,1]
+<strong>Output:</strong> 3
+</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>-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/reverse-pairs/reverse-pairs.cpp b/reverse-pairs/reverse-pairs.cpp
new file mode 100644
index 0000000..36e5f2b
--- /dev/null
+++ b/reverse-pairs/reverse-pairs.cpp
@@ -0,0 +1,130 @@
+class Solution {
+public:
+  int merge(vector<int>& nums,int start,int mid,int end)
+  {
+    int j = mid+1;
+    int count = 0;
+    for(int i = start;i<=mid;i++ )
+    {
+       while(j<=end && nums[i] > 2LL * nums[j] )
+       {
+         j++;
+       }
+      count += (j-(mid+1));
+    }
+   
+    vector<int> temp;
+    int i = start;
+    j = mid+1;
+    int k = 0;
+    while(i<= mid && j<= end)
+    {
+      if(nums[i]>=nums[j])
+        temp.push_back(nums[j++]);
+      else
+        temp.push_back(nums[i++]);
+    }
+    
+    while(i<=mid)
+       temp.push_back(nums[i++]);
+    while(j<=end)
+      temp.push_back(nums[j++]);
+    
+    for(int y =start;y<=end;y++)
+      nums[y] = temp[y-start];
+    
+    return count;
+    
+  }
+  
+  int merge_sort(vector<int>& nums,int start,int end)
+  {
+    if(start>=end)
+      return 0;
+      int pairs = 0;
+      int mid = (start + end)/2;
+      pairs+=merge_sort(nums,start,mid);
+      pairs+=merge_sort(nums,mid+1,end);
+      
+      pairs+=merge(nums,start,mid,end);
+    return pairs;
+  }
+  
+    int reversePairs(vector<int>& nums) {
+        return merge_sort(nums,0,nums.size()-1);
+    }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// class Solution {
+// public:
+//     int merge(vector<int> &nums, int l, int m, int h) {
+//         int count=0;
+//         int j=m+1;
+//         for(int i=l;i<=m;++i) {
+//             while(j<=h && nums[i] > 2LL*nums[j]) ++j;
+//             count += (j - (m+1));
+//         }
+//         // merge of two sorted array
+//         vector<int> temp;
+//         int left=l,right=m+1;
+//         // loop till on of them execuested
+//         while(left<=m && right<=h) {
+//             if(nums[left]<=nums[right]) temp.push_back(nums[left++]);
+//             else temp.push_back(nums[right++]);
+//         }
+//         // remaining elements of left side
+//         while(left<=m) temp.push_back(nums[left++]);
+//         // remaining elements of right side
+//         while(right<=h) temp.push_back(nums[right++]);
+//         // assingn in main vector after merging
+//         for(int i=l;i<=h;++i) {
+//             nums[i]=temp[i-l];
+//         }
+//         return count;
+//     }
+//     int mergeSort(vector<int> &nums, int l, int h) {
+//         if(l>=h) return 0; // A single element does not contain any pair 
+//         int m=(l+h)/2;
+//         int count=0;
+//         count += mergeSort(nums,l,m);    // count from left side of vector
+//         count += mergeSort(nums,m+1,h);  // count from right side of vector
+//         count += merge(nums,l,m,h);      // count merge 
+//         return count;
+//     }
+//     int reversePairs(vector<int>& nums) {
+//         return mergeSort(nums, 0, nums.size()-1);
+//     }
+// };
\ No newline at end of file
diff --git a/reverse-words-in-a-string-iii/README.md b/reverse-words-in-a-string-iii/README.md
new file mode 100644
index 0000000..d60372a
--- /dev/null
+++ b/reverse-words-in-a-string-iii/README.md
@@ -0,0 +1,21 @@
+<h2>557. Reverse Words in a String III</h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code>, reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> s = "Let's take LeetCode contest"
+<strong>Output:</strong> "s'teL ekat edoCteeL tsetnoc"
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> s = "God Ding"
+<strong>Output:</strong> "doG gniD"
+</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>s</code> contains printable <strong>ASCII</strong> characters.</li>
+	<li><code>s</code> does not contain any leading or trailing spaces.</li>
+	<li>There is <strong>at least one</strong> word in <code>s</code>.</li>
+	<li>All the words in <code>s</code> are separated by a single space.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/robot-return-to-origin/README.md b/robot-return-to-origin/README.md
new file mode 100644
index 0000000..177e74d
--- /dev/null
+++ b/robot-return-to-origin/README.md
@@ -0,0 +1,41 @@
+<h2>657. Robot Return to Origin</h2><h3>Easy</h3><hr><div><p>There is a robot starting at position (0, 0), the origin, on a 2D plane. Given a sequence of its moves, judge if this robot <strong>ends up at (0, 0)</strong> after it completes its moves.</p>
+
+<p>The move sequence is represented by a string, and the character moves[i] represents its ith move. Valid moves are R (right), L (left), U (up), and D (down). If the robot returns to the origin after it finishes all of its moves, return true. Otherwise, return false.</p>
+
+<p><strong>Note</strong>: The way that the robot is "facing" is irrelevant. "R" will always make the robot move to the right once, "L" will always make it move left, etc. Also, assume that the magnitude of the robot's movement is the same for each move.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> moves = "UD"
+<strong>Output:</strong> true
+<strong>Explanation</strong>: The robot moves up once, and then down once. All moves have the same magnitude, so it ended up at the origin where it started. Therefore, we return true.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> moves = "LL"
+<strong>Output:</strong> false
+<strong>Explanation</strong>: The robot moves left twice. It ends up two "moves" to the left of the origin. We return false because it is not at the origin at the end of its moves.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> moves = "RRDD"
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> moves = "LDRRLRUULR"
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= moves.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>moves</code> only contains the characters <code>'U'</code>, <code>'D'</code>, <code>'L'</code> and <code>'R'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/robot-return-to-origin/robot-return-to-origin.cpp b/robot-return-to-origin/robot-return-to-origin.cpp
new file mode 100644
index 0000000..7530b1a
--- /dev/null
+++ b/robot-return-to-origin/robot-return-to-origin.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    bool judgeCircle(string moves) {
+        int v = 0;
+        int h = 0;
+        for (char ch : moves) {
+            switch (ch) {
+                case 'U' : v++; break;
+                case 'D' : v--; break;
+                case 'R' : h++; break;
+                case 'L' : h--; break;
+            }
+        }
+        return v == 0 && h == 0;
+    }
+};
\ No newline at end of file
diff --git a/roman-to-integer/README.md b/roman-to-integer/README.md
new file mode 100644
index 0000000..1c6e097
--- /dev/null
+++ b/roman-to-integer/README.md
@@ -0,0 +1,65 @@
+<h2>13. Roman to Integer</h2><h3>Easy</h3><hr><div><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 one's 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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "III"
+<strong>Output:</strong> 3
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "IV"
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "IX"
+<strong>Output:</strong> 9
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> s = "LVIII"
+<strong>Output:</strong> 58
+<strong>Explanation:</strong> L = 50, V= 5, III = 3.
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> s = "MCMXCIV"
+<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>('I', 'V', 'X', 'L', 'C', 'D', 'M')</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>
+</div>
\ No newline at end of file
diff --git a/roman-to-integer/roman-to-integer.cpp b/roman-to-integer/roman-to-integer.cpp
new file mode 100644
index 0000000..e982b04
--- /dev/null
+++ b/roman-to-integer/roman-to-integer.cpp
@@ -0,0 +1,28 @@
+class Solution {
+public:
+int romanToInt(string s) 
+{
+    unordered_map<char, int> T = { { 'I' , 1 },
+                                   { 'V' , 5 },
+                                   { 'X' , 10 },
+                                   { 'L' , 50 },
+                                   { 'C' , 100 },
+                                   { 'D' , 500 },
+                                   { 'M' , 1000 } };
+                                   
+   int sum = T[s.back()];
+   for (int i = s.length() - 2; i >= 0; --i) 
+   {
+       if (T[s[i]] < T[s[i + 1]])
+       {
+           sum -= T[s[i]];
+       }
+       else
+       {
+           sum += T[s[i]];
+       }
+   }
+   
+   return sum;
+}
+};
\ No newline at end of file
diff --git a/rotate-array/README.md b/rotate-array/README.md
new file mode 100644
index 0000000..49cca61
--- /dev/null
+++ b/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/rotate-array/rotate-array.cpp b/rotate-array/rotate-array.cpp
new file mode 100644
index 0000000..9230e79
--- /dev/null
+++ b/rotate-array/rotate-array.cpp
@@ -0,0 +1,13 @@
+class Solution {
+public:
+    void rotate(vector<int>& nums, int k) {
+        
+        if(k>nums.size())
+            k = k % nums.size();
+        
+        reverse(nums.begin(),nums.begin()+(nums.size()-k));
+        reverse(nums.begin()+(nums.size()-k),nums.end());
+        reverse(nums.begin(),nums.end());
+        
+    }
+};
\ No newline at end of file
diff --git a/rotate-image/README.md b/rotate-image/README.md
new file mode 100644
index 0000000..74239c2
--- /dev/null
+++ b/rotate-image/README.md
@@ -0,0 +1,39 @@
+<h2>48. Rotate Image</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: 642px; height: 242px;">
+<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: 800px; height: 321px;">
+<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><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [[1]]
+<strong>Output:</strong> [[1]]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> matrix = [[1,2],[3,4]]
+<strong>Output:</strong> [[3,1],[4,2]]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>matrix.length == n</code></li>
+	<li><code>matrix[i].length == n</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/rotate-image/rotate-image.cpp b/rotate-image/rotate-image.cpp
new file mode 100644
index 0000000..8351400
--- /dev/null
+++ b/rotate-image/rotate-image.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    void rotate(vector<vector<int>>& matrix) {
+        
+      int m = matrix.size();
+      int n = matrix[0].size();
+      
+      // Doing Transpose of the matrix
+      
+      for(int i=0;i<m;i++)
+      {
+        for(int j=0;j<i;j++)
+        {
+          swap(matrix[i][j],matrix[j][i]);
+        }
+      }
+      
+      // reversing every row
+      
+      for(int i=0;i<m;i++)
+      {
+        reverse(matrix[i].begin(),matrix[i].end());
+      }
+      
+    }
+};
\ No newline at end of file
diff --git a/rotate-list/README.md b/rotate-list/README.md
new file mode 100644
index 0000000..fab98cf
--- /dev/null
+++ b/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/rotate-list/rotate-list.cpp b/rotate-list/rotate-list.cpp
new file mode 100644
index 0000000..4ef4d77
--- /dev/null
+++ b/rotate-list/rotate-list.cpp
@@ -0,0 +1,53 @@
+/**
+ * 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* rotateRight(ListNode* head, int k) {
+     
+        if(k == 0 || head == NULL || head->next == NULL)
+            return head;
+        
+        int count = 0;
+        ListNode * temp = head;
+        while(temp != NULL)
+        {
+            temp = temp->next;
+            count++;
+        }
+        
+        
+        k = k % count;
+        if(k==0)return head;
+        
+       // cout<<k<<endl;
+        ListNode * fast = head;
+        ListNode * slow = head;
+        
+        while(k!=0)
+        {
+            fast = fast->next;
+            k--;
+        }
+       // cout<<slow->val<<endl;
+       // cout<<fast->val<<endl;
+        while(fast->next != NULL)
+        {
+            slow = slow->next;
+            fast = fast->next;
+        }
+        ListNode * res = slow->next;
+        slow->next = NULL;
+        fast->next = head;
+        return res;
+        
+        
+    }
+};
\ No newline at end of file
diff --git a/rotated-digits/README.md b/rotated-digits/README.md
new file mode 100644
index 0000000..e4579da
--- /dev/null
+++ b/rotated-digits/README.md
@@ -0,0 +1,20 @@
+<h2>788. Rotated Digits</h2><h3>Easy</h3><hr><div><p><code>x</code> is a good number if after rotating each digit individually by 180 degrees, we get a valid number that is different from <code>x</code>. Each digit must be rotated - we cannot choose to leave it alone.</p>
+
+<p>A number is valid if each digit remains a digit after rotation. 0, 1, and 8 rotate to themselves; 2 and 5 rotate to each other (on this case they are rotated in a different direction, in other words 2 or 5 gets mirrored); 6 and 9 rotate to each other, and the rest of the numbers do not rotate to any other number and become invalid.</p>
+
+<p>Now given a positive number <code>n</code>, how many numbers <code>x</code> from <code>1</code> to <code>n</code> are good?</p>
+
+<pre><strong>Example:</strong>
+<strong>Input:</strong> 10
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> 
+There are four good numbers in the range [1, 10] : 2, 5, 6, 9.
+Note that 1 and 10 are not good numbers, since they remain unchanged after rotating.
+</pre>
+
+<p><strong>Note:</strong></p>
+
+<ul>
+	<li><code>n</code> will be in range <code>[1, 10000]</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/rotated-digits/rotated-digits.cpp b/rotated-digits/rotated-digits.cpp
new file mode 100644
index 0000000..c346e5b
--- /dev/null
+++ b/rotated-digits/rotated-digits.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+  int rotatedDigits(int N) {
+  //3,4,7 invalid ->0
+  //0,1,8 valid ->1
+  //2,5,6,9 good ->2
+  vector<int> dp(N+1,0);
+  int cnt=0;
+  for(int i=0;i<=N;++i){
+	if(i<10){
+	  if(i==0 || i==1 || i==8) dp[i]=1;
+	  else if(i==2 || i==5 || i==6 || i==9) dp[i]=2,++cnt; 
+	}else{
+	  if(dp[i/10]==1 && dp[i%10]==1) dp[i]=1;
+	  else if(dp[i/10]>=1 && dp[i%10]>=1) dp[i]=2,++cnt;
+	}
+  }
+  return cnt;
+}
+};
\ No newline at end of file
diff --git a/rotting-oranges/README.md b/rotting-oranges/README.md
new file mode 100644
index 0000000..b4c408e
--- /dev/null
+++ b/rotting-oranges/README.md
@@ -0,0 +1,43 @@
+<h2>994. Rotting Oranges</h2><h3>Medium</h3><hr><div><p>You are given an <code>m x n</code> <code>grid</code> where each cell can have one of three values:</p>
+
+<ul>
+	<li><code>0</code> representing an empty cell,</li>
+	<li><code>1</code> representing a fresh orange, or</li>
+	<li><code>2</code> representing a rotten orange.</li>
+</ul>
+
+<p>Every minute, any fresh orange that is <strong>4-directionally adjacent</strong> to a rotten orange becomes rotten.</p>
+
+<p>Return <em>the minimum number of minutes that must elapse until no cell has a fresh orange</em>. If <em>this is impossible, return</em> <code>-1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/02/16/oranges.png" style="width: 650px; height: 137px;">
+<pre><strong>Input:</strong> grid = [[2,1,1],[1,1,0],[0,1,1]]
+<strong>Output:</strong> 4
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[2,1,1],[0,1,1],[1,0,1]]
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> The orange in the bottom left corner (row 2, column 0) is never rotten, because rotting only happens 4-directionally.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> grid = [[0,2]]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> Since there are already no fresh oranges at minute 0, the answer is just 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;= 10</code></li>
+	<li><code>grid[i][j]</code> is <code>0</code>, <code>1</code>, or <code>2</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/rotting-oranges/rotting-oranges.cpp b/rotting-oranges/rotting-oranges.cpp
new file mode 100644
index 0000000..02a2524
--- /dev/null
+++ b/rotting-oranges/rotting-oranges.cpp
@@ -0,0 +1,49 @@
+class Solution {
+public:
+    int orangesRotting(vector<vector<int>>& grid) 
+    {
+        
+        vector<int> dir={-1,0,1,0,-1}; //used for finding all 4 adjacent coordinates
+        
+        int m=grid.size();
+        int n=grid[0].size();
+        
+        queue<pair<int,int>> q;
+        int fresh=0; //To keep track of all fresh oranges left
+        for(int i=0;i<m;i++)
+            for(int j=0;j<n;j++)
+            {
+                if(grid[i][j]==2)
+                    q.push({i,j});
+                if(grid[i][j]==1)
+                    fresh++;
+            }
+        int ans=-1; //initialised to -1 since after each step we increment the time by 1 and initially all rotten oranges started at 0.
+        while(!q.empty())
+        {
+            int sz=q.size();
+            while(sz--)
+            {
+                pair<int,int> p=q.front();
+                q.pop();
+                for(int i=0;i<4;i++)
+                {
+                    int r=p.first+dir[i];
+                    int c=p.second+dir[i+1];
+                    if(r>=0 && r<m && c>=0 && c<n &&grid[r][c]==1)
+                    {
+                        grid[r][c]=2;
+                        q.push({r,c});
+                        fresh--; // decrement by 1 foreach fresh orange that now is rotten
+                    }
+                    
+                }
+            }
+            ans++; //incremented after each minute passes
+        }
+        if(fresh>0) return -1; //if fresh>0 that means there are fresh oranges left
+        if(ans==-1) return 0; //we initialised with -1, so if there were no oranges it'd take 0 mins.
+        return ans;
+        
+    }
+};
\ No newline at end of file
diff --git a/same-tree/README.md b/same-tree/README.md
new file mode 100644
index 0000000..9572f3d
--- /dev/null
+++ b/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/same-tree/same-tree.cpp b/same-tree/same-tree.cpp
new file mode 100644
index 0000000..614439b
--- /dev/null
+++ b/same-tree/same-tree.cpp
@@ -0,0 +1,27 @@
+/**
+ * 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:
+    bool isSameTree(TreeNode* p, TreeNode* q) {
+        if(p == NULL && q == NULL)
+            return true;
+        else if(p == NULL || q == NULL)
+            return false;
+        
+        if(p->val == q->val)
+        {
+            return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
+        }
+        else
+            return false;
+    }
+};
\ No newline at end of file
diff --git a/search-a-2d-matrix-ii/README.md b/search-a-2d-matrix-ii/README.md
new file mode 100644
index 0000000..8f206be
--- /dev/null
+++ b/search-a-2d-matrix-ii/README.md
@@ -0,0 +1,33 @@
+<h2>240. Search a 2D Matrix II</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/search-a-2d-matrix-ii/search-a-2d-matrix-ii.cpp b/search-a-2d-matrix-ii/search-a-2d-matrix-ii.cpp
new file mode 100644
index 0000000..9527e27
--- /dev/null
+++ b/search-a-2d-matrix-ii/search-a-2d-matrix-ii.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    bool searchMatrix(vector<vector<int>>& matrix, int target) {
+      
+      int rows = matrix.size();
+      int col = matrix[0].size();
+      
+      int i = 0;
+      int j = col -1;
+      
+      while(i<rows && j>=0)
+      {
+        if(matrix[i][j] == target)
+          return true;
+        else if(matrix[i][j] > target)
+        {
+         j--;
+        }
+        else
+          i++;
+          
+      }
+      return false;
+      
+    }
+};
\ No newline at end of file
diff --git a/search-a-2d-matrix/README.md b/search-a-2d-matrix/README.md
new file mode 100644
index 0000000..511073a
--- /dev/null
+++ b/search-a-2d-matrix/README.md
@@ -0,0 +1,30 @@
+<h2>74. Search a 2D Matrix</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/search-a-2d-matrix/search-a-2d-matrix.cpp b/search-a-2d-matrix/search-a-2d-matrix.cpp
new file mode 100644
index 0000000..863097d
--- /dev/null
+++ b/search-a-2d-matrix/search-a-2d-matrix.cpp
@@ -0,0 +1,36 @@
+class Solution {
+public:
+      
+    bool binarysearch(vector<int> v,int s,int e,int target)
+    {
+      if(s<=e)
+      {
+        int m = (s+e)/2;
+        if(v[m] == target)
+          return true;
+        else if(v[m]<target)
+        {
+          return binarysearch(v,m+1,e,target);
+        }
+        return binarysearch(v,s,m-1,target);
+      }
+      return false;
+    }
+  
+    bool searchMatrix(vector<vector<int>>& matrix, int target) {
+      
+      int m = matrix.size();
+      int n = matrix[0].size();
+      
+      int i=0;
+      while(i<m &&target > matrix[i][n-1])
+      {
+        i++;
+      }
+      if(i == m)
+        return false;
+      return binarysearch(matrix[i],0,n-1,target);
+      
+      
+    }
+};
\ No newline at end of file
diff --git a/search-in-rotated-sorted-array/README.md b/search-in-rotated-sorted-array/README.md
new file mode 100644
index 0000000..850441c
--- /dev/null
+++ b/search-in-rotated-sorted-array/README.md
@@ -0,0 +1,30 @@
+<h2>33. Search in Rotated Sorted Array</h2><h3>Medium</h3><hr><div><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>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>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>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>
+</div>
\ No newline at end of file
diff --git a/search-in-rotated-sorted-array/search-in-rotated-sorted-array.cpp b/search-in-rotated-sorted-array/search-in-rotated-sorted-array.cpp
new file mode 100644
index 0000000..175d78e
--- /dev/null
+++ b/search-in-rotated-sorted-array/search-in-rotated-sorted-array.cpp
@@ -0,0 +1,33 @@
+class Solution {
+public:
+    int search(vector<int>& nums, int target) {
+        
+        int low = 0;
+        int high = nums.size()-1;
+        
+        while(low <= high)
+        {
+            int mid = (high+low)/2;
+            if(nums[mid] == target)
+            {
+                return mid;
+            }
+            else if(nums[mid] >= nums[low] )
+            {
+                if( target >= nums[low] && target <= nums[mid])
+                high = mid-1;
+                else 
+                    low = mid+1;
+            }
+            else if(nums[mid] <= nums[high]  )
+            {
+                if(target >= nums[mid] && target <= nums[high])
+                low = mid + 1;
+                else
+                    high = mid-1;
+            }
+            
+        }
+        return -1;
+    }
+};
\ No newline at end of file
diff --git a/search-insert-position/README.md b/search-insert-position/README.md
new file mode 100644
index 0000000..7e57581
--- /dev/null
+++ b/search-insert-position/README.md
@@ -0,0 +1,31 @@
+<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><strong>Example 4:</strong></p>
+<pre><strong>Input:</strong> nums = [1,3,5,6], target = 0
+<strong>Output:</strong> 0
+</pre><p><strong>Example 5:</strong></p>
+<pre><strong>Input:</strong> nums = [1], target = 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>-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/search-insert-position/search-insert-position.cpp b/search-insert-position/search-insert-position.cpp
new file mode 100644
index 0000000..985a28b
--- /dev/null
+++ b/search-insert-position/search-insert-position.cpp
@@ -0,0 +1,6 @@
+class Solution {
+public:
+    int searchInsert(vector<int>& nums, int target) {
+        return lower_bound(nums.begin(),nums.end(),target)-nums.begin();
+    }
+};
\ No newline at end of file
diff --git a/second-highest-salary/README.md b/second-highest-salary/README.md
new file mode 100644
index 0000000..f034e2c
--- /dev/null
+++ b/second-highest-salary/README.md
@@ -0,0 +1,20 @@
+<h2>176. Second Highest Salary</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>Write a SQL query to get the second highest salary from the <code>Employee</code> table.</p>
+
+<pre>+----+--------+
+| Id | Salary |
++----+--------+
+| 1  | 100    |
+| 2  | 200    |
+| 3  | 300    |
++----+--------+
+</pre>
+
+<p>For example, given the above Employee table, the query should return <code>200</code> as the second highest salary. If there is no second highest salary, then the query should return <code>null</code>.</p>
+
+<pre>+---------------------+
+| SecondHighestSalary |
++---------------------+
+| 200                 |
++---------------------+
+</pre>
+</div>
\ No newline at end of file
diff --git a/second-highest-salary/second-highest-salary.sql b/second-highest-salary/second-highest-salary.sql
new file mode 100644
index 0000000..6b60396
--- /dev/null
+++ b/second-highest-salary/second-highest-salary.sql
@@ -0,0 +1,3 @@
+# Write your MySQL query statement below
+
+SELECT MAX(Salary) as SecondHighestSalary FROM Employee WHERE Salary NOT IN (SELECT MAX(Salary) FROM Employee);
diff --git a/set-matrix-zeroes/README.md b/set-matrix-zeroes/README.md
new file mode 100644
index 0000000..b2ffdac
--- /dev/null
+++ b/set-matrix-zeroes/README.md
@@ -0,0 +1,36 @@
+<h2>73. Set Matrix Zeroes</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/set-matrix-zeroes/set-matrix-zeroes.cpp b/set-matrix-zeroes/set-matrix-zeroes.cpp
new file mode 100644
index 0000000..5d03c66
--- /dev/null
+++ b/set-matrix-zeroes/set-matrix-zeroes.cpp
@@ -0,0 +1,35 @@
+class Solution {
+public:
+    void setZeroes(vector<vector<int>>& matrix) {
+      
+      int col = 1;
+      int m = matrix.size();
+      int n = matrix[0].size();
+      
+      for(int i=0;i<m;i++)
+      {
+        if(matrix[i][0] == 0)
+          col = 0;
+        for(int j=1;j<n;j++)
+        {
+          if(matrix[i][j] == 0)
+          {
+            matrix[i][0] = 0;
+            matrix[0][j] = 0;
+          }
+        }
+      }
+      
+      for(int i = m-1;i>=0;i--)
+      {
+        for(int j=n-1;j>=1;j--)
+        {
+          if(matrix[i][0] == 0 || matrix[0][j] == 0)
+            matrix[i][j] = 0;
+        }
+        if(col == 0)
+          matrix[i][0] = 0;
+      }
+      
+    }
+};
\ No newline at end of file
diff --git a/shuffle-an-array/README.md b/shuffle-an-array/README.md
new file mode 100644
index 0000000..51662c5
--- /dev/null
+++ b/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 nums.</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/shuffle-an-array/shuffle-an-array.cpp b/shuffle-an-array/shuffle-an-array.cpp
new file mode 100644
index 0000000..4228638
--- /dev/null
+++ b/shuffle-an-array/shuffle-an-array.cpp
@@ -0,0 +1,22 @@
+class Solution {
+    vector<int> nums;
+public:
+    Solution(vector<int> nums) {
+        this->nums = nums;
+    }
+    
+    /** Resets the array to its original configuration and return it. */
+    vector<int> reset() {
+        return nums;
+    }
+    
+    /** Returns a random shuffling of the array. */
+    vector<int> shuffle() {
+        vector<int> result(nums);
+        for (int i = 0;i < result.size();i++) {
+            int pos = rand()%(result.size()-i);
+            swap(result[i+pos], result[i]);
+        }
+        return result;
+    }
+};
\ No newline at end of file
diff --git a/single-element-in-a-sorted-array/README.md b/single-element-in-a-sorted-array/README.md
new file mode 100644
index 0000000..b014b19
--- /dev/null
+++ b/single-element-in-a-sorted-array/README.md
@@ -0,0 +1,22 @@
+<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 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>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<sup>5</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/single-element-in-a-sorted-array/single-element-in-a-sorted-array.cpp b/single-element-in-a-sorted-array/single-element-in-a-sorted-array.cpp
new file mode 100644
index 0000000..e051a62
--- /dev/null
+++ b/single-element-in-a-sorted-array/single-element-in-a-sorted-array.cpp
@@ -0,0 +1,58 @@
+class Solution {
+public:
+  
+  int helper(vector<int>& nums,int l ,int h)
+  {
+      while(l<h)
+      {
+        int mid = l + (h-l)/2;
+        
+        if(mid-1>=0 && nums[mid] == nums[mid-1])
+           {
+              int a = helper(nums,l,mid-2);
+            if(a != -1)
+              return a;
+          
+            int b = helper(nums,mid+1,h);
+          if(b != -1)
+            return b;
+          
+          return -1;
+           }
+        else if((mid+1 < nums.size() && nums[mid] == nums[mid+1] ))
+        {
+           int a = helper(nums,l,mid-1);
+            if(a != -1)
+              return a;
+          
+            int b = helper(nums,mid+2,h);
+          if(b != -1)
+            return b;
+          
+          return -1;
+        }
+        else
+        {
+             return nums[mid];
+        }
+        
+      }
+    
+      if(l == h)
+        return nums[l];
+       return -1;   
+    
+  }
+    int singleNonDuplicate(vector<int>& nums) {
+      
+      if(nums.size()==1)
+      return nums[0];
+      if(nums.size() == 2)
+        return -1;
+      
+      int low = 0;
+      int high = nums.size()-1;
+      
+      return helper(nums,low,high);
+    }
+};
\ No newline at end of file
diff --git a/single-number-iii/README.md b/single-number-iii/README.md
new file mode 100644
index 0000000..d8afd72
--- /dev/null
+++ b/single-number-iii/README.md
@@ -0,0 +1,33 @@
+<h2>260. Single Number III</h2><h3>Medium</h3><hr><div><p>Given an integer array <code>nums</code>, in which exactly two elements appear only once and all the other elements appear exactly twice. Find the two elements that appear only once. You can return the answer in <strong>any order</strong>.</p>
+
+<p>You must write an&nbsp;algorithm that runs in linear runtime complexity and uses&nbsp;only constant extra space.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,1,3,2,5]
+<strong>Output:</strong> [3,5]
+<strong>Explanation: </strong> [5, 3] is also a valid answer.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-1,0]
+<strong>Output:</strong> [-1,0]
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [0,1]
+<strong>Output:</strong> [1,0]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &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 integer in <code>nums</code> will appear twice, only two integers will appear once.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/single-number-iii/single-number-iii.cpp b/single-number-iii/single-number-iii.cpp
new file mode 100644
index 0000000..e32301e
--- /dev/null
+++ b/single-number-iii/single-number-iii.cpp
@@ -0,0 +1,33 @@
+class Solution {
+public:
+
+    vector<int> singleNumber(vector<int>& nums) {
+        int n = nums.size();
+        vector<int>res{};
+        int bucket1{}, bucket2{};
+        long long int xr{};
+        
+		//Calculate xor of every number so that xr will have (x^y)
+        for(int i{}; i<n; ++i) 
+            xr = xr ^ nums[i];
+        
+		// Compute rightmost set bit of xr, gives us the ith bit we need as a mask
+        int mask = xr & (-xr);
+        
+		// Fill our buckets according to our intuition mentioned in above steps
+        for(int i{}; i<n; ++i){
+            
+            if(mask & nums[i])
+                bucket1 ^= nums[i];
+            
+            else
+                bucket2 ^= nums[i];
+        }
+        
+		// bucket1 and bucket2 will contain x and y
+        res.push_back(bucket1);
+        res.push_back(bucket2);
+        
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/slowest-key/README.md b/slowest-key/README.md
new file mode 100644
index 0000000..aacf8ef
--- /dev/null
+++ b/slowest-key/README.md
@@ -0,0 +1,48 @@
+<h2>1629. Slowest Key</h2><h3>Easy</h3><hr><div><p>A newly designed keypad was tested, where a tester pressed a sequence of <code>n</code> keys, one at a time.</p>
+
+<p>You are given a string <code>keysPressed</code> of length <code>n</code>, where <code>keysPressed[i]</code> was the <code>i<sup>th</sup></code> key pressed in the testing sequence, and a sorted list <code>releaseTimes</code>, where <code>releaseTimes[i]</code> was the time the <code>i<sup>th</sup></code> key was released. Both arrays are <strong>0-indexed</strong>. The <code>0<sup>th</sup></code> key was pressed at the time <code>0</code>,&nbsp;and every subsequent key was pressed at the <strong>exact</strong> time the previous key was released.</p>
+
+<p>The tester wants to know the key of the keypress that had the <strong>longest duration</strong>. The <code>i<sup>th</sup></code><sup> </sup>keypress had a <strong>duration</strong> of <code>releaseTimes[i] - releaseTimes[i - 1]</code>, and the <code>0<sup>th</sup></code> keypress had a duration of <code>releaseTimes[0]</code>.</p>
+
+<p>Note that the same key could have been pressed multiple times during the test, and these multiple presses of the same key <strong>may not</strong> have had the same <strong>duration</strong>.</p>
+
+<p><em>Return the key of the keypress that had the <strong>longest duration</strong>. If there are multiple such keypresses, return the lexicographically largest key of the keypresses.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> releaseTimes = [9,29,49,50], keysPressed = "cbcd"
+<strong>Output:</strong> "c"
+<strong>Explanation:</strong> The keypresses were as follows:
+Keypress for 'c' had a duration of 9 (pressed at time 0 and released at time 9).
+Keypress for 'b' had a duration of 29 - 9 = 20 (pressed at time 9 right after the release of the previous character and released at time 29).
+Keypress for 'c' had a duration of 49 - 29 = 20 (pressed at time 29 right after the release of the previous character and released at time 49).
+Keypress for 'd' had a duration of 50 - 49 = 1 (pressed at time 49 right after the release of the previous character and released at time 50).
+The longest of these was the keypress for 'b' and the second keypress for 'c', both with duration 20.
+'c' is lexicographically larger than 'b', so the answer is 'c'.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> releaseTimes = [12,23,36,46,62], keysPressed = "spuda"
+<strong>Output:</strong> "a"
+<strong>Explanation:</strong> The keypresses were as follows:
+Keypress for 's' had a duration of 12.
+Keypress for 'p' had a duration of 23 - 12 = 11.
+Keypress for 'u' had a duration of 36 - 23 = 13.
+Keypress for 'd' had a duration of 46 - 36 = 10.
+Keypress for 'a' had a duration of 62 - 46 = 16.
+The longest of these was the keypress for 'a' with duration 16.</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>releaseTimes.length == n</code></li>
+	<li><code>keysPressed.length == n</code></li>
+	<li><code>2 &lt;= n &lt;= 1000</code></li>
+	<li><code>1 &lt;= releaseTimes[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>releaseTimes[i] &lt; releaseTimes[i+1]</code></li>
+	<li><code>keysPressed</code> contains only lowercase English letters.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/slowest-key/slowest-key.cpp b/slowest-key/slowest-key.cpp
new file mode 100644
index 0000000..be2fef0
--- /dev/null
+++ b/slowest-key/slowest-key.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+   char slowestKey(vector<int>& times, string keys) {
+    int max_p = times[0], res = keys[0];
+    for (auto i = 1; i < times.size(); ++i)
+        if (max_p <= times[i] - times[i - 1]) {
+            if (max_p == times[i] - times[i - 1])
+                res = max((char)res, keys[i]);
+            else
+                res = keys[i];
+            max_p = times[i] - times[i - 1];
+        }
+    return res;
+}
+};
\ No newline at end of file
diff --git a/smallest-integer-divisible-by-k/README.md b/smallest-integer-divisible-by-k/README.md
new file mode 100644
index 0000000..b5ec720
--- /dev/null
+++ b/smallest-integer-divisible-by-k/README.md
@@ -0,0 +1,35 @@
+<h2>1015. Smallest Integer Divisible by K</h2><h3>Medium</h3><hr><div><p>Given a positive integer <code>k</code>, you need to find the <strong>length</strong> of the <strong>smallest</strong> positive integer <code>n</code> such that <code>n</code> is divisible by <code>k</code>, and <code>n</code> only contains the digit <code>1</code>.</p>
+
+<p>Return <em>the <strong>length</strong> of </em><code>n</code>. If there is no such <code>n</code>, return -1.</p>
+
+<p><strong>Note:</strong> <code>n</code> may not fit in a 64-bit signed integer.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> k = 1
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> The smallest answer is n = 1, which has length 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> k = 2
+<strong>Output:</strong> -1
+<strong>Explanation:</strong> There is no such positive integer n divisible by 2.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> k = 3
+<strong>Output:</strong> 3
+<strong>Explanation:</strong> The smallest answer is n = 111, which has length 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/smallest-integer-divisible-by-k/smallest-integer-divisible-by-k.cpp b/smallest-integer-divisible-by-k/smallest-integer-divisible-by-k.cpp
new file mode 100644
index 0000000..a33b530
--- /dev/null
+++ b/smallest-integer-divisible-by-k/smallest-integer-divisible-by-k.cpp
@@ -0,0 +1,9 @@
+class Solution {
+public:
+    int smallestRepunitDivByK(int K) {
+           for (int r = 0, N = 1; N <= K; ++N)
+            if ((r = (r * 10 + 1) % K) == 0)
+                return N;
+        return -1;
+    }
+};
\ No newline at end of file
diff --git a/sort-an-array/README.md b/sort-an-array/README.md
new file mode 100644
index 0000000..95ef07f
--- /dev/null
+++ b/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/sort-an-array/sort-an-array.cpp b/sort-an-array/sort-an-array.cpp
new file mode 100644
index 0000000..29a1be1
--- /dev/null
+++ b/sort-an-array/sort-an-array.cpp
@@ -0,0 +1,8 @@
+class Solution {
+public:
+    vector<int> sortArray(vector<int>& nums) {
+        
+    stable_sort(nums.begin(), nums.end());
+        return nums;
+    }
+};
\ No newline at end of file
diff --git a/sort-characters-by-frequency/README.md b/sort-characters-by-frequency/README.md
new file mode 100644
index 0000000..6dfa169
--- /dev/null
+++ b/sort-characters-by-frequency/README.md
@@ -0,0 +1,37 @@
+<h2>451. Sort Characters By Frequency</h2><h3>Medium</h3><hr><div><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>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "tree"
+<strong>Output:</strong> "eert"
+<strong>Explanation:</strong> 'e' appears twice while 'r' and 't' both appear once.
+So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "cccaaa"
+<strong>Output:</strong> "aaaccc"
+<strong>Explanation:</strong> Both 'c' and 'a' appear three times, so both "cccaaa" and "aaaccc" are valid answers.
+Note that "cacaca" is incorrect, as the same characters must be together.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "Aabb"
+<strong>Output:</strong> "bbAa"
+<strong>Explanation:</strong> "bbaA" is also a valid answer, but "Aabb" is incorrect.
+Note that 'A' and 'a' 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>
+</div>
\ No newline at end of file
diff --git a/sort-characters-by-frequency/sort-characters-by-frequency.cpp b/sort-characters-by-frequency/sort-characters-by-frequency.cpp
new file mode 100644
index 0000000..2f6e63b
--- /dev/null
+++ b/sort-characters-by-frequency/sort-characters-by-frequency.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    string frequencySort(string s) {
+        int counts[256] = {0};
+        for (char ch : s)
+            ++counts[ch];
+        sort(s.begin(), s.end(), [&](char a, char b) { 
+            return counts[a] > counts[b] || (counts[a] == counts[b] && a < b); 
+        });
+        return s;
+    }
+};
\ No newline at end of file
diff --git a/sort-colors/README.md b/sort-colors/README.md
new file mode 100644
index 0000000..e79cb45
--- /dev/null
+++ b/sort-colors/README.md
@@ -0,0 +1,32 @@
+<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/sort-colors/sort-colors.cpp b/sort-colors/sort-colors.cpp
new file mode 100644
index 0000000..6874464
--- /dev/null
+++ b/sort-colors/sort-colors.cpp
@@ -0,0 +1,32 @@
+class Solution {
+public:
+    void sortColors(vector<int>& nums) {
+      
+      int left = 0;
+      int mid = 0;
+      int right = nums.size()-1;
+ 
+     while(mid<=right)
+     {
+       if(nums[mid] == 0)
+       {
+         swap(nums[mid],nums[left]);
+         mid++;
+         left++;
+       }
+       else if(nums[mid] == 1)
+       {
+         mid++;
+       }
+       else
+       {
+         swap(nums[mid],nums[right]);
+         right--;
+        
+       }
+       
+     }
+    
+      
+    }
+};
\ No newline at end of file
diff --git a/sort-integers-by-the-number-of-1-bits/README.md b/sort-integers-by-the-number-of-1-bits/README.md
new file mode 100644
index 0000000..978e591
--- /dev/null
+++ b/sort-integers-by-the-number-of-1-bits/README.md
@@ -0,0 +1,49 @@
+<h2>1356. Sort Integers by The Number of 1 Bits</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>arr</code>. You have to sort the integers in the array&nbsp;in ascending order by the number of <strong>1's</strong>&nbsp;in their binary representation and in case of two or more integers have the same number of <strong>1's</strong> you have to sort them in ascending order.</p>
+
+<p>Return <em>the sorted array</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> arr = [0,1,2,3,4,5,6,7,8]
+<strong>Output:</strong> [0,1,2,4,8,3,5,6,7]
+<strong>Explantion:</strong> [0] is the only integer with 0 bits.
+[1,2,4,8] all have 1 bit.
+[3,5,6] have 2 bits.
+[7] has 3 bits.
+The sorted array by bits is [0,1,2,4,8,3,5,6,7]
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> arr = [1024,512,256,128,64,32,16,8,4,2,1]
+<strong>Output:</strong> [1,2,4,8,16,32,64,128,256,512,1024]
+<strong>Explantion:</strong> All integers have 1 bit in the binary representation, you should just sort them in ascending order.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> arr = [10000,10000]
+<strong>Output:</strong> [10000,10000]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> arr = [2,3,5,7,11,13,17,19]
+<strong>Output:</strong> [2,3,5,17,7,11,13,19]
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> arr = [10,100,1000,10000]
+<strong>Output:</strong> [10,100,10000,1000]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length &lt;= 500</code></li>
+	<li><code>0 &lt;= arr[i] &lt;= 10^4</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/spiral-matrix/README.md b/spiral-matrix/README.md
new file mode 100644
index 0000000..02d4fd6
--- /dev/null
+++ b/spiral-matrix/README.md
@@ -0,0 +1,25 @@
+<h2>54. Spiral Matrix</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/spiral-matrix/spiral-matrix.cpp b/spiral-matrix/spiral-matrix.cpp
new file mode 100644
index 0000000..cadb576
--- /dev/null
+++ b/spiral-matrix/spiral-matrix.cpp
@@ -0,0 +1,35 @@
+class Solution {
+public:
+    vector<int> spiralOrder(vector<vector<int>>& matrix) {
+        int m = matrix.size(), n = m ? matrix[0].size() : 0, u = 0, d = m - 1, l = 0, r = n - 1, p = 0;
+        vector<int> order(m * n);
+        while (u <= d && l <= r) {
+            for (int col = l; col <= r; col++) {
+                order[p++] = matrix[u][col];
+            }
+            if (++u > d) {
+                break;
+            }
+            for (int row = u; row <= d; row++) {
+                order[p++] = matrix[row][r];
+            }
+            if (--r < l) {
+                break;
+            }
+            for (int col = r; col >= l; col--) {
+                order[p++] = matrix[d][col];
+            }
+            if (--d < u) {
+                break;
+            }
+            for (int row = d; row >= u; row--) {
+                order[p++] = matrix[row][l];
+            }
+            if (l++ > r) {
+                break;
+            }
+        }
+         //order.push_back(1);
+        return order;
+    }
+};
\ No newline at end of file
diff --git a/sqrtx/README.md b/sqrtx/README.md
new file mode 100644
index 0000000..c25fd96
--- /dev/null
+++ b/sqrtx/README.md
@@ -0,0 +1,26 @@
+<h2>69. Sqrt(x)</h2><h3>Easy</h3><hr><div><p>Given a non-negative integer <code>x</code>,&nbsp;compute and return <em>the square root of</em> <code>x</code>.</p>
+
+<p>Since the return type&nbsp;is an integer, the decimal digits are <strong>truncated</strong>, and only <strong>the integer part</strong> of the result&nbsp;is returned.</p>
+
+<p><strong>Note:&nbsp;</strong>You are not allowed to use any built-in exponent function or operator, such as <code>pow(x, 0.5)</code> or&nbsp;<code>x ** 0.5</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> x = 4
+<strong>Output:</strong> 2
+</pre>
+
+<p><strong>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 the decimal part is truncated, 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>
+</div>
\ No newline at end of file
diff --git a/sqrtx/sqrtx.cpp b/sqrtx/sqrtx.cpp
new file mode 100644
index 0000000..070137d
--- /dev/null
+++ b/sqrtx/sqrtx.cpp
@@ -0,0 +1,6 @@
+class Solution {
+public:
+    int mySqrt(int x) {
+        return sqrt(x);
+    }
+};
\ No newline at end of file
diff --git a/squares-of-a-sorted-array/README.md b/squares-of-a-sorted-array/README.md
new file mode 100644
index 0000000..19d5498
--- /dev/null
+++ b/squares-of-a-sorted-array/README.md
@@ -0,0 +1,28 @@
+<h2>977. Squares of a Sorted Array</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> sorted in <strong>non-decreasing</strong> order, return <em>an array of <strong>the squares of each number</strong> sorted in non-decreasing order</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-4,-1,0,3,10]
+<strong>Output:</strong> [0,1,9,16,100]
+<strong>Explanation:</strong> After squaring, the array becomes [16,1,0,9,100].
+After sorting, it becomes [0,1,9,16,100].
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [-7,-3,2,3,11]
+<strong>Output:</strong> [4,9,9,49,121]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code><span>1 &lt;= nums.length &lt;= </span>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 <strong>non-decreasing</strong> order.</li>
+</ul>
+
+<p>&nbsp;</p>
+<strong>Follow up:</strong> Squaring each element and sorting the new array is very trivial, could you find an <code>O(n)</code> solution using a different approach?</div>
\ No newline at end of file
diff --git a/squares-of-a-sorted-array/squares-of-a-sorted-array.cpp b/squares-of-a-sorted-array/squares-of-a-sorted-array.cpp
new file mode 100644
index 0000000..58d9bf5
--- /dev/null
+++ b/squares-of-a-sorted-array/squares-of-a-sorted-array.cpp
@@ -0,0 +1,13 @@
+class Solution {
+public:
+    vector<int> sortedSquares(vector<int>& nums) {
+        
+        for(int i=0;i<nums.size();i++)
+            nums[i] = nums[i] * nums[i];
+        
+        sort(nums.begin(),nums.end());
+        
+        return nums;
+        
+    }
+};
\ No newline at end of file
diff --git a/stone-game/README.md b/stone-game/README.md
new file mode 100644
index 0000000..4934004
--- /dev/null
+++ b/stone-game/README.md
@@ -0,0 +1,31 @@
+<h2>877. Stone Game</h2><h3>Medium</h3><hr><div><p>Alex and Lee play a game with piles of stones.&nbsp; There are an even number of&nbsp;piles <strong>arranged in a row</strong>, and each pile has a positive integer number of stones <code>piles[i]</code>.</p>
+
+<p>The objective of the game is to end with the most&nbsp;stones.&nbsp; The total number of stones is odd, so there are no ties.</p>
+
+<p>Alex and Lee take turns, with Alex starting first.&nbsp; Each turn, a player&nbsp;takes the entire pile of stones from either the beginning or the end of the row.&nbsp; This continues until there are no more piles left, at which point the person with the most stones wins.</p>
+
+<p>Assuming Alex and Lee play optimally, return <code>True</code>&nbsp;if and only if Alex wins the game.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> piles = [5,3,4,5]
+<strong>Output:</strong> true
+<strong>Explanation: </strong>
+Alex starts first, and can only take the first 5 or the last 5.
+Say he takes the first 5, so that the row becomes [3, 4, 5].
+If Lee takes 3, then the board is [4, 5], and Alex takes 5 to win with 10 points.
+If Lee takes the last 5, then the board is [3, 4], and Alex takes 4 to win with 9 points.
+This demonstrated that taking the first 5 was a winning move for Alex, so we return true.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= piles.length &lt;= 500</code></li>
+	<li><code>piles.length</code> is even.</li>
+	<li><code>1 &lt;= piles[i] &lt;= 500</code></li>
+	<li><code>sum(piles)</code> is odd.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/stone-game/stone-game.cpp b/stone-game/stone-game.cpp
new file mode 100644
index 0000000..fa3582d
--- /dev/null
+++ b/stone-game/stone-game.cpp
@@ -0,0 +1,10 @@
+class Solution {
+public:
+  bool stoneGame(vector<int>& p) {
+        vector<int> dp = p;
+        for (int d = 1; d < p.size(); d++)
+            for (int i = 0; i < p.size() - d; i++)
+                dp[i] = max(p[i] - dp[i + 1], p[i + d] - dp[i]);
+        return dp[0] > 0;
+    }
+};
\ No newline at end of file
diff --git a/subsets/README.md b/subsets/README.md
new file mode 100644
index 0000000..a2af7b4
--- /dev/null
+++ b/subsets/README.md
@@ -0,0 +1,26 @@
+<h2>78. Subsets</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/subsets/subsets.cpp b/subsets/subsets.cpp
new file mode 100644
index 0000000..1bc88f0
--- /dev/null
+++ b/subsets/subsets.cpp
@@ -0,0 +1,35 @@
+class Solution {
+public:
+    vector<vector<int>> ans;
+    
+    void subsets_helper(int index,vector<int> & nums,vector<int> &subset)
+    {
+        
+        if(index == nums.size())
+        {
+            ans.push_back(subset);
+            return;
+        }
+         subset.push_back(nums[index]);
+        subsets_helper(index+1,nums,subset);
+        subset.pop_back();
+        subsets_helper(index+1,nums,subset);
+        
+        return;
+        
+//         ans.push_back(subset);
+        
+//         for(int i= index;i<nums.size();i++)
+//         {
+//             subset.push_back(nums[i]);
+//             subsets_helper(i+1,nums,subset);
+//             subset.pop_back();
+//         }
+//         return ;
+    }
+    vector<vector<int>> subsets(vector<int>& nums) {
+        vector<int> subset;
+        subsets_helper(0,nums,subset);
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/sum-of-left-leaves/README.md b/sum-of-left-leaves/README.md
new file mode 100644
index 0000000..b9e7ba5
--- /dev/null
+++ b/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/sum-of-left-leaves/sum-of-left-leaves.cpp b/sum-of-left-leaves/sum-of-left-leaves.cpp
new file mode 100644
index 0000000..063286b
--- /dev/null
+++ b/sum-of-left-leaves/sum-of-left-leaves.cpp
@@ -0,0 +1,28 @@
+/**
+ * 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:
+    //20
+    int sum = 0;
+    int sumOfLeftLeaves(TreeNode* root) {
+        dfs(root);
+        return sum;
+    }
+    void dfs(TreeNode* root){
+        if(root == nullptr)return;
+        dfs(root->left);
+        dfs(root->right);
+        if(root->left != nullptr && root->left->left == nullptr && root->left->right == nullptr)         {
+            sum += root->left->val;
+        }
+    }
+};
\ No newline at end of file
diff --git a/sum-of-nodes-with-even-valued-grandparent/README.md b/sum-of-nodes-with-even-valued-grandparent/README.md
new file mode 100644
index 0000000..de1a759
--- /dev/null
+++ b/sum-of-nodes-with-even-valued-grandparent/README.md
@@ -0,0 +1,21 @@
+<h2>1315. Sum of Nodes with Even-Valued Grandparent</h2><h3>Medium</h3><hr><div><p>Given a binary tree, return the sum of values of nodes with even-valued grandparent.&nbsp; (A <em>grandparent</em> of a node is the parent of its parent, if it exists.)</p>
+
+<p>If there are no nodes with an even-valued grandparent, return&nbsp;<code>0</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2019/07/24/1473_ex1.png" style="width: 350px; height: 214px;"></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> 18
+<b>Explanation:</b> The red nodes are the nodes with even-value grandparent while the blue nodes are the even-value grandparents.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is between&nbsp;<code>1</code>&nbsp;and&nbsp;<code>10^4</code>.</li>
+	<li>The value of nodes is between&nbsp;<code>1</code>&nbsp;and&nbsp;<code>100</code>.</li>
+</ul></div>
\ No newline at end of file
diff --git a/sum-of-nodes-with-even-valued-grandparent/sum-of-nodes-with-even-valued-grandparent.cpp b/sum-of-nodes-with-even-valued-grandparent/sum-of-nodes-with-even-valued-grandparent.cpp
new file mode 100644
index 0000000..31cee64
--- /dev/null
+++ b/sum-of-nodes-with-even-valued-grandparent/sum-of-nodes-with-even-valued-grandparent.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int s=0;
+    int sumEvenGrandparent(TreeNode* root) {
+        fun(root,NULL,NULL);  //passing the root node with it's parent & grandparent as NULL
+        return s;
+    }
+    void fun(TreeNode* root,TreeNode* parent,TreeNode* grandparent)
+    {
+        if(!root) return;  //if root is null then return 
+        if(grandparent && grandparent->val%2==0)  //checking even valued grandparent existance 
+            s+=root->val;
+        fun(root->left,root,parent);  //calling function for left subtree where root will be the parent & previous parent will act as the grandparent for left subtree of the root.
+        fun(root->right,root,parent);  //same for right subtree
+    }
+};
\ No newline at end of file
diff --git a/sum-of-square-numbers/README.md b/sum-of-square-numbers/README.md
new file mode 100644
index 0000000..0575c71
--- /dev/null
+++ b/sum-of-square-numbers/README.md
@@ -0,0 +1,41 @@
+<h2>633. Sum of Square Numbers</h2><h3>Medium</h3><hr><div><p>Given a non-negative integer <code>c</code>, decide whether there're two integers <code>a</code> and <code>b</code> such that <code>a<sup>2</sup> + b<sup>2</sup> = c</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> c = 5
+<strong>Output:</strong> true
+<strong>Explanation:</strong> 1 * 1 + 2 * 2 = 5
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> c = 3
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> c = 4
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> c = 2
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> c = 1
+<strong>Output:</strong> true
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= c &lt;= 2<sup>31</sup> - 1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/sum-of-square-numbers/sum-of-square-numbers.cpp b/sum-of-square-numbers/sum-of-square-numbers.cpp
new file mode 100644
index 0000000..6ccf56a
--- /dev/null
+++ b/sum-of-square-numbers/sum-of-square-numbers.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+    bool judgeSquareSum(int c) 
+    {
+    	if(c<0)
+    		return false;
+    	long int left=0,right=sqrt(c);
+    	while(left<=right)
+    	{
+    		long int cur=left*left+right*right;
+    		if(cur<c)
+    			left++;
+    		else if(cur>c)
+    			right--;
+    		else 
+    			return true;
+    	}    
+    	return false;
+    }
+};
\ No newline at end of file
diff --git a/sum-root-to-leaf-numbers/README.md b/sum-root-to-leaf-numbers/README.md
new file mode 100644
index 0000000..029935e
--- /dev/null
+++ b/sum-root-to-leaf-numbers/README.md
@@ -0,0 +1,43 @@
+<h2>129. Sum Root to Leaf Numbers</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/surrounded-regions/README.md b/surrounded-regions/README.md
new file mode 100644
index 0000000..56830b7
--- /dev/null
+++ b/surrounded-regions/README.md
@@ -0,0 +1,28 @@
+<h2>130. Surrounded Regions</h2><h3>Medium</h3><hr><div><p>Given an <code>m x n</code> matrix <code>board</code> containing <code>'X'</code> and <code>'O'</code>, <em>capture all regions that are 4-directionally&nbsp;surrounded by</em> <code>'X'</code>.</p>
+
+<p>A region is <strong>captured</strong> by flipping all <code>'O'</code>s into <code>'X'</code>s in that surrounded region.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/xogrid.jpg" style="width: 550px; height: 237px;">
+<pre><strong>Input:</strong> board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]
+<strong>Output:</strong> [["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]
+<strong>Explanation:</strong> Surrounded regions should not be on the border, which means that any 'O' on the border of the board are not flipped to 'X'. Any 'O' that is not on the border and it is not connected to an 'O' on the border will be flipped to 'X'. Two cells are connected if they are adjacent cells connected horizontally or vertically.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> board = [["X"]]
+<strong>Output:</strong> [["X"]]
+</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;= 200</code></li>
+	<li><code>board[i][j]</code> is <code>'X'</code> or <code>'O'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/surrounded-regions/surrounded-regions.cpp b/surrounded-regions/surrounded-regions.cpp
new file mode 100644
index 0000000..ebecf89
--- /dev/null
+++ b/surrounded-regions/surrounded-regions.cpp
@@ -0,0 +1,42 @@
+class Solution {
+public:
+	void solve(vector<vector<char>>& board) {
+        int i,j;
+        int row=board.size();
+        if(!row)
+        	return;
+        int col=board[0].size();
+
+		for(i=0;i<row;i++){
+			check(board,i,0,row,col);
+			if(col>1)
+				check(board,i,col-1,row,col);
+		}
+		for(j=1;j+1<col;j++){
+			check(board,0,j,row,col);
+			if(row>1)
+				check(board,row-1,j,row,col);
+		}
+		for(i=0;i<row;i++)
+			for(j=0;j<col;j++)
+				if(board[i][j]=='O')
+					board[i][j]='X';
+		for(i=0;i<row;i++)
+			for(j=0;j<col;j++)
+				if(board[i][j]=='1')
+					board[i][j]='O';
+    }
+	void check(vector<vector<char> >&vec,int i,int j,int row,int col){
+		if(vec[i][j]=='O'){
+			vec[i][j]='1';
+			if(i>1)
+				check(vec,i-1,j,row,col);
+			if(j>1)
+				check(vec,i,j-1,row,col);
+			if(i+1<row)
+				check(vec,i+1,j,row,col);
+			if(j+1<col)
+				check(vec,i,j+1,row,col);
+		}
+	}
+};
\ No newline at end of file
diff --git a/symmetric-tree/README.md b/symmetric-tree/README.md
new file mode 100644
index 0000000..457d82e
--- /dev/null
+++ b/symmetric-tree/README.md
@@ -0,0 +1,25 @@
+<h2>101. Symmetric Tree</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/three-equal-parts/README.md b/three-equal-parts/README.md
new file mode 100644
index 0000000..b62e24d
--- /dev/null
+++ b/three-equal-parts/README.md
@@ -0,0 +1,34 @@
+<h2>927. Three Equal Parts</h2><h3>Hard</h3><hr><div><p>You are given an array <code>arr</code> which consists of only zeros and ones, divide the array into <strong>three non-empty parts</strong> such that all of these parts represent the same binary value.</p>
+
+<p>If it is possible, return any <code>[i, j]</code> with <code>i + 1 &lt; j</code>, such that:</p>
+
+<ul>
+	<li><code>arr[0], arr[1], ..., arr[i]</code> is the first part,</li>
+	<li><code>arr[i + 1], arr[i + 2], ..., arr[j - 1]</code> is the second part, and</li>
+	<li><code>arr[j], arr[j + 1], ..., arr[arr.length - 1]</code> is the third part.</li>
+	<li>All three parts have equal binary values.</li>
+</ul>
+
+<p>If it is not possible, return <code>[-1, -1]</code>.</p>
+
+<p>Note that the entire part is used when considering what binary value it represents. For example, <code>[1,1,0]</code> represents <code>6</code> in decimal, not <code>3</code>. Also, leading zeros <strong>are allowed</strong>, so <code>[0,1,1]</code> and <code>[1,1]</code> represent the same value.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> arr = [1,0,1,0,1]
+<strong>Output:</strong> [0,3]
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> arr = [1,1,0,1,1]
+<strong>Output:</strong> [-1,-1]
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> arr = [1,1,0,0,1]
+<strong>Output:</strong> [0,2]
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>3 &lt;= arr.length &lt;= 3 * 10<sup>4</sup></code></li>
+	<li><code>arr[i]</code> is <code>0</code> or <code>1</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/three-equal-parts/three-equal-parts.cpp b/three-equal-parts/three-equal-parts.cpp
new file mode 100644
index 0000000..39463a2
--- /dev/null
+++ b/three-equal-parts/three-equal-parts.cpp
@@ -0,0 +1,19 @@
+class Solution {
+public:
+    vector<int> threeEqualParts(vector<int>& A) {
+        vector<int> dp;
+        for(int i = 0 ; i < A.size(); i++) // this loop is used to store the index of all 1s
+            if(A[i]) dp.push_back(i);
+        if(dp.size() % 3) return {-1, -1}; // if the number of 1s cannot be devided perfectly by 3, the input is invalid
+	if(dp.empty()) return {0,2}; // if the number of 1 is zero, then it is natually valid, return {0, 2}
+        int l1 = 0, l2 = dp.size() / 3, l3 = l2 * 2; //if we want to devide into 3 parts, the distribution pattern of 1s in three parts should be the same
+        for(int i = 1; i < l2; i++ ) {
+            int diff = dp[i] - dp[i-1];
+            if(dp[l2+i] - dp[l2+i-1] != diff || dp[l3+i] - dp[l3+i-1] != diff) //unmatched pattern
+                return {-1, -1};
+	}
+        int tail0 = A.size() - dp.back(); // calculate how many 0s tail
+        if(dp[l3] - dp[l3-1] < tail0 ||   dp[l2] - dp[l2-1] < tail0) return {-1,-1};// all three parts should tail with the same number of 0s with that in the last part
+        return {dp[l2-1] + tail0 - 1, dp[l3-1] + tail0};
+    }
+};
\ No newline at end of file
diff --git a/total-hamming-distance/README.md b/total-hamming-distance/README.md
new file mode 100644
index 0000000..bf3c00a
--- /dev/null
+++ b/total-hamming-distance/README.md
@@ -0,0 +1,30 @@
+<h2>477. Total Hamming Distance</h2><h3>Medium</h3><hr><div><p>The <a href="https://en.wikipedia.org/wiki/Hamming_distance" target="_blank">Hamming distance</a> between two integers is the number of positions at which the corresponding bits are different.</p>
+
+<p>Given an integer array <code>nums</code>, return <em>the sum of <strong>Hamming distances</strong> between all the pairs of the integers in</em> <code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [4,14,2]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> In binary representation, the 4 is 0100, 14 is 1110, and 2 is 0010 (just
+showing the four bits relevant in this case).
+The answer will be:
+HammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [4,14,4]
+<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>0 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
+	<li>The answer for the given input will fit in a <strong>32-bit</strong> integer.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/trapping-rain-water/README.md b/trapping-rain-water/README.md
new file mode 100644
index 0000000..b57dde7
--- /dev/null
+++ b/trapping-rain-water/README.md
@@ -0,0 +1,25 @@
+<h2>42. Trapping Rain Water</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/trapping-rain-water/trapping-rain-water.cpp b/trapping-rain-water/trapping-rain-water.cpp
new file mode 100644
index 0000000..4739bc5
--- /dev/null
+++ b/trapping-rain-water/trapping-rain-water.cpp
@@ -0,0 +1,32 @@
+class Solution {
+public:
+    int trap(vector<int>& height) {
+        
+        if(height.size()<=2)
+            return 0;
+        int n = height.size();
+        int l = 0;
+        int r = n-1;
+        int ans = 0;
+        int lmax = 0;
+        int rmax = 0;
+        
+        while(r>=l)
+        {
+            if(lmax>=rmax)
+            {
+                ans += max(0,rmax-height[r]);
+                rmax = max(rmax,height[r]);
+                r--;
+            }
+            else
+            {
+                ans += max(0,lmax-height[l]);
+                lmax = max(lmax,height[l]);
+                l++;
+            }
+            
+        }
+        return ans;
+    }
+};
\ No newline at end of file
diff --git a/triangle/README.md b/triangle/README.md
new file mode 100644
index 0000000..24ab426
--- /dev/null
+++ b/triangle/README.md
@@ -0,0 +1,35 @@
+<h2>120. Triangle</h2><h3>Medium</h3><hr><div><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>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>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?</div>
\ No newline at end of file
diff --git a/trim-a-binary-search-tree/README.md b/trim-a-binary-search-tree/README.md
new file mode 100644
index 0000000..d29817c
--- /dev/null
+++ b/trim-a-binary-search-tree/README.md
@@ -0,0 +1,46 @@
+<h2>669. Trim a Binary Search Tree</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><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [1], low = 1, high = 2
+<strong>Output:</strong> [1]
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,null,2], low = 1, high = 3
+<strong>Output:</strong> [1,null,2]
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> root = [1,null,2], low = 2, high = 4
+<strong>Output:</strong> [2]
+</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/trim-a-binary-search-tree/trim-a-binary-search-tree.cpp b/trim-a-binary-search-tree/trim-a-binary-search-tree.cpp
new file mode 100644
index 0000000..b99f498
--- /dev/null
+++ b/trim-a-binary-search-tree/trim-a-binary-search-tree.cpp
@@ -0,0 +1,11 @@
+class Solution {
+public:
+    TreeNode* trimBST(TreeNode* root, int L, int R) {
+        if (root == NULL) return NULL;
+        if (root->val < L) return trimBST(root->right, L, R);
+        if (root->val > R) return trimBST(root->left, L, R);
+        root->left = trimBST(root->left, L, R);
+        root->right = trimBST(root->right, L, R);
+        return root;
+    }
+};
\ No newline at end of file
diff --git a/two-sum-ii-input-array-is-sorted/README.md b/two-sum-ii-input-array-is-sorted/README.md
new file mode 100644
index 0000000..76542e8
--- /dev/null
+++ b/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;= first &lt; second &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>, 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.
+</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.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> numbers = [-1,0], 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.
+</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/two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted.cpp b/two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted.cpp
new file mode 100644
index 0000000..bf4dad0
--- /dev/null
+++ b/two-sum-ii-input-array-is-sorted/two-sum-ii-input-array-is-sorted.cpp
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        int i=0;
+      int j = nums.size()-1;
+      
+      while(i<j)
+      {
+        if(nums[i]+nums[j]>target)
+          j--;
+        else if(nums[i]+nums[j]<target)
+          i++;
+        else
+        return {i+1,j+1};
+      }
+      return {-1,-1};
+    }
+};
\ No newline at end of file
diff --git a/two-sum-iv-input-is-a-bst/README.md b/two-sum-iv-input-is-a-bst/README.md
new file mode 100644
index 0000000..13f2bec
--- /dev/null
+++ b/two-sum-iv-input-is-a-bst/README.md
@@ -0,0 +1,43 @@
+<h2>653. Two Sum IV - Input is a BST</h2><h3>Easy</h3><hr><div><p>Given the <code>root</code> of a Binary Search Tree and a target number <code>k</code>, return <em><code>true</code> if there exist two elements in the BST such that their sum is equal to the given target</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/21/sum_tree_1.jpg" style="width: 562px; height: 322px;">
+<pre><strong>Input:</strong> root = [5,3,6,2,4,null,7], k = 9
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/09/21/sum_tree_2.jpg" style="width: 562px; height: 322px;">
+<pre><strong>Input:</strong> root = [5,3,6,2,4,null,7], k = 28
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> root = [2,1,3], k = 4
+<strong>Output:</strong> true
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> root = [2,1,3], k = 1
+<strong>Output:</strong> false
+</pre>
+
+<p><strong>Example 5:</strong></p>
+
+<pre><strong>Input:</strong> root = [2,1,3], k = 3
+<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>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>-10<sup>4</sup>&nbsp;&lt;= Node.val &lt;= 10<sup>4</sup></code></li>
+	<li><code>root</code> is guaranteed to be a <strong>valid</strong> binary search tree.</li>
+	<li><code>-10<sup>5</sup>&nbsp;&lt;= k &lt;= 10<sup>5</sup></code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/two-sum-iv-input-is-a-bst/two-sum-iv-input-is-a-bst.cpp b/two-sum-iv-input-is-a-bst/two-sum-iv-input-is-a-bst.cpp
new file mode 100644
index 0000000..bef41a5
--- /dev/null
+++ b/two-sum-iv-input-is-a-bst/two-sum-iv-input-is-a-bst.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+    unordered_set<int> s;
+    bool findTarget(TreeNode* root, int k) {
+        if(!root)
+        return false;
+        if(s.count(k-root->val)) 
+        return true;
+        s.insert(root->val);
+        return findTarget(root->left,k)||findTarget(root->right,k);
+    }
+};
\ No newline at end of file
diff --git a/two-sum/README.md b/two-sum/README.md
new file mode 100644
index 0000000..5dd9f3f
--- /dev/null
+++ b/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/two-sum/two-sum.cpp b/two-sum/two-sum.cpp
new file mode 100644
index 0000000..86560ea
--- /dev/null
+++ b/two-sum/two-sum.cpp
@@ -0,0 +1,22 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        map <int,int> m;
+        vector <int> v;
+       
+        for(int i=0;i<nums.size();i++)
+        {
+            if(m.find(target - nums[i]) != m.end())
+            {
+                v.push_back(i);
+                v.push_back(m[target-nums[i]]);
+            }
+            else
+            {
+                m[nums[i]] = i;
+            }
+        }
+       
+        return v;
+    }
+};
\ No newline at end of file
diff --git a/ugly-number-ii/README.md b/ugly-number-ii/README.md
new file mode 100644
index 0000000..e5234f0
--- /dev/null
+++ b/ugly-number-ii/README.md
@@ -0,0 +1,26 @@
+<h2>264. Ugly Number II</h2><h3>Medium</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 <em>the</em> <code>n<sup>th</sup></code> <em><strong>ugly number</strong></em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> n = 10
+<strong>Output:</strong> 12
+<strong>Explanation:</strong> [1, 2, 3, 4, 5, 6, 8, 9, 10, 12] is the sequence of the first 10 ugly numbers.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> n = 1
+<strong>Output:</strong> 1
+<strong>Explanation:</strong> 1 has no prime factors, therefore all of its prime factors are limited to 2, 3, and 5.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 1690</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/ugly-number-ii/ugly-number-ii.cpp b/ugly-number-ii/ugly-number-ii.cpp
new file mode 100644
index 0000000..9724a11
--- /dev/null
+++ b/ugly-number-ii/ugly-number-ii.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+   int nthUglyNumber(int n) {
+        vector <int> results (1,1);
+        int i = 0, j = 0, k = 0;
+        while (results.size() < n)
+        {
+            results.push_back(min(results[i] * 2, min(results[j] * 3, results[k] * 5)));
+            if (results.back() == results[i] * 2) ++i;
+            if (results.back() == results[j] * 3) ++j;
+            if (results.back() == results[k] * 5) ++k;
+        }
+        return results.back();
+    }
+};
\ No newline at end of file
diff --git a/unique-binary-search-trees-ii/README.md b/unique-binary-search-trees-ii/README.md
new file mode 100644
index 0000000..09b3af2
--- /dev/null
+++ b/unique-binary-search-trees-ii/README.md
@@ -0,0 +1,22 @@
+<h2>95. Unique Binary Search Trees II</h2><h3>Medium</h3><hr><div><p>Given an integer <code>n</code>, return <em>all the 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>. Return the answer in <strong>any order</strong>.</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> [[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
+</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;= 8</code></li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/unique-binary-search-trees/README.md b/unique-binary-search-trees/README.md
new file mode 100644
index 0000000..99e5681
--- /dev/null
+++ b/unique-binary-search-trees/README.md
@@ -0,0 +1,22 @@
+<h2>96. Unique Binary Search Trees</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/unique-binary-search-trees/unique-binary-search-trees.cpp b/unique-binary-search-trees/unique-binary-search-trees.cpp
new file mode 100644
index 0000000..9700c7a
--- /dev/null
+++ b/unique-binary-search-trees/unique-binary-search-trees.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int numTrees(int n) {
+      if(n<=2)
+        return n;
+        vector <int> v(n+1);
+      v[0] = 1;
+      v[1] = 1;
+      v[2] = 2;
+      
+      for(int i=3;i<=n;i++)
+      {
+        for(int j=0;j<i;j++)
+        {
+          v[i] += v[j] * v[i-j-1];
+        }
+      }
+      
+      return v[n];
+    }
+};
\ No newline at end of file
diff --git a/unique-paths-ii/README.md b/unique-paths-ii/README.md
new file mode 100644
index 0000000..f661d9e
--- /dev/null
+++ b/unique-paths-ii/README.md
@@ -0,0 +1,35 @@
+<h2>63. Unique Paths II</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/unique-paths-iii/README.md b/unique-paths-iii/README.md
new file mode 100644
index 0000000..aadf15e
--- /dev/null
+++ b/unique-paths-iii/README.md
@@ -0,0 +1,52 @@
+<h2>980. Unique Paths III</h2><h3>Hard</h3><hr><div><p>You are given an <code>m x n</code> integer array <code>grid</code> where <code>grid[i][j]</code> could be:</p>
+
+<ul>
+	<li><code>1</code> representing the starting square. There is exactly one starting square.</li>
+	<li><code>2</code> representing the ending square. There is exactly one ending square.</li>
+	<li><code>0</code> representing empty squares we can walk over.</li>
+	<li><code>-1</code> representing obstacles that we cannot walk over.</li>
+</ul>
+
+<p>Return <em>the number of 4-directional walks from the starting square to the ending square, that walk over every non-obstacle square exactly once</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/02/lc-unique1.jpg" style="width: 324px; height: 245px;">
+<pre><strong>Input:</strong> grid = [[1,0,0,0],[0,0,0,0],[0,0,2,-1]]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> We have the following two paths: 
+1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2)
+2. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2)
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/02/lc-unique2.jpg" style="width: 324px; height: 245px;">
+<pre><strong>Input:</strong> grid = [[1,0,0,0],[0,0,0,0],[0,0,0,2]]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> We have the following four paths: 
+1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2),(2,3)
+2. (0,0),(0,1),(1,1),(1,0),(2,0),(2,1),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3)
+3. (0,0),(1,0),(2,0),(2,1),(2,2),(1,2),(1,1),(0,1),(0,2),(0,3),(1,3),(2,3)
+4. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2),(2,3)
+</pre>
+
+<p><strong>Example 3:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/02/lc-unique3-.jpg" style="width: 164px; height: 165px;">
+<pre><strong>Input:</strong> grid = [[0,1],[2,0]]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There is no path that walks over every empty square exactly once.
+Note that the starting and ending square can be anywhere in the grid.
+</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;= 20</code></li>
+	<li><code>1 &lt;= m * n &lt;= 20</code></li>
+	<li><code>-1 &lt;= grid[i][j] &lt;= 2</code></li>
+	<li>There is exactly one starting cell and one ending cell.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/unique-paths-iii/unique-paths-iii.cpp b/unique-paths-iii/unique-paths-iii.cpp
new file mode 100644
index 0000000..1591993
--- /dev/null
+++ b/unique-paths-iii/unique-paths-iii.cpp
@@ -0,0 +1,35 @@
+class Solution {
+public:
+    int res = 0, empty = 1;
+    void dfs(vector<vector<int>>& grid, int x, int y, int count) {
+        if (x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] == -1) return;
+        
+        if (grid[x][y] == 2) {
+            if(empty == count) res++; 
+            return;
+        }
+        
+        grid[x][y] = -1;
+        
+        dfs(grid, x+1, y, count+1);
+        dfs(grid, x-1, y, count+1);
+        dfs(grid, x, y+1, count+1);
+        dfs(grid, x, y-1, count+1);
+        
+        grid[x][y] = 0;
+        
+    }
+    
+    int uniquePathsIII(vector<vector<int>>& grid) {
+        int start_x, start_y;
+        for (int i = 0; i < grid.size(); i++) {
+            for (int j = 0; j < grid[0].size(); j++) {
+                if (grid[i][j] == 1) start_x = i, start_y = j;
+                else if (grid[i][j] == 0) empty++;
+            }
+        }
+        
+        dfs(grid, start_x, start_y, 0);
+        return res;
+    }
+};
\ No newline at end of file
diff --git a/unique-paths/README.md b/unique-paths/README.md
new file mode 100644
index 0000000..2bdfde0
--- /dev/null
+++ b/unique-paths/README.md
@@ -0,0 +1,44 @@
+<h2>62. Unique Paths</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>How many possible unique paths are there?</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><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> m = 7, n = 3
+<strong>Output:</strong> 28
+</pre>
+
+<p><strong>Example 4:</strong></p>
+
+<pre><strong>Input:</strong> m = 3, n = 3
+<strong>Output:</strong> 6
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= m, n &lt;= 100</code></li>
+	<li>It's guaranteed that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/unique-paths/unique-paths.cpp b/unique-paths/unique-paths.cpp
new file mode 100644
index 0000000..bdb7735
--- /dev/null
+++ b/unique-paths/unique-paths.cpp
@@ -0,0 +1,12 @@
+class Solution {
+public:
+int uniquePaths(int m, int n) {
+    int N = m+n-2;
+    int r = min(m-1,n-1);
+    long double res = 1.0;
+    for(int i=1; i<=r; i++){
+        res = res*(N-r+i)/i;
+    }
+    return (int)res;
+}
+};
\ No newline at end of file
diff --git a/valid-palindrome/README.md b/valid-palindrome/README.md
new file mode 100644
index 0000000..f27fc0c
--- /dev/null
+++ b/valid-palindrome/README.md
@@ -0,0 +1,25 @@
+<h2>125. Valid Palindrome</h2><h3>Easy</h3><hr><div><p>Given a string <code>s</code>, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.</p>
+
+<p>&nbsp;</p>
+<p><strong>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>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>&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/valid-palindrome/valid-palindrome.cpp b/valid-palindrome/valid-palindrome.cpp
new file mode 100644
index 0000000..4fe64a9
--- /dev/null
+++ b/valid-palindrome/valid-palindrome.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    bool isPalindrome(string s) {
+        string a ;
+        for(int i=0;i<s.size();i++)
+        {
+            if((s[i] >= 'a' && s[i] <= 'z' ) || (s[i] >= 'A' && s[i] <= 'Z') || s[i] >= '0' && s[i] <= '9')
+            a.push_back(tolower(s[i]));
+        }
+        for(int i=0;i<a.size();i++)
+        {
+            if(a[i] != a[a.size()-1-i])
+                return false;
+        }
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/valid-parentheses/README.md b/valid-parentheses/README.md
new file mode 100644
index 0000000..53485dc
--- /dev/null
+++ b/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/valid-parentheses/valid-parentheses.cpp b/valid-parentheses/valid-parentheses.cpp
new file mode 100644
index 0000000..d8d9095
--- /dev/null
+++ b/valid-parentheses/valid-parentheses.cpp
@@ -0,0 +1,53 @@
+class Solution {
+public:
+    bool isValid(string s) {
+        stack<char> sc;
+      
+      for(int i=0;i<s.size();i++)
+      {
+        if(s[i] == '{')
+          sc.push(s[i]);
+        else if(s[i] == '(')
+          sc.push(s[i]);
+        else if(s[i] == '[')
+          sc.push(s[i]);
+        
+        if(sc.empty())
+          return false;
+        
+        if(s[i] == '}')
+        {
+          if(sc.top() == '{')
+          {
+            sc.pop();
+          }
+          else
+          {
+            return false;
+          }
+        }
+        else if(s[i] == ']')
+        {
+          if(sc.top() == '[')
+          {
+            sc.pop();
+          }
+          else
+            return false;
+        }
+        else if(s[i] == ')')
+        {
+          if(sc.top() == '(')
+            sc.pop();
+          else
+            return false;
+        }
+          
+      }
+      
+      if(sc.empty())
+        return true;
+      else
+        return false;
+    }
+};
\ No newline at end of file
diff --git a/valid-sudoku/README.md b/valid-sudoku/README.md
new file mode 100644
index 0000000..041f971
--- /dev/null
+++ b/valid-sudoku/README.md
@@ -0,0 +1,56 @@
+<h2>36. Valid Sudoku</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 or <code>'.'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/valid-sudoku/valid-sudoku.cpp b/valid-sudoku/valid-sudoku.cpp
new file mode 100644
index 0000000..76969b6
--- /dev/null
+++ b/valid-sudoku/valid-sudoku.cpp
@@ -0,0 +1,20 @@
+class Solution
+{
+public:
+    bool isValidSudoku(vector<vector<char> > &board)
+    {
+        int used1[9][9] = {0}, used2[9][9] = {0}, used3[9][9] = {0};
+        
+        for(int i = 0; i < board.size(); ++ i)
+            for(int j = 0; j < board[i].size(); ++ j)
+                if(board[i][j] != '.')
+                {
+                    int num = board[i][j] - '0' - 1, k = i / 3 * 3 + j / 3;
+                    if(used1[i][num] || used2[j][num] || used3[k][num])
+                        return false;
+                    used1[i][num] = used2[j][num] = used3[k][num] = 1;
+                }
+        
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/valid-triangle-number/README.md b/valid-triangle-number/README.md
new file mode 100644
index 0000000..d662112
--- /dev/null
+++ b/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/valid-triangle-number/valid-triangle-number.cpp b/valid-triangle-number/valid-triangle-number.cpp
new file mode 100644
index 0000000..ba2e732
--- /dev/null
+++ b/valid-triangle-number/valid-triangle-number.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int triangleNumber(vector<int>& nums) {
+        vector<int> snums(nums);
+        sort(snums.begin(), snums.end());
+        int count = 0;
+        for ( int n = nums.size(), k = n - 1; k > 1; --k ) {
+            int i = 0, j = k - 1;
+            while ( i < j ) {
+                // any value x between i...j will satisfy snums[x] + snums[j] > snums[k]
+                // and because snums[k] > snums[j] > snums[x] >= 0, they will always satisfy
+                // snums[k] + snums[x] > snums[j] and snums[k] + snums[j] > snums[x]
+                if ( snums[i] + snums[j] > snums[k] )
+                    count += --j - i + 1;
+                else
+                    ++i;
+            }
+        }
+        return count;
+    }
+};
\ No newline at end of file
diff --git a/validate-binary-search-tree/README.md b/validate-binary-search-tree/README.md
new file mode 100644
index 0000000..3e6f61c
--- /dev/null
+++ b/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/validate-binary-search-tree/validate-binary-search-tree.cpp b/validate-binary-search-tree/validate-binary-search-tree.cpp
new file mode 100644
index 0000000..e96e563
--- /dev/null
+++ b/validate-binary-search-tree/validate-binary-search-tree.cpp
@@ -0,0 +1,43 @@
+/**
+ * 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:
+    bool isValidBST(TreeNode* root) {
+        
+        if(root == NULL)
+            return true;
+        
+        stack <TreeNode * > s;
+        TreeNode * temp = NULL;
+        while(root != NULL ||  !s.empty())
+        {
+            
+            if(root != NULL)
+            { 
+                s.push(root);
+                root = root->left;
+            }
+            else
+            {
+                root = s.top();
+                s.pop();
+                if(temp != NULL && temp->val >= root->val)
+                    return false;
+                temp = root;
+                root = root->right;
+            }
+            
+        }
+        
+        return true;
+    }
+};
\ No newline at end of file
diff --git a/verify-preorder-serialization-of-a-binary-tree/README.md b/verify-preorder-serialization-of-a-binary-tree/README.md
new file mode 100644
index 0000000..fe3a558
--- /dev/null
+++ b/verify-preorder-serialization-of-a-binary-tree/README.md
@@ -0,0 +1,35 @@
+<h2>331. Verify Preorder Serialization of a Binary Tree</h2><h3>Medium</h3><hr><div><p>One way to serialize a binary tree is to use <strong>preorder traversal</strong>. When we encounter a non-null node, we record the node's value. If it is a null node, we record using a sentinel value such as <code>'#'</code>.</p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/03/12/pre-tree.jpg" style="width: 362px; height: 293px;">
+<p>For example, the above binary tree can be serialized to the string <code>"9,3,4,#,#,1,#,#,2,#,6,#,#"</code>, where <code>'#'</code> represents a null node.</p>
+
+<p>Given a string of comma-separated values <code>preorder</code>, return <code>true</code> if it is a correct preorder traversal serialization of a binary tree.</p>
+
+<p>It is <strong>guaranteed</strong> that each comma-separated value in the string must be either an integer or a character <code>'#'</code> representing null pointer.</p>
+
+<p>You may assume that the input format is always valid.</p>
+
+<ul>
+	<li>For example, it could never contain two consecutive commas, such as <code>"1,,3"</code>.</li>
+</ul>
+
+<p><strong>Note:&nbsp;</strong>You are not allowed to reconstruct the tree.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<pre><strong>Input:</strong> preorder = "9,3,4,#,#,1,#,#,2,#,6,#,#"
+<strong>Output:</strong> true
+</pre><p><strong>Example 2:</strong></p>
+<pre><strong>Input:</strong> preorder = "1,#"
+<strong>Output:</strong> false
+</pre><p><strong>Example 3:</strong></p>
+<pre><strong>Input:</strong> preorder = "9,#,#,1"
+<strong>Output:</strong> false
+</pre>
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= preorder.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>preoder</code> consist of integers in the range <code>[0, 100]</code> and <code>'#'</code> separated by commas <code>','</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/verify-preorder-serialization-of-a-binary-tree/verify-preorder-serialization-of-a-binary-tree.cpp b/verify-preorder-serialization-of-a-binary-tree/verify-preorder-serialization-of-a-binary-tree.cpp
new file mode 100644
index 0000000..a9cdf7e
--- /dev/null
+++ b/verify-preorder-serialization-of-a-binary-tree/verify-preorder-serialization-of-a-binary-tree.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+bool isValidSerialization(string preorder) {
+    if (preorder.empty()) return false;
+    preorder+=',';
+    int sz=preorder.size(),idx=0;
+    int capacity=1;
+    for (idx=0;idx<sz;idx++){
+        if (preorder[idx]!=',') continue;
+        capacity--;
+        if (capacity<0) return false;
+        if (preorder[idx-1]!='#') capacity+=2;
+    }
+    return capacity==0;
+}
+};
\ No newline at end of file
diff --git a/walking-robot-simulation-ii/README.md b/walking-robot-simulation-ii/README.md
new file mode 100644
index 0000000..7b85d5b
--- /dev/null
+++ b/walking-robot-simulation-ii/README.md
@@ -0,0 +1,55 @@
+<h2>2069. Walking Robot Simulation II</h2><h3>Medium</h3><hr><div><p>A <code>width x height</code> grid is on an XY-plane with the <strong>bottom-left</strong> cell at <code>(0, 0)</code> and the <strong>top-right</strong> cell at <code>(width - 1, height - 1)</code>. The grid is aligned with the four cardinal directions (<code>"North"</code>, <code>"East"</code>, <code>"South"</code>, and <code>"West"</code>). A robot is <strong>initially</strong> at cell <code>(0, 0)</code> facing direction <code>"East"</code>.</p>
+
+<p>The robot can be instructed to move for a specific number of <strong>steps</strong>. For each step, it does the following.</p>
+
+<ol>
+	<li>Attempts to move <strong>forward one</strong> cell in the direction it is facing.</li>
+	<li>If the cell the robot is <strong>moving to</strong> is <strong>out of bounds</strong>, the robot instead <strong>turns</strong> 90 degrees <strong>counterclockwise</strong> and retries the step.</li>
+</ol>
+
+<p>After the robot finishes moving the number of steps required, it stops and awaits the next instruction.</p>
+
+<p>Implement the <code>Robot</code> class:</p>
+
+<ul>
+	<li><code>Robot(int width, int height)</code> Initializes the <code>width x height</code> grid with the robot at <code>(0, 0)</code> facing <code>"East"</code>.</li>
+	<li><code>void move(int num)</code> Instructs the robot to move forward <code>num</code> steps.</li>
+	<li><code>int[] getPos()</code> Returns the current cell the robot is at, as an array of length 2, <code>[x, y]</code>.</li>
+	<li><code>String getDir()</code> Returns the current direction of the robot, <code>"North"</code>, <code>"East"</code>, <code>"South"</code>, or <code>"West"</code>.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="example-1" src="https://assets.leetcode.com/uploads/2021/10/09/example-1.png" style="width: 498px; height: 268px;">
+<pre><strong>Input</strong>
+["Robot", "move", "move", "getPos", "getDir", "move", "move", "move", "getPos", "getDir"]
+[[6, 3], [2], [2], [], [], [2], [1], [4], [], []]
+<strong>Output</strong>
+[null, null, null, [4, 0], "East", null, null, null, [1, 2], "West"]
+
+<strong>Explanation</strong>
+Robot robot = new Robot(6, 3); // Initialize the grid and the robot at (0, 0) facing East.
+robot.move(2);  // It moves two steps East to (2, 0), and faces East.
+robot.move(2);  // It moves two steps East to (4, 0), and faces East.
+robot.getPos(); // return [4, 0]
+robot.getDir(); // return "East"
+robot.move(2);  // It moves one step East to (5, 0), and faces East.
+                // Moving the next step East would be out of bounds, so it turns and faces North.
+                // Then, it moves one step North to (5, 1), and faces North.
+robot.move(1);  // It moves one step North to (5, 2), and faces <strong>North</strong> (not West).
+robot.move(4);  // Moving the next step North would be out of bounds, so it turns and faces West.
+                // Then, it moves four steps West to (1, 2), and faces West.
+robot.getPos(); // return [1, 2]
+robot.getDir(); // return "West"
+
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= width, height &lt;= 100</code></li>
+	<li><code>1 &lt;= num &lt;= 10<sup>5</sup></code></li>
+	<li>At most <code>10<sup>4</sup></code> calls <strong>in total</strong> will be made to <code>move</code>, <code>getPos</code>, and <code>getDir</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/walking-robot-simulation-ii/walking-robot-simulation-ii.cpp b/walking-robot-simulation-ii/walking-robot-simulation-ii.cpp
new file mode 100644
index 0000000..7217a4b
--- /dev/null
+++ b/walking-robot-simulation-ii/walking-robot-simulation-ii.cpp
@@ -0,0 +1,28 @@
+class Robot {
+    int dir = 0, dirs[4][2] = {{1,0},{0,1},{-1,0},{0,-1}}, w, h, perimeter, x = 0, y = 0;
+    string text[4] = {"East","North","West","South"};
+public:
+    Robot(int width, int height) : w(width), h(height), perimeter(2*(w + h - 2)) {}
+    void move(int k) {
+        if (k >= perimeter) {
+            k %= perimeter;
+            if (x == 0 && y == 0 && dir == 0) dir = 3; // Special case: if we are at the beginning (x = 0, y = 0 and facing east), after the round trip, the direction becomes south.
+        }
+        while (k > 0) {
+            auto &[dx, dy] = dirs[dir];
+            int nx = x + dx, ny = y + dy;
+            if (nx < 0 || ny < 0 || nx >= w || ny >= h) {
+                dir = (dir + 1) % 4;
+            } else {
+                x = nx, y = ny;
+                --k;
+            }
+        }
+    }
+    vector<int> getPos() {
+        return {x,y};
+    }
+    string getDir() {
+        return text[dir];
+    }
+};
\ No newline at end of file
diff --git a/wiggle-subsequence/README.md b/wiggle-subsequence/README.md
new file mode 100644
index 0000000..e4366ed
--- /dev/null
+++ b/wiggle-subsequence/README.md
@@ -0,0 +1,44 @@
+<h2>376. Wiggle Subsequence</h2><h3>Medium</h3><hr><div><p>A <strong>wiggle sequence</strong> is a sequence where the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with one element and a sequence with two non-equal elements are trivially wiggle sequences.</p>
+
+<ul>
+	<li>For example, <code>[1, 7, 4, 9, 2, 5]</code> is a <strong>wiggle sequence</strong> because the differences <code>(6, -3, 5, -7, 3)</code> alternate between positive and negative.</li>
+	<li>In contrast, <code>[1, 4, 7, 2, 5]</code> and <code>[1, 7, 4, 5, 5]</code> are not wiggle sequences. The first is not because its first two differences are positive, and the second is not because its last difference is zero.</li>
+</ul>
+
+<p>A <strong>subsequence</strong> is obtained by deleting some elements (possibly zero) from the original sequence, leaving the remaining elements in their original order.</p>
+
+<p>Given an integer array <code>nums</code>, return <em>the length of the longest <strong>wiggle subsequence</strong> of </em><code>nums</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,7,4,9,2,5]
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> The entire sequence is a wiggle sequence with differences (6, -3, 5, -7, 3).
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,17,5,10,13,15,10,5,16,8]
+<strong>Output:</strong> 7
+<strong>Explanation:</strong> There are several subsequences that achieve this length.
+One is [1, 17, 10, 13, 10, 16, 8] with differences (16, -7, 3, -3, 6, -8).
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,2,3,4,5,6,7,8,9]
+<strong>Output:</strong> 2
+</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>
+
+<p>&nbsp;</p>
+<p><strong>Follow up:</strong> Could you solve this in <code>O(n)</code> time?</p>
+</div>
\ No newline at end of file
diff --git a/wiggle-subsequence/wiggle-subsequence.cpp b/wiggle-subsequence/wiggle-subsequence.cpp
new file mode 100644
index 0000000..3431152
--- /dev/null
+++ b/wiggle-subsequence/wiggle-subsequence.cpp
@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int wiggleMaxLength(vector<int>& nums) {
+         if (nums.size() < 2)
+            return nums.size();
+        int down = 1, up = 1;
+        for (int i = 1; i < nums.size(); i++) {
+            if (nums[i] > nums[i - 1])
+                up = down + 1;
+            else if (nums[i] < nums[i - 1])
+                down = up + 1;
+        }
+        return max(down, up);
+    }
+};
\ No newline at end of file
diff --git a/wildcard-matching/README.md b/wildcard-matching/README.md
new file mode 100644
index 0000000..38edee9
--- /dev/null
+++ b/wildcard-matching/README.md
@@ -0,0 +1,40 @@
+<h2>44. Wildcard Matching</h2><h3>Hard</h3><hr><div><p>Given an input string (<code>s</code>) and a pattern (<code>p</code>), implement wildcard pattern matching with support for <code>'?'</code> and <code>'*'</code> where:</p>
+
+<ul>
+	<li><code>'?'</code> Matches any single character.</li>
+	<li><code>'*'</code> Matches any sequence of characters (including the empty sequence).</li>
+</ul>
+
+<p>The matching should cover the <strong>entire</strong> input string (not partial).</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "aa", p = "a"
+<strong>Output:</strong> false
+<strong>Explanation:</strong> "a" does not match the entire string "aa".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "aa", p = "*"
+<strong>Output:</strong> true
+<strong>Explanation:</strong>&nbsp;'*' matches any sequence.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "cb", p = "?a"
+<strong>Output:</strong> false
+<strong>Explanation:</strong>&nbsp;'?' matches 'c', but the second letter is 'a', which does not match 'b'.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>0 &lt;= s.length, p.length &lt;= 2000</code></li>
+	<li><code>s</code> contains only lowercase English letters.</li>
+	<li><code>p</code> contains only lowercase English letters, <code>'?'</code> or <code>'*'</code>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/word-break/README.md b/word-break/README.md
new file mode 100644
index 0000000..49efd2b
--- /dev/null
+++ b/word-break/README.md
@@ -0,0 +1,37 @@
+<h2>139. Word Break</h2><h3>Medium</h3><hr><div><p>Given a string <code>s</code> and a dictionary of strings <code>wordDict</code>, return <code>true</code> if <code>s</code> can be segmented into a space-separated sequence of one or more dictionary words.</p>
+
+<p><strong>Note</strong> that the same word in the dictionary may be reused multiple times in the segmentation.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> s = "leetcode", wordDict = ["leet","code"]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Return true because "leetcode" can be segmented as "leet code".
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> s = "applepenapple", wordDict = ["apple","pen"]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Return true because "applepenapple" can be segmented as "apple pen apple".
+Note that you are allowed to reuse a dictionary word.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre><strong>Input:</strong> s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
+<strong>Output:</strong> false
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 300</code></li>
+	<li><code>1 &lt;= wordDict.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= wordDict[i].length &lt;= 20</code></li>
+	<li><code>s</code> and <code>wordDict[i]</code> consist of only lowercase English letters.</li>
+	<li>All the strings of <code>wordDict</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/word-break/word-break.cpp b/word-break/word-break.cpp
new file mode 100644
index 0000000..8162a13
--- /dev/null
+++ b/word-break/word-break.cpp
@@ -0,0 +1,16 @@
+class Solution {
+public:
+    bool wordBreak(string s, vector<string>& wordDict) {
+        vector<bool> dp(s.size()+1, false);
+        dp[0] = true;
+        
+        // we mark as true every index that we managed to segment so far
+        for (int i = 1; i <= s.size(); i++)
+            for (int j = 0; j < i; j++)
+                if ((dp[j]) && (find(wordDict.begin(), wordDict.end(), s.substr(j, i-j)) != wordDict.end())) {
+                    dp[i] = true;
+                    break;
+                }
+        return dp.back();
+    }
+};
\ No newline at end of file
diff --git a/word-ladder/README.md b/word-ladder/README.md
new file mode 100644
index 0000000..30efa8f
--- /dev/null
+++ b/word-ladder/README.md
@@ -0,0 +1,38 @@
+<h2>127. Word Ladder</h2><h3>Hard</h3><hr><div><p>A <strong>transformation sequence</strong> from word <code>beginWord</code> to word <code>endWord</code> using a dictionary <code>wordList</code> is a sequence of words <code>beginWord -&gt; s<sub>1</sub> -&gt; s<sub>2</sub> -&gt; ... -&gt; s<sub>k</sub></code> such that:</p>
+
+<ul>
+	<li>Every adjacent pair of words differs by a single letter.</li>
+	<li>Every <code>s<sub>i</sub></code> for <code>1 &lt;= i &lt;= k</code> is in <code>wordList</code>. Note that <code>beginWord</code> does not need to be in <code>wordList</code>.</li>
+	<li><code>s<sub>k</sub> == endWord</code></li>
+</ul>
+
+<p>Given two words, <code>beginWord</code> and <code>endWord</code>, and a dictionary <code>wordList</code>, return <em>the <strong>number of words</strong> in the <strong>shortest transformation sequence</strong> from</em> <code>beginWord</code> <em>to</em> <code>endWord</code><em>, or </em><code>0</code><em> if no such sequence exists.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> One shortest transformation sequence is "hit" -&gt; "hot" -&gt; "dot" -&gt; "dog" -&gt; cog", which is 5 words long.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> The endWord "cog" is not in wordList, therefore there is no valid transformation sequence.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= beginWord.length &lt;= 10</code></li>
+	<li><code>endWord.length == beginWord.length</code></li>
+	<li><code>1 &lt;= wordList.length &lt;= 5000</code></li>
+	<li><code>wordList[i].length == beginWord.length</code></li>
+	<li><code>beginWord</code>, <code>endWord</code>, and <code>wordList[i]</code> consist of lowercase English letters.</li>
+	<li><code>beginWord != endWord</code></li>
+	<li>All the words in <code>wordList</code> are <strong>unique</strong>.</li>
+</ul>
+</div>
\ No newline at end of file
diff --git a/word-search/README.md b/word-search/README.md
new file mode 100644
index 0000000..9898373
--- /dev/null
+++ b/word-search/README.md
@@ -0,0 +1,37 @@
+<h2>79. Word Search</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/xor-queries-of-a-subarray/README.md b/xor-queries-of-a-subarray/README.md
new file mode 100644
index 0000000..d94ff17
--- /dev/null
+++ b/xor-queries-of-a-subarray/README.md
@@ -0,0 +1,35 @@
+<h2>1310. XOR Queries of a Subarray</h2><h3>Medium</h3><hr><div>Given the array <code>arr</code> of positive integers and the array <code>queries</code> where <code>queries[i] = [L<sub>i,&nbsp;</sub>R<sub>i</sub>]</code>,&nbsp;for each query <code>i</code> compute the <strong>XOR</strong> of elements from <code>L<sub>i</sub></code> to <code>Ri</code> (that is, <code>arr[L<sub>i</sub>] <strong>xor</strong> arr[L<sub>i+1</sub>] <strong>xor</strong> ... <strong>xor</strong> arr[R<sub>i</sub>]</code> ). Return an array containing the result for the given <code>queries</code>.
+<p>&nbsp;</p>
+<p><strong>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>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 &lt;= 3 *&nbsp;10^4</code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 10^9</code></li>
+	<li><code>1 &lt;= queries.length &lt;= 3 * 10^4</code></li>
+	<li><code>queries[i].length == 2</code></li>
+	<li><code>0 &lt;= queries[i][0] &lt;= queries[i][1] &lt; arr.length</code></li>
+</ul></div>
\ No newline at end of file