├── .gitignore ├── 0003-longest-substring-without-repeating-characters ├── 0003-longest-substring-without-repeating-characters.cpp └── README.md ├── 0019-remove-nth-node-from-end-of-list ├── 0019-remove-nth-node-from-end-of-list.cpp └── README.md ├── 0023-merge-k-sorted-lists ├── 0023-merge-k-sorted-lists.cpp └── README.md ├── 0026-remove-duplicates-from-sorted-array ├── 0026-remove-duplicates-from-sorted-array.cpp └── README.md ├── 0033-search-in-rotated-sorted-array ├── 0033-search-in-rotated-sorted-array.cpp └── README.md ├── 0034-find-first-and-last-position-of-element-in-sorted-array ├── 0034-find-first-and-last-position-of-element-in-sorted-array.cpp └── README.md ├── 0037-sudoku-solver ├── 0037-sudoku-solver.cpp └── README.md ├── 0039-combination-sum ├── 0039-combination-sum.cpp └── README.md ├── 0040-combination-sum-ii ├── 0040-combination-sum-ii.cpp └── README.md ├── 0041-first-missing-positive ├── 0041-first-missing-positive.cpp └── README.md ├── 0042-trapping-rain-water ├── 0042-trapping-rain-water.cpp └── README.md ├── 0046-permutations ├── 0046-permutations.cpp └── README.md ├── 0048-rotate-image ├── 0048-rotate-image.cpp └── README.md ├── 0051-n-queens ├── 0051-n-queens.cpp └── README.md ├── 0059-spiral-matrix-ii ├── 0059-spiral-matrix-ii.cpp └── README.md ├── 0064-minimum-path-sum ├── 0064-minimum-path-sum.cpp └── README.md ├── 0068-text-justification ├── 0068-text-justification.cpp └── README.md ├── 0076-minimum-window-substring ├── 0076-minimum-window-substring.cpp └── README.md ├── 0077-combinations ├── 0077-combinations.cpp └── README.md ├── 0078-subsets ├── 0078-subsets.cpp └── README.md ├── 0080-remove-duplicates-from-sorted-array-ii ├── 0080-remove-duplicates-from-sorted-array-ii.cpp └── README.md ├── 0082-remove-duplicates-from-sorted-list-ii ├── 0082-remove-duplicates-from-sorted-list-ii.cpp └── README.md ├── 0083-remove-duplicates-from-sorted-list ├── 0083-remove-duplicates-from-sorted-list.cpp └── README.md ├── 0084-largest-rectangle-in-histogram ├── 0084-largest-rectangle-in-histogram.cpp └── README.md ├── 0086-partition-list ├── 0086-partition-list.cpp └── README.md ├── 0090-subsets-ii ├── 0090-subsets-ii.cpp └── README.md ├── 0091-decode-ways ├── 0091-decode-ways.cpp └── README.md ├── 0095-unique-binary-search-trees-ii ├── 0095-unique-binary-search-trees-ii.cpp └── README.md ├── 0096-unique-binary-search-trees ├── 0096-unique-binary-search-trees.cpp └── README.md ├── 0098-validate-binary-search-tree ├── 0098-validate-binary-search-tree.cpp └── README.md ├── 0101-symmetric-tree ├── 0101-symmetric-tree.cpp └── README.md ├── 0102-binary-tree-level-order-traversal ├── 0102-binary-tree-level-order-traversal.cpp └── README.md ├── 0104-maximum-depth-of-binary-tree ├── 0104-maximum-depth-of-binary-tree.cpp └── README.md ├── 0108-convert-sorted-array-to-binary-search-tree ├── 0108-convert-sorted-array-to-binary-search-tree.cpp └── README.md ├── 0110-balanced-binary-tree ├── 0110-balanced-binary-tree.cpp └── README.md ├── 0112-path-sum ├── 0112-path-sum.cpp └── README.md ├── 0131-palindrome-partitioning ├── 0131-palindrome-partitioning.cpp └── README.md ├── 0134-gas-station ├── 0134-gas-station.cpp └── README.md ├── 0143-reorder-list ├── 0143-reorder-list.cpp └── README.md ├── 0145-binary-tree-postorder-traversal ├── 0145-binary-tree-postorder-traversal.cpp └── README.md ├── 0146-lru-cache ├── 0146-lru-cache.cpp └── README.md ├── 0148-sort-list ├── 0148-sort-list.cpp └── README.md ├── 0150-evaluate-reverse-polish-notation ├── 0150-evaluate-reverse-polish-notation.cpp └── README.md ├── 0151-reverse-words-in-a-string ├── 0151-reverse-words-in-a-string.cpp └── README.md ├── 0152-maximum-product-subarray ├── 0152-maximum-product-subarray.cpp └── README.md ├── 0153-find-minimum-in-rotated-sorted-array ├── 0153-find-minimum-in-rotated-sorted-array.cpp └── README.md ├── 0173-binary-search-tree-iterator ├── 0173-binary-search-tree-iterator.cpp └── README.md ├── 0197-rising-temperature ├── 0197-rising-temperature.sql └── README.md ├── 0199-binary-tree-right-side-view ├── 0199-binary-tree-right-side-view.cpp └── README.md ├── 0208-implement-trie-prefix-tree ├── 0208-implement-trie-prefix-tree.cpp └── README.md ├── 0209-minimum-size-subarray-sum ├── 0209-minimum-size-subarray-sum.cpp └── README.md ├── 0212-word-search-ii ├── 0212-word-search-ii.cpp └── README.md ├── 0214-shortest-palindrome ├── 0214-shortest-palindrome.cpp └── README.md ├── 0215-kth-largest-element-in-an-array ├── 0215-kth-largest-element-in-an-array.cpp └── README.md ├── 0219-contains-duplicate-ii ├── 0219-contains-duplicate-ii.cpp └── README.md ├── 0230-kth-smallest-element-in-a-bst ├── 0230-kth-smallest-element-in-a-bst.cpp └── README.md ├── 0235-lowest-common-ancestor-of-a-binary-search-tree ├── 0235-lowest-common-ancestor-of-a-binary-search-tree.cpp └── README.md ├── 0236-lowest-common-ancestor-of-a-binary-tree ├── 0236-lowest-common-ancestor-of-a-binary-tree.cpp └── README.md ├── 0239-sliding-window-maximum ├── 0239-sliding-window-maximum.cpp └── README.md ├── 0241-different-ways-to-add-parentheses ├── 0241-different-ways-to-add-parentheses.cpp └── README.md ├── 0257-binary-tree-paths ├── 0257-binary-tree-paths.cpp └── README.md ├── 0258-add-digits ├── 0258-add-digits.cpp └── README.md ├── 0263-ugly-number ├── 0263-ugly-number.cpp └── README.md ├── 0264-ugly-number-ii ├── 0264-ugly-number-ii.cpp └── README.md ├── 0273-integer-to-english-words ├── 0273-integer-to-english-words.cpp └── README.md ├── 0289-game-of-life ├── 0289-game-of-life.cpp └── README.md ├── 0300-longest-increasing-subsequence ├── 0300-longest-increasing-subsequence.cpp └── README.md ├── 0303-range-sum-query-immutable ├── 0303-range-sum-query-immutable.cpp └── README.md ├── 0307-range-sum-query-mutable ├── 0307-range-sum-query-mutable.cpp └── README.md ├── 0322-coin-change ├── 0322-coin-change.cpp └── README.md ├── 0338-counting-bits ├── 0338-counting-bits.cpp └── README.md ├── 0341-flatten-nested-list-iterator ├── 0341-flatten-nested-list-iterator.cpp └── README.md ├── 0347-top-k-frequent-elements ├── 0347-top-k-frequent-elements.cpp └── README.md ├── 0378-kth-smallest-element-in-a-sorted-matrix ├── 0378-kth-smallest-element-in-a-sorted-matrix.cpp └── README.md ├── 0381-insert-delete-getrandom-o1-duplicates-allowed ├── 0381-insert-delete-getrandom-o1-duplicates-allowed.cpp └── README.md ├── 0386-lexicographical-numbers ├── 0386-lexicographical-numbers.cpp └── README.md ├── 0394-decode-string ├── 0394-decode-string.cpp └── README.md ├── 0404-sum-of-left-leaves ├── 0404-sum-of-left-leaves.cpp └── README.md ├── 0410-split-array-largest-sum ├── 0410-split-array-largest-sum.cpp └── README.md ├── 0416-partition-equal-subset-sum ├── 0416-partition-equal-subset-sum.cpp └── README.md ├── 0424-longest-repeating-character-replacement ├── 0424-longest-repeating-character-replacement.cpp └── README.md ├── 0432-all-oone-data-structure ├── 0432-all-oone-data-structure.cpp └── README.md ├── 0435-non-overlapping-intervals ├── 0435-non-overlapping-intervals.cpp └── README.md ├── 0438-find-all-anagrams-in-a-string ├── 0438-find-all-anagrams-in-a-string.cpp └── README.md ├── 0440-k-th-smallest-in-lexicographical-order ├── 0440-k-th-smallest-in-lexicographical-order.cpp └── README.md ├── 0462-minimum-moves-to-equal-array-elements-ii ├── 0462-minimum-moves-to-equal-array-elements-ii.cpp └── README.md ├── 0474-ones-and-zeroes ├── 0474-ones-and-zeroes.cpp └── README.md ├── 0476-number-complement ├── 0476-number-complement.cpp └── README.md ├── 0493-reverse-pairs ├── 0493-reverse-pairs.cpp └── README.md ├── 0494-target-sum ├── 0494-target-sum.cpp └── README.md ├── 0526-beautiful-arrangement ├── 0526-beautiful-arrangement.cpp └── README.md ├── 0530-minimum-absolute-difference-in-bst ├── 0530-minimum-absolute-difference-in-bst.cpp └── README.md ├── 0539-minimum-time-difference ├── 0539-minimum-time-difference.cpp └── README.md ├── 0541-reverse-string-ii ├── 0541-reverse-string-ii.cpp └── README.md ├── 0547-number-of-provinces ├── 0547-number-of-provinces.cpp └── README.md ├── 0564-find-the-closest-palindrome ├── 0564-find-the-closest-palindrome.cpp └── README.md ├── 0567-permutation-in-string ├── 0567-permutation-in-string.cpp └── README.md ├── 0570-managers-with-at-least-5-direct-reports ├── 0570-managers-with-at-least-5-direct-reports.sql └── README.md ├── 0572-subtree-of-another-tree ├── 0572-subtree-of-another-tree.cpp └── README.md ├── 0577-employee-bonus ├── 0577-employee-bonus.sql └── README.md ├── 0584-find-customer-referee ├── 0584-find-customer-referee.sql └── README.md ├── 0587-erect-the-fence ├── 0587-erect-the-fence.cpp └── README.md ├── 0592-fraction-addition-and-subtraction ├── 0592-fraction-addition-and-subtraction.cpp └── README.md ├── 0595-big-countries ├── 0595-big-countries.sql └── README.md ├── 0617-merge-two-binary-trees ├── 0617-merge-two-binary-trees.cpp └── README.md ├── 0620-not-boring-movies ├── 0620-not-boring-movies.sql └── README.md ├── 0621-task-scheduler ├── 0621-task-scheduler.cpp └── README.md ├── 0624-maximum-distance-in-arrays ├── 0624-maximum-distance-in-arrays.cpp └── README.md ├── 0632-smallest-range-covering-elements-from-k-lists ├── 0632-smallest-range-covering-elements-from-k-lists.cpp └── README.md ├── 0650-2-keys-keyboard ├── 0650-2-keys-keyboard.cpp └── README.md ├── 0662-maximum-width-of-binary-tree ├── 0662-maximum-width-of-binary-tree.cpp └── README.md ├── 0664-strange-printer ├── 0664-strange-printer.cpp └── README.md ├── 0698-partition-to-k-equal-sum-subsets ├── 0698-partition-to-k-equal-sum-subsets.cpp └── README.md ├── 0713-subarray-product-less-than-k ├── 0713-subarray-product-less-than-k.cpp └── README.md ├── 0718-maximum-length-of-repeated-subarray ├── 0718-maximum-length-of-repeated-subarray.cpp └── README.md ├── 0719-find-k-th-smallest-pair-distance ├── 0719-find-k-th-smallest-pair-distance.cpp └── README.md ├── 0729-my-calendar-i ├── 0729-my-calendar-i.cpp └── README.md ├── 0731-my-calendar-ii ├── 0731-my-calendar-ii.cpp └── README.md ├── 0739-daily-temperatures ├── 0739-daily-temperatures.cpp └── README.md ├── 0776-n-ary-tree-postorder-traversal ├── 0776-n-ary-tree-postorder-traversal.cpp └── README.md ├── 0778-reorganize-string ├── 0778-reorganize-string.cpp └── README.md ├── 0789-kth-largest-element-in-a-stream ├── 0789-kth-largest-element-in-a-stream.cpp └── README.md ├── 0859-design-circular-deque ├── 0859-design-circular-deque.cpp └── README.md ├── 0870-magic-squares-in-grid ├── 0870-magic-squares-in-grid.cpp └── README.md ├── 0887-minimum-cost-to-hire-k-workers ├── 0887-minimum-cost-to-hire-k-workers.cpp └── README.md ├── 0890-lemonade-change ├── 0890-lemonade-change.cpp └── README.md ├── 0893-all-nodes-distance-k-in-binary-tree ├── 0893-all-nodes-distance-k-in-binary-tree.cpp └── README.md ├── 0906-walking-robot-simulation ├── 0906-walking-robot-simulation.cpp └── README.md ├── 0920-uncommon-words-from-two-sentences ├── 0920-uncommon-words-from-two-sentences.cpp └── README.md ├── 0921-spiral-matrix-iii ├── 0921-spiral-matrix-iii.cpp └── README.md ├── 0937-online-stock-span ├── 0937-online-stock-span.cpp └── README.md ├── 0943-sum-of-subarray-minimums ├── 0943-sum-of-subarray-minimums.cpp └── README.md ├── 0948-sort-an-array ├── 0948-sort-an-array.cpp └── README.md ├── 0957-minimum-add-to-make-parentheses-valid ├── 0957-minimum-add-to-make-parentheses-valid.cpp └── README.md ├── 0959-3sum-with-multiplicity ├── 0959-3sum-with-multiplicity.cpp └── README.md ├── 0966-binary-subarrays-with-sum ├── 0966-binary-subarrays-with-sum.cpp └── README.md ├── 0971-shortest-bridge ├── 0971-shortest-bridge.cpp └── README.md ├── 0975-range-sum-of-bst ├── 0975-range-sum-of-bst.cpp └── README.md ├── 0984-most-stones-removed-with-same-row-or-column ├── 0984-most-stones-removed-with-same-row-or-column.cpp └── README.md ├── 0999-regions-cut-by-slashes ├── 0999-regions-cut-by-slashes.cpp └── README.md ├── 1002-maximum-width-ramp ├── 1002-maximum-width-ramp.cpp └── README.md ├── 1013-fibonacci-number ├── 1013-fibonacci-number.cpp └── README.md ├── 1022-unique-paths-iii ├── 1022-unique-paths-iii.cpp └── README.md ├── 1028-interval-list-intersections ├── 1028-interval-list-intersections.cpp └── README.md ├── 1036-rotting-oranges ├── 1036-rotting-oranges.cpp └── README.md ├── 1153-product-sales-analysis-i └── README.md ├── 1196-filling-bookcase-shelves ├── 1196-filling-bookcase-shelves.cpp └── README.md ├── 1250-longest-common-subsequence ├── 1250-longest-common-subsequence.cpp └── README.md ├── 1256-rank-transform-of-an-array ├── 1256-rank-transform-of-an-array.cpp └── README.md ├── 1258-article-views-i ├── 1258-article-views-i.sql └── README.md ├── 1320-remove-all-adjacent-duplicates-in-string-ii ├── 1320-remove-all-adjacent-duplicates-in-string-ii.cpp └── README.md ├── 1325-path-with-maximum-probability ├── 1325-path-with-maximum-probability.cpp └── README.md ├── 1333-sort-the-jumbled-numbers ├── 1333-sort-the-jumbled-numbers.cpp └── README.md ├── 1402-count-square-submatrices-with-all-ones ├── 1402-count-square-submatrices-with-all-ones.cpp └── README.md ├── 1415-students-and-examinations ├── 1415-students-and-examinations.sql └── README.md ├── 1435-xor-queries-of-a-subarray ├── 1435-xor-queries-of-a-subarray.cpp └── README.md ├── 1442-number-of-operations-to-make-network-connected ├── 1442-number-of-operations-to-make-network-connected.cpp └── README.md ├── 1456-find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance ├── 1456-find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.cpp └── README.md ├── 1473-find-the-longest-substring-containing-vowels-in-even-counts ├── 1473-find-the-longest-substring-containing-vowels-in-even-counts.cpp └── README.md ├── 1484-linked-list-in-binary-tree ├── 1484-linked-list-in-binary-tree.cpp └── README.md ├── 1492-time-needed-to-inform-all-employees ├── 1492-time-needed-to-inform-all-employees.cpp └── README.md ├── 1497-design-a-stack-with-increment-operation ├── 1497-design-a-stack-with-increment-operation.cpp └── README.md ├── 1509-replace-employee-id-with-the-unique-identifier ├── 1509-replace-employee-id-with-the-unique-identifier.sql └── README.md ├── 1511-count-number-of-teams ├── 1511-count-number-of-teams.cpp └── README.md ├── 1556-make-two-arrays-equal-by-reversing-subarrays ├── 1556-make-two-arrays-equal-by-reversing-subarrays.cpp └── README.md ├── 1615-range-sum-of-sorted-subarray-sums ├── 1615-range-sum-of-sorted-subarray-sums.cpp └── README.md ├── 1620-check-if-array-pairs-are-divisible-by-k ├── 1620-check-if-array-pairs-are-divisible-by-k.cpp └── README.md ├── 1622-max-value-of-equation ├── 1622-max-value-of-equation.cpp └── README.md ├── 1666-make-the-string-great ├── 1666-make-the-string-great.cpp └── README.md ├── 1691-minimum-number-of-days-to-disconnect-island ├── 1691-minimum-number-of-days-to-disconnect-island.cpp └── README.md ├── 1694-make-sum-divisible-by-p ├── 1694-make-sum-divisible-by-p.cpp └── README.md ├── 1700-minimum-time-to-make-rope-colorful ├── 1700-minimum-time-to-make-rope-colorful.cpp └── README.md ├── 1724-customer-who-visited-but-did-not-make-any-transactions ├── 1724-customer-who-visited-but-did-not-make-any-transactions.sql └── README.md ├── 1756-minimum-deletions-to-make-string-balanced ├── 1756-minimum-deletions-to-make-string-balanced.cpp └── README.md ├── 1762-furthest-building-you-can-reach ├── 1762-furthest-building-you-can-reach.cpp └── README.md ├── 1770-minimum-deletions-to-make-character-frequencies-unique ├── 1770-minimum-deletions-to-make-character-frequencies-unique.cpp └── README.md ├── 1781-check-if-two-string-arrays-are-equivalent ├── 1781-check-if-two-string-arrays-are-equivalent.cpp └── README.md ├── 1786-count-the-number-of-consistent-strings ├── 1786-count-the-number-of-consistent-strings.cpp └── README.md ├── 1792-find-the-most-competitive-subsequence ├── 1792-find-the-most-competitive-subsequence.cpp └── README.md ├── 1801-average-time-of-process-per-machine ├── 1801-average-time-of-process-per-machine.sql └── README.md ├── 1813-maximum-erasure-value ├── 1813-maximum-erasure-value.cpp └── README.md ├── 1823-determine-if-string-halves-are-alike ├── 1823-determine-if-string-halves-are-alike.cpp └── README.md ├── 1827-invalid-tweets ├── 1827-invalid-tweets.sql └── README.md ├── 1866-restore-the-array-from-adjacent-pairs ├── 1866-restore-the-array-from-adjacent-pairs.cpp └── README.md ├── 1908-recyclable-and-low-fat-products ├── 1908-recyclable-and-low-fat-products.sql └── README.md ├── 1923-sentence-similarity-iii ├── 1923-sentence-similarity-iii.cpp └── README.md ├── 1960-check-if-the-sentence-is-pangram ├── 1960-check-if-the-sentence-is-pangram.cpp └── README.md ├── 2006-find-the-student-that-will-replace-the-chalk ├── 2006-find-the-student-that-will-replace-the-chalk.cpp └── README.md ├── 2035-count-sub-islands ├── 2035-count-sub-islands.cpp └── README.md ├── 2067-maximum-number-of-points-with-cost ├── 2067-maximum-number-of-points-with-cost.cpp └── README.md ├── 2076-sum-of-digits-of-string-after-convert ├── 2076-sum-of-digits-of-string-after-convert.cpp └── README.md ├── 2087-confirmation-rate ├── 2087-confirmation-rate.sql └── README.md ├── 2095-minimum-number-of-swaps-to-make-the-string-balanced ├── 2095-minimum-number-of-swaps-to-make-the-string-balanced.cpp └── README.md ├── 2132-convert-1d-array-into-2d-array ├── 2132-convert-1d-array-into-2d-array.cpp └── README.md ├── 2155-find-missing-observations ├── 2155-find-missing-observations.cpp └── README.md ├── 2163-kth-distinct-string-in-an-array ├── 2163-kth-distinct-string-in-an-array.cpp └── README.md ├── 2171-second-minimum-time-to-reach-destination ├── 2171-second-minimum-time-to-reach-destination.cpp └── README.md ├── 2255-minimum-swaps-to-group-all-1s-together-ii ├── 2255-minimum-swaps-to-group-all-1s-together-ii.cpp └── README.md ├── 2323-minimum-bit-flips-to-convert-number ├── 2323-minimum-bit-flips-to-convert-number.cpp └── README.md ├── 2411-spiral-matrix-iv ├── 2411-spiral-matrix-iv.cpp └── README.md ├── 2488-divide-intervals-into-minimum-number-of-groups ├── 2488-divide-intervals-into-minimum-number-of-groups.cpp └── README.md ├── 2494-sum-of-prefix-scores-of-strings ├── 2494-sum-of-prefix-scores-of-strings.cpp └── README.md ├── 2503-longest-subarray-with-maximum-bitwise-and ├── 2503-longest-subarray-with-maximum-bitwise-and.cpp └── README.md ├── 2581-divide-players-into-teams-of-equal-skill ├── 2581-divide-players-into-teams-of-equal-skill.cpp └── README.md ├── 2727-number-of-senior-citizens ├── 2727-number-of-senior-citizens.cpp └── README.md ├── 2732-counter ├── 2732-counter.js └── README.md ├── 2755-extra-characters-in-a-string ├── 2755-extra-characters-in-a-string.cpp └── README.md ├── 2789-counter-ii ├── 2789-counter-ii.js └── README.md ├── 2800-minimum-string-length-after-removing-substrings ├── 2800-minimum-string-length-after-removing-substrings.cpp └── README.md ├── 2803-modify-graph-edge-weights ├── 2803-modify-graph-edge-weights.cpp └── README.md ├── 2809-create-hello-world-function ├── 2809-create-hello-world-function.js └── README.md ├── 2813-to-be-or-not-to-be ├── 2813-to-be-or-not-to-be.js └── README.md ├── 3275-minimum-number-of-pushes-to-type-word-i ├── 3275-minimum-number-of-pushes-to-type-word-i.cpp └── README.md ├── 3276-minimum-number-of-pushes-to-type-word-ii ├── 3276-minimum-number-of-pushes-to-type-word-ii.cpp └── README.md ├── 3329-find-the-length-of-the-longest-common-prefix ├── 3329-find-the-length-of-the-longest-common-prefix.cpp └── README.md ├── 3501-delete-nodes-from-linked-list-present-in-array ├── 3501-delete-nodes-from-linked-list-present-in-array.cpp └── README.md ├── 3510-maximize-the-total-height-of-unique-towers ├── 3510-maximize-the-total-height-of-unique-towers.cpp └── README.md ├── 3519-find-the-number-of-winning-players ├── 3519-find-the-number-of-winning-players.cpp └── README.md ├── 3600-find-the-k-th-character-in-string-game-i ├── 3600-find-the-k-th-character-in-string-game-i.cpp └── README.md ├── Arrays ├── 2DArray │ ├── noOfIslands.cpp │ └── spiralMatrix.cpp ├── 3Sum.cpp ├── 4sum.cpp ├── BuyAndSellStocks.cpp ├── BuyAndSellStocks2.cpp ├── ChocolateDistribution.cpp ├── FindDuplicate.cpp ├── MajorityElement.cpp ├── MergeSortedArray.cpp ├── MoveZeros.cpp ├── RemoveDuplicates.cpp ├── SlidingWindow │ ├── SubArraySumEqualsK.cpp │ └── subArraySumDivsibleByK.cpp ├── TwoSum.cpp ├── checkIfReversingMakesSorted.cpp ├── containerWithMostWater.cpp ├── findAllDuplicates.cpp ├── findPairGivenDifference.cpp ├── largestSubarrayWithZeroSum.cpp ├── maxPointFromCard.cpp ├── removeKdigits.cpp ├── setMatrixZero.cpp ├── sortColors.cpp ├── twoStacksUsingArray.cpp └── wordSearch.cpp ├── DP ├── climbingStairs.cpp ├── jumpGame.cpp ├── longestCommonSubstring.cpp └── maxCutSegments.cpp ├── Graphs ├── BipartiteGraph.cpp ├── Krushkals.cpp ├── M-coloring.cpp ├── TopologicalSort.cpp ├── bellmanFordAlgo.cpp ├── bfs.cpp ├── cheapestFlightswithKStops.cpp ├── cycleInDirected.cpp ├── cycleInUndirected.cpp ├── dfs.cpp ├── floodFill.cpp ├── floydWarshall.cpp ├── graphColoring.cpp ├── kosarajuAlgo.cpp └── numberOfIslands.cpp ├── Greedy ├── minCostAcquiringCoins.cpp └── minCostAquiringCoins.cpp ├── LinkedList ├── BinaryToInteger.cpp ├── CopyListWithRandomPtrs.cpp ├── LinkedListCycle.cpp ├── MergeTwoSortedLists.cpp ├── MiddleOfLL.cpp ├── MultiplyTwoLL.cpp ├── PalindromeLL.cpp ├── RemoveDuplicatesFromSortedLL.cpp ├── addNumbers.cpp ├── addNumbers2.cpp ├── deleteNodesHavingGreaterValueOnright.cpp ├── flatteningLinkedlist.cpp ├── intersectionOf2LL.cpp ├── removeLLelements.cpp ├── reverseLL.cpp ├── reverseLL2.cpp ├── sortList.cpp └── tempCodeRunnerFile.cpp ├── Mathamatical ├── ExcelSheetColTitle.cpp ├── addBinary.cpp ├── countingBits.cpp ├── maxProductOf3numbers.cpp ├── permutationsInArray.cpp └── productArrayPuzzle.cpp ├── README.md ├── Searching └── BooksAllocation.cpp ├── Sorting ├── SearchInotatedSortedArr.cpp ├── minSwapsToSort.cpp └── radix.cpp ├── Stack ├── backspaceStringCompare.cpp ├── dailyTemperatures.cpp ├── nextGreaterElement1.cpp ├── stackUsingQueues.cpp └── theCelebrityProblem.cpp ├── Strings ├── IntegerToroman.cpp ├── RabinKarpAlgo.cpp ├── ValidParenthesis.cpp ├── basicCalculator2.cpp ├── boyelMoore.cpp ├── duplicateCharacters.cpp ├── firstIndexOfFirstOccurence.cpp ├── groupAnagrams.cpp ├── longestCommonPrefix.cpp ├── reverseWords.cpp ├── simplifyPath.cpp └── validPalindrome.cpp ├── Trees ├── BTinorder.cpp ├── InvertBT.cpp ├── SameTree.cpp ├── countNodesInRange.cpp ├── diameterOfBT.cpp ├── medianOfBST.cpp └── preSucBST.cpp ├── backtracking ├── Subsets.cpp ├── TugOfWar.cpp ├── findAllPalindromicPartitions.cpp ├── generateParenthesis.cpp ├── largestNumInKSwaps.cpp └── uniquePermutations.cpp ├── queue ├── evaluatePOstfixExpression.cpp └── queueUsingStacks.cpp ├── rottenOranges └── rottenOranges.cpp └── stats.json /.gitignore: -------------------------------------------------------------------------------- 1 | .vscode 2 | .exe -------------------------------------------------------------------------------- /0003-longest-substring-without-repeating-characters/0003-longest-substring-without-repeating-characters.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int lengthOfLongestSubstring(string s) { 4 | int ans=0; 5 | int n = s.size(); 6 | vector ex; 7 | int count =0; 8 | for(int i=0;i& nums) { 4 | int n = nums.size(); 5 | int i=0; 6 | int j=1; 7 | while(j& nums) { 4 | int n = nums.size(); 5 | int s = 0, e=n-1; 6 | while(s nums[e]) 10 | { 11 | s = m+1; 12 | }else e = m; 13 | } 14 | return e; 15 | } 16 | int BS(vector& nums, int target, int s, int e) 17 | { 18 | while(s<=e) 19 | { 20 | int m = s+(e-s)/2; 21 | if(nums[m] == target) return m; 22 | else if(nums[m] < target) 23 | { 24 | s = m+1; 25 | }else{ 26 | e = m-1; 27 | } 28 | } 29 | return -1; 30 | } 31 | int search(vector& nums, int target) { 32 | int n = nums.size(); 33 | int s =0, e = n-1; 34 | int pivot = findPivot(nums); 35 | int left = BS(nums,target,0,pivot-1); 36 | int right = BS(nums,target,pivot,n-1); 37 | 38 | if(left == -1) return right; 39 | return left; 40 | } 41 | }; -------------------------------------------------------------------------------- /0034-find-first-and-last-position-of-element-in-sorted-array/0034-find-first-and-last-position-of-element-in-sorted-array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int BS(vector &nums, int s, int e, bool isLeft, int target) 4 | { 5 | int ans = -1; 6 | while(s<=e) 7 | { 8 | int m = s+(e-s)/2; 9 | if(nums[m] == target) 10 | { 11 | ans = m; 12 | if(isLeft) e = m-1; 13 | else s = m+1; 14 | } 15 | else if(nums[m] < target) 16 | { 17 | s = m+1; 18 | }else{ 19 | e = m-1; 20 | } 21 | } 22 | return ans; 23 | } 24 | vector searchRange(vector& nums, int target) { 25 | vector ans(2); 26 | int n = nums.size(); 27 | int s= 0, e = n-1; 28 | 29 | int start = BS(nums,0,n-1,true,target); 30 | int end = BS(nums,0,n-1,false,target); 31 | 32 | ans[0] = start; 33 | ans[1] = end; 34 | return ans; 35 | } 36 | }; -------------------------------------------------------------------------------- /0039-combination-sum/0039-combination-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> ans; 4 | void solve(vector& nums, int target,vector & curr, int idx) 5 | { 6 | if(idx == nums.size()) return; 7 | if(target == 0) 8 | { 9 | ans.push_back(curr); 10 | return; 11 | } 12 | 13 | if(nums[idx] <= target) 14 | { 15 | curr.push_back(nums[idx]); 16 | solve(nums,target-nums[idx],curr,idx); 17 | curr.pop_back(); 18 | solve(nums,target,curr,idx+1); 19 | } 20 | } 21 | vector> combinationSum(vector& candidates, int target) { 22 | vector curr; 23 | sort(candidates.begin(),candidates.end()); 24 | solve(candidates,target,curr,0); 25 | return ans; 26 | } 27 | }; -------------------------------------------------------------------------------- /0040-combination-sum-ii/0040-combination-sum-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> ans; 4 | void solve(vector& nums, int target,vector & curr, int idx) 5 | { 6 | if(target == 0) 7 | { 8 | if(find(ans.begin(), ans.end(), curr) != ans.end()) return; 9 | ans.push_back(curr); 10 | return; 11 | } 12 | 13 | for(int i=idx;i idx && nums[i] == nums[i-1]) continue; 16 | if(nums[i]>target) break; 17 | curr.push_back(nums[i]); 18 | solve(nums,target-nums[i],curr,i+1); 19 | curr.pop_back(); 20 | } 21 | } 22 | vector> combinationSum2(vector& candidates, int target) { 23 | vector curr; 24 | sort(candidates.begin(),candidates.end()); 25 | solve(candidates,target,curr,0); 26 | return ans; 27 | } 28 | }; -------------------------------------------------------------------------------- /0041-first-missing-positive/0041-first-missing-positive.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int firstMissingPositive(vector& nums) { 4 | int n = nums.size(); 5 | bool containsOne = false; 6 | for(int i=0;i n) nums[i] = 1; 10 | } 11 | if(!containsOne) return 1; 12 | for(int i=0;i 0) return i+1; 21 | } 22 | return n+1; 23 | } 24 | }; -------------------------------------------------------------------------------- /0042-trapping-rain-water/0042-trapping-rain-water.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector calcLeft(vector& height) 4 | { 5 | vector ans(height.size()); 6 | ans[0] = height[0]; 7 | for(int i=1;i calcRight(vector& height) 14 | { 15 | int n = height.size(); 16 | vector ans(n); 17 | ans[n-1] = height[n-1]; 18 | for(int i=n-2;i>=0;i--) 19 | { 20 | ans[i] = max(ans[i+1], height[i]); 21 | } 22 | return ans; 23 | } 24 | int trap(vector& height) { 25 | int count =0; 26 | int n = height.size(); 27 | vector leftMax = calcLeft(height); 28 | vector rightMax = calcRight(height); 29 | for(int i=0;i> ans; 4 | void solve(vector& nums,int idx) 5 | { 6 | if(idx == nums.size()) 7 | { 8 | ans.push_back(nums); 9 | return; 10 | } 11 | 12 | for(int i=idx;i> permute(vector& nums) { 21 | vector curr; 22 | solve(nums,0); 23 | return ans; 24 | } 25 | }; -------------------------------------------------------------------------------- /0046-permutations/README.md: -------------------------------------------------------------------------------- 1 |

46. Permutations

Medium

Given an array nums of distinct integers, return all the possible permutations. You can return the answer in any order.

2 | 3 |

 

4 |

Example 1:

5 | 
Input: nums = [1,2,3]
 6 | Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
 7 |

Example 2:

8 | 
Input: nums = [0,1]
 9 | Output: [[0,1],[1,0]]
10 |

Example 3:

11 | 
Input: nums = [1]
12 | Output: [[1]]
13 |
14 |

 

15 |

Constraints:

16 | 17 |
    18 |
  • 1 <= nums.length <= 6
    • 19 |
  • -10 <= nums[i] <= 10
    • 20 |
  • All the integers of nums are unique.
    • 21 |
22 | -------------------------------------------------------------------------------- /0048-rotate-image/0048-rotate-image.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void Transpose(vector>& matrix) 4 | { 5 | int n = matrix.size(); 6 | for(int i=0;i>& matrix) { 15 | int n = matrix.size(); 16 | Transpose(matrix); 17 | for(int i=0;i59. Spiral Matrix II

Medium

Given a positive integer n, generate an n x n matrix filled with elements from 1 to n2 in spiral order.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: n = 3
 8 | Output: [[1,2,3],[8,9,4],[7,6,5]]
 9 |
10 | 11 |

Example 2:

12 | 13 | 
14 | Input: n = 1
15 | Output: [[1]]
16 |
17 | 18 |

 

19 |

Constraints:

20 | 21 |
    22 |
  • 1 <= n <= 20
    • 23 |
24 | -------------------------------------------------------------------------------- /0064-minimum-path-sum/0064-minimum-path-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int solve(int row,int col,vector>& grid, vector> &dp) 4 | { 5 | if(row == grid.size()-1 && col == grid[0].size()-1) return grid[row][col]; 6 | 7 | if(dp[row][col]) return dp[row][col]; 8 | 9 | if(col == grid[0].size()-1) 10 | { 11 | return dp[row][col] = grid[row][col] + solve(row+1,col,grid,dp); 12 | } 13 | else if(row == grid.size()-1) 14 | { 15 | return dp[row][col] = grid[row][col] + solve(row,col+1,grid,dp); 16 | } 17 | else return dp[row][col] = grid[row][col] + min(solve(row+1,col,grid,dp), solve(row,col+1,grid,dp)); 18 | } 19 | int minPathSum(vector>& grid) { 20 | int n = grid.size(); 21 | int m = grid[0].size(); 22 | vector> dp(n, vector(m,0)); 23 | return solve(0,0,grid,dp); 24 | } 25 | }; -------------------------------------------------------------------------------- /0076-minimum-window-substring/0076-minimum-window-substring.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string minWindow(string s, string t) { 4 | int n = s.size(); 5 | 6 | if(t.size()>n) return ""; 7 | 8 | unordered_map mp; 9 | for(auto ch : t) 10 | { 11 | mp[ch]++; 12 | } 13 | int requiredCount = t.length(); 14 | int i=0,j=0; 15 | int minWinSize = INT_MAX; 16 | int start=0; 17 | while(j 0) requiredCount--; 21 | 22 | mp[ch]--; 23 | while(requiredCount==0) 24 | { 25 | int currWindSize = j-i+1; 26 | if(minWinSize > currWindSize){ 27 | minWinSize = currWindSize; 28 | start = i; 29 | } 30 | mp[s[i]]++; 31 | if(mp[s[i]] > 0){ 32 | requiredCount++; 33 | } 34 | i++; 35 | } 36 | j++; 37 | } 38 | 39 | return minWinSize==INT_MAX ? "" : s.substr(start,minWinSize); 40 | } 41 | }; -------------------------------------------------------------------------------- /0077-combinations/0077-combinations.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> ans; 4 | void solve(int n, int k, vector &curr,int i) 5 | { 6 | if(curr.size() == k) 7 | { 8 | sort(curr.begin(),curr.end()); 9 | ans.push_back(curr); 10 | return; 11 | } 12 | if(i > n) return; 13 | 14 | curr.push_back(i); 15 | solve(n,k,curr,i+1); 16 | curr.pop_back(); 17 | solve(n,k,curr,i+1); 18 | } 19 | vector> combine(int n, int k) { 20 | vector curr; 21 | solve(n,k,curr,1); 22 | 23 | return ans; 24 | } 25 | }; -------------------------------------------------------------------------------- /0077-combinations/README.md: -------------------------------------------------------------------------------- 1 |

77. Combinations

Medium

Given two integers n and k, return all possible combinations of k numbers chosen from the range [1, n].

2 | 3 |

You may return the answer in any order.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
 9 | Input: n = 4, k = 2
10 | Output: [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
11 | Explanation: There are 4 choose 2 = 6 total combinations.
12 | Note that combinations are unordered, i.e., [1,2] and [2,1] are considered to be the same combination.
13 |
14 | 15 |

Example 2:

16 | 17 | 
18 | Input: n = 1, k = 1
19 | Output: [[1]]
20 | Explanation: There is 1 choose 1 = 1 total combination.
21 |
22 | 23 |

 

24 |

Constraints:

25 | 26 |
    27 |
  • 1 <= n <= 20
    • 28 |
  • 1 <= k <= n
    • 29 |
30 | -------------------------------------------------------------------------------- /0078-subsets/0078-subsets.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> ans; 4 | void solve(vector& nums, vector &curr,int idx) 5 | { 6 | if(idx == nums.size()) 7 | { 8 | ans.push_back(curr); 9 | return; 10 | } 11 | 12 | curr.push_back(nums[idx]); 13 | solve(nums,curr,idx+1); 14 | curr.pop_back(); 15 | solve(nums,curr,idx+1); 16 | } 17 | vector> subsets(vector& nums) { 18 | vector curr; 19 | solve(nums,curr,0); 20 | return ans; 21 | } 22 | }; -------------------------------------------------------------------------------- /0078-subsets/README.md: -------------------------------------------------------------------------------- 1 |

78. Subsets

Medium

Given an integer array nums of unique elements, return all possible subsets (the power set).

2 | 3 |

The solution set must not contain duplicate subsets. Return the solution in any order.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
 9 | Input: nums = [1,2,3]
10 | Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
11 |
12 | 13 |

Example 2:

14 | 15 | 
16 | Input: nums = [0]
17 | Output: [[],[0]]
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 |
    24 |
  • 1 <= nums.length <= 10
    • 25 |
  • -10 <= nums[i] <= 10
    • 26 |
  • All the numbers of nums are unique.
    • 27 |
28 | -------------------------------------------------------------------------------- /0080-remove-duplicates-from-sorted-array-ii/0080-remove-duplicates-from-sorted-array-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int removeDuplicates(vector& nums) { 4 | int n = nums.size(); 5 | if (n <= 2) return n; 6 | int i=2; 7 | for(int j=2;jnext = curr; 18 | while(curr && curr->next) 19 | { 20 | if(curr->next->val != curr->val) 21 | { 22 | prev = curr; 23 | curr = curr->next; 24 | }else{ 25 | while(curr->next && curr->next->val == curr->val) 26 | { 27 | curr = curr->next; 28 | } 29 | curr = curr->next; 30 | prev->next = curr; 31 | } 32 | } 33 | return newHead->next; 34 | } 35 | }; -------------------------------------------------------------------------------- /0083-remove-duplicates-from-sorted-list/0083-remove-duplicates-from-sorted-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode() : val(0), next(nullptr) {} 7 | * ListNode(int x) : val(x), next(nullptr) {} 8 | * ListNode(int x, ListNode *next) : val(x), next(next) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | ListNode* deleteDuplicates(ListNode* head) { 14 | ListNode* curr = head; 15 | ListNode* prev = new ListNode(INT_MIN); 16 | prev->next = curr; 17 | while(curr) 18 | { 19 | if(curr->val != prev->val) 20 | { 21 | prev = curr; 22 | curr = curr->next; 23 | }else{ 24 | prev->next = curr->next; 25 | curr = curr->next; 26 | } 27 | } 28 | return head; 29 | } 30 | }; -------------------------------------------------------------------------------- /0086-partition-list/0086-partition-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode() : val(0), next(nullptr) {} 7 | * ListNode(int x) : val(x), next(nullptr) {} 8 | * ListNode(int x, ListNode *next) : val(x), next(next) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | ListNode* partition(ListNode* head, int x) { 14 | ListNode* curr = head; 15 | ListNode* leftHead = new ListNode(0); 16 | ListNode* rightHead= new ListNode(0); 17 | ListNode* l = leftHead; 18 | ListNode* r = rightHead; 19 | while(curr) 20 | { 21 | if(curr->val < x) 22 | { 23 | l->next = new ListNode(curr->val); 24 | l = l->next; 25 | }else{ 26 | rightHead->next = new ListNode(curr->val); 27 | rightHead = rightHead->next; 28 | } 29 | curr = curr->next; 30 | } 31 | l->next = r->next; 32 | return leftHead->next; 33 | } 34 | }; -------------------------------------------------------------------------------- /0090-subsets-ii/0090-subsets-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> ans; 4 | vector sub; 5 | void recur(vector& nums, int ind) 6 | { 7 | ans.push_back(sub); 8 | for(int i=ind;iind && nums[i] == nums[i-1]) continue; 11 | sub.push_back(nums[i]); 12 | recur(nums,i+1); 13 | sub.pop_back(); 14 | } 15 | } 16 | vector> subsetsWithDup(vector& nums) { 17 | sort(nums.begin(),nums.end()); 18 | recur(nums,0); 19 | return ans; 20 | } 21 | }; -------------------------------------------------------------------------------- /0090-subsets-ii/README.md: -------------------------------------------------------------------------------- 1 |

90. Subsets II

Medium

Given an integer array nums that may contain duplicates, return all possible subsets (the power set).

2 | 3 |

The solution set must not contain duplicate subsets. Return the solution in any order.

4 | 5 |

 

6 |

Example 1:

7 | 
Input: nums = [1,2,2]
 8 | Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]
 9 |

Example 2:

10 | 
Input: nums = [0]
11 | Output: [[],[0]]
12 |
13 |

 

14 |

Constraints:

15 | 16 |
    17 |
  • 1 <= nums.length <= 10
    • 18 |
  • -10 <= nums[i] <= 10
    • 19 |
20 | -------------------------------------------------------------------------------- /0091-decode-ways/0091-decode-ways.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int dp[101]; 4 | int solve(string s,int i) 5 | { 6 | if(i == s.size()) return 1; 7 | if(s[i] == '0') return 0; 8 | if(dp[i] != -1) return dp[i]; 9 | 10 | int opt1 = solve(s,i+1); 11 | int opt2 = 0; 12 | if(i+195. Unique Binary Search Trees II

Medium

Given an integer n, return all the structurally unique BST's (binary search trees), which has exactly n nodes of unique values from 1 to n. Return the answer in any order.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: n = 3
 8 | Output: [[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
 9 |
10 | 11 |

Example 2:

12 | 13 | 
14 | Input: n = 1
15 | Output: [[1]]
16 |
17 | 18 |

 

19 |

Constraints:

20 | 21 |
    22 |
  • 1 <= n <= 8
    • 23 |
24 | -------------------------------------------------------------------------------- /0096-unique-binary-search-trees/0096-unique-binary-search-trees.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int solve(int n,vector&dp){ 4 | if(n<=1){ 5 | return 1; 6 | } 7 | if(dp[n]!=-1){ 8 | return dp[n]; 9 | } 10 | int ans=0; 11 | for(int i=1;i<=n;i++){ 12 | ans+=solve(i-1,dp)*solve(n-i,dp); 13 | } 14 | return dp[n]=ans; 15 | } 16 | int numTrees(int n) { 17 | vectordp(n+1,-1); 18 | return solve(n,dp); 19 | } 20 | }; -------------------------------------------------------------------------------- /0096-unique-binary-search-trees/README.md: -------------------------------------------------------------------------------- 1 |

96. Unique Binary Search Trees

Medium

Given an integer n, return the number of structurally unique BST's (binary search trees) which has exactly n nodes of unique values from 1 to n.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: n = 3
 8 | Output: 5
 9 |
10 | 11 |

Example 2:

12 | 13 | 
14 | Input: n = 1
15 | Output: 1
16 |
17 | 18 |

 

19 |

Constraints:

20 | 21 |
    22 |
  • 1 <= n <= 19
    • 23 |
24 | -------------------------------------------------------------------------------- /0098-validate-binary-search-tree/0098-validate-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | bool isValid(TreeNode* root, long long min,long long max) 15 | { 16 | if(root == NULL) return true; 17 | if(root->val >= max || root->val <= min) return false; 18 | return isValid(root->left,min,root->val) && isValid(root->right,root->val,max); 19 | } 20 | bool isValidBST(TreeNode* root) { 21 | if(!root->left && !root->right) return true; 22 | return isValid(root,LLONG_MIN, LLONG_MAX); 23 | } 24 | }; -------------------------------------------------------------------------------- /0101-symmetric-tree/0101-symmetric-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | bool traversal(TreeNode* left, TreeNode* right) 15 | { 16 | if(left == NULL || right == NULL) return left==right; 17 | 18 | if(left->val != right->val) return false; 19 | return traversal(left->left, right->right) && traversal(left->right, right->left); 20 | } 21 | bool isSymmetric(TreeNode* root) { 22 | return root== NULL || traversal(root->left, root->right); 23 | } 24 | }; -------------------------------------------------------------------------------- /0101-symmetric-tree/README.md: -------------------------------------------------------------------------------- 1 |

101. Symmetric Tree

Easy

Given the root of a binary tree, check whether it is a mirror of itself (i.e., symmetric around its center).

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: root = [1,2,2,3,4,4,3]
 8 | Output: true
 9 |
10 | 11 |

Example 2:

12 | 13 | 
14 | Input: root = [1,2,2,null,3,null,3]
15 | Output: false
16 |
17 | 18 |

 

19 |

Constraints:

20 | 21 |
    22 |
  • The number of nodes in the tree is in the range [1, 1000].
    • 23 |
  • -100 <= Node.val <= 100
    • 24 |
25 | 26 |

 

27 | Follow up: Could you solve it both recursively and iteratively? -------------------------------------------------------------------------------- /0104-maximum-depth-of-binary-tree/0104-maximum-depth-of-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | int height(TreeNode* root) 15 | { 16 | if(!root) return 0; 17 | int left = height(root->left); 18 | int right = height(root->right); 19 | 20 | return max(left,right) + 1; 21 | } 22 | int maxDepth(TreeNode* root) { 23 | return height(root); 24 | } 25 | }; -------------------------------------------------------------------------------- /0104-maximum-depth-of-binary-tree/README.md: -------------------------------------------------------------------------------- 1 |

104. Maximum Depth of Binary Tree

Easy

Given the root of a binary tree, return its maximum depth.

2 | 3 |

A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
 9 | Input: root = [3,9,20,null,null,15,7]
10 | Output: 3
11 |
12 | 13 |

Example 2:

14 | 15 | 
16 | Input: root = [1,null,2]
17 | Output: 2
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 |
    24 |
  • The number of nodes in the tree is in the range [0, 104].
    • 25 |
  • -100 <= Node.val <= 100
    • 26 |
27 | -------------------------------------------------------------------------------- /0108-convert-sorted-array-to-binary-search-tree/0108-convert-sorted-array-to-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | TreeNode* recur(vector& nums, int start, int end) 15 | { 16 | if(start > end) return NULL; 17 | int mid = (start + end)/2; 18 | TreeNode* root = new TreeNode(nums[mid]); 19 | 20 | root->left = recur(nums, start, mid-1); 21 | root->right = recur(nums, mid+1, end); 22 | 23 | return root; 24 | } 25 | TreeNode* sortedArrayToBST(vector& nums) { 26 | int n = nums.size(); 27 | return recur(nums, 0, n-1); 28 | } 29 | }; -------------------------------------------------------------------------------- /0110-balanced-binary-tree/0110-balanced-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | int balanced(TreeNode* root,bool &flag) 15 | { 16 | if(root== NULL) 17 | { 18 | return 0; 19 | } 20 | 21 | int left = balanced(root->left,flag); 22 | int right = balanced(root->right,flag); 23 | if(abs(left-right) > 1)flag = false; 24 | 25 | return max(left,right)+1; 26 | } 27 | bool isBalanced(TreeNode* root) { 28 | bool flag = true; 29 | balanced(root,flag); 30 | return flag; 31 | } 32 | }; -------------------------------------------------------------------------------- /0112-path-sum/0112-path-sum.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | bool dfs(TreeNode* root, int targetSum,int currSum) 15 | { 16 | if(root ==NULL) return false; 17 | 18 | currSum += root->val; 19 | if(root->left == NULL && root->right == NULL && currSum == targetSum) return true; 20 | bool left = dfs(root->left,targetSum, currSum); 21 | bool right = dfs(root->right, targetSum, currSum); 22 | 23 | return left || right; 24 | } 25 | bool hasPathSum(TreeNode* root, int targetSum) { 26 | return dfs(root,targetSum,0); 27 | } 28 | }; -------------------------------------------------------------------------------- /0131-palindrome-partitioning/0131-palindrome-partitioning.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> ans; 4 | bool palindrome(string s, int start, int end) 5 | { 6 | while(start <= end) 7 | { 8 | if(s[start] != s[end]) return false; 9 | 10 | start++; 11 | end--; 12 | } 13 | return true; 14 | } 15 | void solve(string s, vector &curr, int idx) 16 | { 17 | if(idx == s.size()) 18 | { 19 | ans.push_back(curr); 20 | return; 21 | } 22 | 23 | for(int i=idx;i> partition(string s) { 34 | vector curr; 35 | solve(s,curr,0); 36 | return ans; 37 | } 38 | }; -------------------------------------------------------------------------------- /0131-palindrome-partitioning/README.md: -------------------------------------------------------------------------------- 1 |

131. Palindrome Partitioning

Medium

Given a string s, partition s such that every substring of the partition is a palindrome. Return all possible palindrome partitioning of s.

2 | 3 |

 

4 |

Example 1:

5 | 
Input: s = "aab"
 6 | Output: [["a","a","b"],["aa","b"]]
 7 |

Example 2:

8 | 
Input: s = "a"
 9 | Output: [["a"]]
10 |
11 |

 

12 |

Constraints:

13 | 14 |
    15 |
  • 1 <= s.length <= 16
    • 16 |
  • s contains only lowercase English letters.
    • 17 |
18 | -------------------------------------------------------------------------------- /0134-gas-station/0134-gas-station.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int canCompleteCircuit(vector& gas, vector& cost) { 4 | if (accumulate(gas.begin(), gas.end(), 0) < accumulate(cost.begin(), cost.end(), 0)) { 5 | return -1; 6 | } 7 | int n = gas.size(); 8 | int fuel =0; 9 | int ans =0; 10 | for(int i=0;i ans; 15 | void postOrder(TreeNode* root) 16 | { 17 | if(!root) return; 18 | postOrder(root->left); 19 | postOrder(root->right); 20 | ans.push_back(root->val); 21 | } 22 | vector postorderTraversal(TreeNode* root) { 23 | postOrder(root); 24 | return ans; 25 | } 26 | }; -------------------------------------------------------------------------------- /0148-sort-list/0148-sort-list.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode() : val(0), next(nullptr) {} 7 | * ListNode(int x) : val(x), next(nullptr) {} 8 | * ListNode(int x, ListNode *next) : val(x), next(next) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | ListNode* sortList(ListNode* head) { 14 | vector v; 15 | ListNode* curr = head; 16 | while(curr) 17 | { 18 | v.push_back(curr->val); 19 | curr = curr->next; 20 | } 21 | sort(v.begin(),v.end()); 22 | curr = head; 23 | for(int i=0;ival = v[i]; 26 | curr = curr->next; 27 | } 28 | return head; 29 | } 30 | }; -------------------------------------------------------------------------------- /0150-evaluate-reverse-polish-notation/0150-evaluate-reverse-polish-notation.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int evalRPN(vector& tokens) { 4 | int n = tokens.size(); 5 | stackst; 6 | for(int i=0;i& nums) { 4 | int n = nums.size(); 5 | int max_product = INT_MIN; 6 | int prefix =1; 7 | int suffix =1; 8 | for(int i=0;i& nums) { 4 | int n = nums.size(); 5 | int s = 0, e=n-1; 6 | while(s nums[e]) 10 | { 11 | s = m+1; 12 | }else e = m; 13 | } 14 | return nums[e]; 15 | } 16 | }; -------------------------------------------------------------------------------- /0197-rising-temperature/0197-rising-temperature.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT w1.id 3 | FROM Weather as w1 JOIN Weather as w2 4 | ON datediff(w1.recordDate, w2.recordDate) = 1 5 | AND w1.temperature > w2.temperature; -------------------------------------------------------------------------------- /0199-binary-tree-right-side-view/0199-binary-tree-right-side-view.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | vector rightSideView(TreeNode* root) { 15 | if(!root) return{}; 16 | vector ans; 17 | queue q; 18 | q.push(root); 19 | while(!q.empty()) 20 | { 21 | int size = q.size(); 22 | TreeNode* curr; 23 | while(size--) 24 | { 25 | curr = q.front(); 26 | q.pop(); 27 | if(curr->left != NULL) q.push(curr->left); 28 | if(curr->right != NULL) q.push(curr->right); 29 | } 30 | ans.push_back(curr->val); 31 | } 32 | return ans; 33 | } 34 | }; -------------------------------------------------------------------------------- /0209-minimum-size-subarray-sum/0209-minimum-size-subarray-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minSubArrayLen(int target, vector& nums) { 4 | int n = nums.size(); 5 | int i=0; 6 | int j=0; 7 | int sum = 0; 8 | int ans = INT_MAX; 9 | while(j=target) 13 | { 14 | ans = min(ans,j-i+1); 15 | sum -= nums[i]; 16 | i++; 17 | } 18 | j++; 19 | } 20 | if(ans == INT_MAX) return 0; 21 | return ans; 22 | } 23 | }; -------------------------------------------------------------------------------- /0214-shortest-palindrome/0214-shortest-palindrome.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string shortestPalindrome(string s) { 4 | string rev = s; 5 | reverse(rev.begin(),rev.end()); 6 | 7 | for(int i=0;i214. Shortest Palindrome

Hard

You are given a string s. You can convert s to a palindrome by adding characters in front of it.

2 | 3 |

Return the shortest palindrome you can find by performing this transformation.

4 | 5 |

 

6 |

Example 1:

7 | 
Input: s = "aacecaaa"
 8 | Output: "aaacecaaa"
 9 |

Example 2:

10 | 
Input: s = "abcd"
11 | Output: "dcbabcd"
12 |
13 |

 

14 |

Constraints:

15 | 16 |
    17 |
  • 0 <= s.length <= 5 * 104
    • 18 |
  • s consists of lowercase English letters only.
    • 19 |
20 | -------------------------------------------------------------------------------- /0215-kth-largest-element-in-an-array/0215-kth-largest-element-in-an-array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findKthLargest(vector& nums, int k) { 4 | int n = nums.size(); 5 | priority_queue, greater> pq; 6 | for(auto x : nums) 7 | { 8 | pq.push(x); 9 | if(pq.size()>k) pq.pop(); 10 | } 11 | return pq.top(); 12 | } 13 | }; -------------------------------------------------------------------------------- /0215-kth-largest-element-in-an-array/README.md: -------------------------------------------------------------------------------- 1 |

215. Kth Largest Element in an Array

Medium

Given an integer array nums and an integer k, return the kth largest element in the array.

2 | 3 |

Note that it is the kth largest element in the sorted order, not the kth distinct element.

4 | 5 |

Can you solve it without sorting?

6 | 7 |

 

8 |

Example 1:

9 | 
Input: nums = [3,2,1,5,6,4], k = 2
10 | Output: 5
11 |

Example 2:

12 | 
Input: nums = [3,2,3,1,2,4,5,5,6], k = 4
13 | Output: 4
14 |
15 |

 

16 |

Constraints:

17 | 18 |
    19 |
  • 1 <= k <= nums.length <= 105
    • 20 |
  • -104 <= nums[i] <= 104
    • 21 |
22 | -------------------------------------------------------------------------------- /0219-contains-duplicate-ii/0219-contains-duplicate-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool containsNearbyDuplicate(vector& nums, int k) { 4 | int n = nums.size(); 5 | unordered_map mp; 6 | for(int i=0;i inorderTraversal; 15 | void inorder(TreeNode* root) 16 | { 17 | if(!root) return; 18 | 19 | inorder(root->left); 20 | inorderTraversal.push_back(root->val); 21 | inorder(root->right); 22 | } 23 | int kthSmallest(TreeNode* root, int k) { 24 | inorder(root); 25 | return inorderTraversal[k-1]; 26 | } 27 | }; -------------------------------------------------------------------------------- /0235-lowest-common-ancestor-of-a-binary-search-tree/0235-lowest-common-ancestor-of-a-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | 11 | class Solution { 12 | public: 13 | TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { 14 | if(!root) return NULL; 15 | 16 | if(root->val < p->val && root->val < q->val) 17 | { 18 | return lowestCommonAncestor(root->right,p,q); 19 | } 20 | if(root->val > p->val && root->val > q->val) 21 | { 22 | return lowestCommonAncestor(root->left,p,q); 23 | } 24 | return root; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /0236-lowest-common-ancestor-of-a-binary-tree/0236-lowest-common-ancestor-of-a-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { 13 | if(!root) return NULL; 14 | 15 | if(root == p || root == q) return root; 16 | 17 | TreeNode* left= lowestCommonAncestor(root->left,p,q); 18 | TreeNode* right= lowestCommonAncestor(root->right,p,q); 19 | 20 | if(left != NULL && right != NULL) return root; 21 | if(left != NULL) return left; 22 | return right; 23 | } 24 | }; -------------------------------------------------------------------------------- /0239-sliding-window-maximum/0239-sliding-window-maximum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector maxSlidingWindow(vector& arr, int k) { 4 | deque dq; 5 | vector ans; 6 | 7 | for (int i = 0; i < arr.size(); ++i) { 8 | if (!dq.empty() && dq.front() == i - k) { 9 | dq.pop_front(); 10 | } 11 | 12 | while (!dq.empty() && arr[dq.back()] < arr[i]) { 13 | dq.pop_back(); 14 | } 15 | 16 | dq.push_back(i); 17 | 18 | if (i >= k - 1) { 19 | ans.push_back(arr[dq.front()]); 20 | } 21 | } 22 | 23 | return ans; 24 | } 25 | }; -------------------------------------------------------------------------------- /0257-binary-tree-paths/0257-binary-tree-paths.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | vector ans; 15 | void dfs(TreeNode* root, string temp) 16 | { 17 | if (!root) return; 18 | 19 | if (!temp.empty()) { 20 | temp += "->"; 21 | } 22 | temp += to_string(root->val); 23 | 24 | if (!root->left && !root->right) { 25 | ans.push_back(temp); 26 | return; 27 | } 28 | 29 | dfs(root->left, temp); 30 | dfs(root->right, temp); 31 | } 32 | vector binaryTreePaths(TreeNode* root) { 33 | dfs(root,""); 34 | return ans; 35 | } 36 | }; -------------------------------------------------------------------------------- /0257-binary-tree-paths/README.md: -------------------------------------------------------------------------------- 1 |

257. Binary Tree Paths

Easy

Given the root of a binary tree, return all root-to-leaf paths in any order.

2 | 3 |

A leaf is a node with no children.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
 9 | Input: root = [1,2,3,null,5]
10 | Output: ["1->2->5","1->3"]
11 |
12 | 13 |

Example 2:

14 | 15 | 
16 | Input: root = [1]
17 | Output: ["1"]
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 |
    24 |
  • The number of nodes in the tree is in the range [1, 100].
    • 25 |
  • -100 <= Node.val <= 100
    • 26 |
27 | -------------------------------------------------------------------------------- /0258-add-digits/0258-add-digits.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int addDigits(int num) { 4 | if(num == 0) return 0; 5 | return num%9 == 0 ? 9 : num%9; 6 | } 7 | }; -------------------------------------------------------------------------------- /0258-add-digits/README.md: -------------------------------------------------------------------------------- 1 |

258. Add Digits

Easy

Given an integer num, repeatedly add all its digits until the result has only one digit, and return it.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: num = 38
 8 | Output: 2
 9 | Explanation: The process is
10 | 38 --> 3 + 8 --> 11
11 | 11 --> 1 + 1 --> 2 
12 | Since 2 has only one digit, return it.
13 |
14 | 15 |

Example 2:

16 | 17 | 
18 | Input: num = 0
19 | Output: 0
20 |
21 | 22 |

 

23 |

Constraints:

24 | 25 |
    26 |
  • 0 <= num <= 231 - 1
    • 27 |
28 | 29 |

 

30 |

Follow up: Could you do it without any loop/recursion in O(1) runtime?

31 | -------------------------------------------------------------------------------- /0263-ugly-number/0263-ugly-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isUgly(int n) { 4 | while(n>1) 5 | { 6 | if(n%2 == 0) n= n/2; 7 | else if(n%3 == 0) n= n/3; 8 | else if(n%5 == 0) n= n/5; 9 | else return false; 10 | } 11 | return n==1 ? true: false; 12 | 13 | } 14 | }; -------------------------------------------------------------------------------- /0264-ugly-number-ii/0264-ugly-number-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int nthUglyNumber(int n) { 4 | int arr[n+1]; 5 | arr[1]=1; 6 | int i2 ,i3,i5; 7 | i2 = i3= i5 = 1; 8 | for(int i=2;i<=n;i++) 9 | { 10 | int i2Num = arr[i2]*2; 11 | int i3Num = arr[i3]*3; 12 | int i5Num = arr[i5]*5; 13 | 14 | int mini = min({i2Num, i3Num, i5Num}); 15 | arr[i] = mini; 16 | 17 | if(mini == i2Num) i2++; 18 | if(mini == i3Num) i3++; 19 | if(mini == i5Num) i5++; 20 | } 21 | return arr[n]; 22 | } 23 | }; -------------------------------------------------------------------------------- /0264-ugly-number-ii/README.md: -------------------------------------------------------------------------------- 1 |

264. Ugly Number II

Medium

An ugly number is a positive integer whose prime factors are limited to 2, 3, and 5.

2 | 3 |

Given an integer n, return the nth ugly number.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
 9 | Input: n = 10
10 | Output: 12
11 | Explanation: [1, 2, 3, 4, 5, 6, 8, 9, 10, 12] is the sequence of the first 10 ugly numbers.
12 |
13 | 14 |

Example 2:

15 | 16 | 
17 | Input: n = 1
18 | Output: 1
19 | Explanation: 1 has no prime factors, therefore all of its prime factors are limited to 2, 3, and 5.
20 |
21 | 22 |

 

23 |

Constraints:

24 | 25 |
    26 |
  • 1 <= n <= 1690
    • 27 |
28 | -------------------------------------------------------------------------------- /0273-integer-to-english-words/README.md: -------------------------------------------------------------------------------- 1 |

273. Integer to English Words

Hard

Convert a non-negative integer num to its English words representation.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: num = 123
 8 | Output: "One Hundred Twenty Three"
 9 |
10 | 11 |

Example 2:

12 | 13 | 
14 | Input: num = 12345
15 | Output: "Twelve Thousand Three Hundred Forty Five"
16 |
17 | 18 |

Example 3:

19 | 20 | 
21 | Input: num = 1234567
22 | Output: "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"
23 |
24 | 25 |

 

26 |

Constraints:

27 | 28 |
    29 |
  • 0 <= num <= 231 - 1
    • 30 |
31 | -------------------------------------------------------------------------------- /0300-longest-increasing-subsequence/0300-longest-increasing-subsequence.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int dp[2501][2501]; 4 | int LIS(vector& nums, int i,int prev) 5 | { 6 | if(i >= nums.size()) return 0; 7 | if(prev != -1 && dp[i][prev] != -1) return dp[i][prev]; 8 | int take=0, skip=0; 9 | if(prev == -1 || nums[i] > nums[prev]) 10 | { 11 | take = 1 + LIS(nums,i+1,i); 12 | } 13 | skip = LIS(nums,i+1,prev); 14 | 15 | if(prev != -1) 16 | { 17 | dp[i][prev] = max(take,skip); 18 | } 19 | return max(take,skip); 20 | } 21 | int lengthOfLIS(vector& nums) { 22 | memset(dp,-1,sizeof(dp)); 23 | return LIS(nums,0,-1); 24 | } 25 | }; -------------------------------------------------------------------------------- /0303-range-sum-query-immutable/0303-range-sum-query-immutable.cpp: -------------------------------------------------------------------------------- 1 | class NumArray { 2 | public: 3 | vector arr; 4 | 5 | NumArray(vector& nums) { 6 | arr.resize(nums.size()); 7 | arr[0] = nums[0]; 8 | for(int i=1;i 0) return arr[right] - arr[left-1]; 16 | return arr[right]; 17 | } 18 | }; 19 | 20 | /** 21 | * Your NumArray object will be instantiated and called as such: 22 | * NumArray* obj = new NumArray(nums); 23 | * int param_1 = obj->sumRange(left,right); 24 | */ -------------------------------------------------------------------------------- /0307-range-sum-query-mutable/0307-range-sum-query-mutable.cpp: -------------------------------------------------------------------------------- 1 | class NumArray { 2 | public: 3 | vector nums; 4 | vector PrefixSum; 5 | 6 | NumArray(vector& nums) : nums(nums) { 7 | PrefixSum.resize(nums.size() + 1); 8 | PrefixSum[0] = 0; 9 | for (int i = 0; i < nums.size(); i++) { 10 | PrefixSum[i + 1] = PrefixSum[i] + nums[i]; 11 | } 12 | } 13 | 14 | void update(int index, int val) { 15 | int diff = val - nums[index]; 16 | nums[index] = val; 17 | 18 | for (int i = index + 1; i < PrefixSum.size(); i++) { 19 | PrefixSum[i] += diff; 20 | } 21 | } 22 | 23 | int sumRange(int left, int right) { 24 | return PrefixSum[right + 1] - PrefixSum[left]; 25 | } 26 | }; 27 | 28 | /** 29 | * Your NumArray object will be instantiated and called as such: 30 | * NumArray* obj = new NumArray(nums); 31 | * obj->update(index,val); 32 | * int param_2 = obj->sumRange(left,right); 33 | */ -------------------------------------------------------------------------------- /0322-coin-change/0322-coin-change.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int coinChange(vector& coins, int amount) { 4 | if(amount<1) return 0; 5 | vector dp(amount + 1, amount + 1); 6 | dp[0] = 0; 7 | 8 | for(int i=1;i<=amount;i++) 9 | { 10 | dp[i] = INT_MAX; 11 | 12 | for(int coin : coins) 13 | { 14 | if(coin <= i && dp[i-coin] != INT_MAX) 15 | { 16 | dp[i] = min(dp[i], 1 + dp[i-coin]); 17 | } 18 | } 19 | } 20 | if(dp[amount] == INT_MAX) return -1; 21 | return dp[amount]; 22 | } 23 | }; -------------------------------------------------------------------------------- /0338-counting-bits/0338-counting-bits.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector countBits(int n) { 4 | vector ans(n+1); 5 | for(int i=0;i<=n;i++) 6 | { 7 | if(i%2==0) ans[i]=ans[i/2]; 8 | else ans[i]=ans[i/2]+1; 9 | } 10 | return ans; 11 | } 12 | }; -------------------------------------------------------------------------------- /0347-top-k-frequent-elements/0347-top-k-frequent-elements.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector topKFrequent(vector& nums, int k) { 4 | int n = nums.size(); 5 | vector> freq(n+1); 6 | unordered_map mp; 7 | for(int i=0;i ans; 16 | for(int i=n;i>=0;i--) 17 | { 18 | while(freq[i].size() > 0 && k >0) 19 | { 20 | ans.push_back(freq[i].back()); 21 | freq[i].pop_back(); 22 | k--; 23 | } 24 | if(k <=0) break; 25 | } 26 | return ans; 27 | } 28 | }; -------------------------------------------------------------------------------- /0378-kth-smallest-element-in-a-sorted-matrix/0378-kth-smallest-element-in-a-sorted-matrix.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int kthSmallest(vector>& matrix, int k) { 4 | int n = matrix.size(); 5 | priority_queue pq; 6 | for(int i=0;ik) pq.pop(); 12 | } 13 | } 14 | return pq.top(); 15 | } 16 | }; -------------------------------------------------------------------------------- /0386-lexicographical-numbers/0386-lexicographical-numbers.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void solve(int n, vector &ans, int curr) 4 | { 5 | if(curr > n ) return; 6 | ans.push_back(curr); 7 | for(int i=0;i<=9;i++) 8 | { 9 | int currNum = curr*10 + i; 10 | solve(n,ans,currNum); 11 | } 12 | } 13 | vector lexicalOrder(int n) { 14 | vector ans; 15 | for(int i=1;i<=9;i++) 16 | { 17 | solve(n,ans,i); 18 | } 19 | return ans; 20 | } 21 | }; -------------------------------------------------------------------------------- /0386-lexicographical-numbers/README.md: -------------------------------------------------------------------------------- 1 |

386. Lexicographical Numbers

Medium

Given an integer n, return all the numbers in the range [1, n] sorted in lexicographical order.

2 | 3 |

You must write an algorithm that runs in O(n) time and uses O(1) extra space. 

4 | 5 |

 

6 |

Example 1:

7 | 
Input: n = 13
 8 | Output: [1,10,11,12,13,2,3,4,5,6,7,8,9]
 9 |

Example 2:

10 | 
Input: n = 2
11 | Output: [1,2]
12 |
13 |

 

14 |

Constraints:

15 | 16 |
    17 |
  • 1 <= n <= 5 * 104
    • 18 |
19 | -------------------------------------------------------------------------------- /0394-decode-string/0394-decode-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string decodeString(string s) { 4 | stack st; 5 | stack st1; 6 | string sb; 7 | int n = 0; 8 | 9 | for (char c : s) { 10 | if (isdigit(c)) { 11 | n = n * 10 + (c - '0'); 12 | } else if (c == '[') { 13 | st.push(n); 14 | n = 0; 15 | st1.push(sb); 16 | sb = ""; 17 | } else if (c == ']') { 18 | int k = st.top(); 19 | st.pop(); 20 | string temp = sb; 21 | sb = st1.top(); 22 | st1.pop(); 23 | while (k-- > 0) { 24 | sb += temp; 25 | } 26 | } else { 27 | sb += c; 28 | } 29 | } 30 | 31 | return sb; 32 | } 33 | }; -------------------------------------------------------------------------------- /0404-sum-of-left-leaves/0404-sum-of-left-leaves.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | int sum =0; 15 | void solve(TreeNode* root, TreeNode* parent) 16 | { 17 | if(!root) return; 18 | 19 | if(root->left == NULL && root->right == NULL) 20 | { 21 | if(parent != NULL && parent->left == root) 22 | { 23 | sum+= root->val; 24 | } 25 | } 26 | solve(root->left,root); 27 | solve(root->right,root); 28 | } 29 | int sumOfLeftLeaves(TreeNode* root) { 30 | solve(root,NULL); 31 | return sum; 32 | } 33 | }; -------------------------------------------------------------------------------- /0404-sum-of-left-leaves/README.md: -------------------------------------------------------------------------------- 1 |

404. Sum of Left Leaves

Easy

Given the root of a binary tree, return the sum of all left leaves.

2 | 3 |

A leaf is a node with no children. A left leaf is a leaf that is the left child of another node.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
 9 | Input: root = [3,9,20,null,null,15,7]
10 | Output: 24
11 | Explanation: There are two left leaves in the binary tree, with values 9 and 15 respectively.
12 |
13 | 14 |

Example 2:

15 | 16 | 
17 | Input: root = [1]
18 | Output: 0
19 |
20 | 21 |

 

22 |

Constraints:

23 | 24 |
    25 |
  • The number of nodes in the tree is in the range [1, 1000].
    • 26 |
  • -1000 <= Node.val <= 1000
    • 27 |
28 | -------------------------------------------------------------------------------- /0410-split-array-largest-sum/0410-split-array-largest-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool check(vector& nums, int k, int mid) 4 | { 5 | int arrCount = 1; 6 | int sum = nums[0]; 7 | for(int i=1;i mid) 10 | { 11 | sum = nums[i]; 12 | arrCount++; 13 | if(arrCount > k) return false; 14 | }else{ 15 | sum += nums[i]; 16 | } 17 | 18 | } 19 | return true; 20 | } 21 | int splitArray(vector& nums, int k) { 22 | int n = nums.size(); 23 | int low = *max_element(nums.begin(),nums.end()); 24 | int high = accumulate(nums.begin(),nums.end(),0); 25 | int ans = high; 26 | while(low<=high) 27 | { 28 | int mid = low+(high-low)/2; 29 | if(check(nums,k,mid)) 30 | { 31 | ans = mid; 32 | high = mid-1; 33 | }else{ 34 | low = mid+1; 35 | } 36 | } 37 | return ans; 38 | } 39 | }; -------------------------------------------------------------------------------- /0416-partition-equal-subset-sum/0416-partition-equal-subset-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> dp; 4 | bool solve(vector& nums, int idx, int target) 5 | { 6 | if (target == 0) return true; 7 | if (idx == nums.size() || target < 0) return false; 8 | 9 | if (dp[idx][target] != -1) return dp[idx][target]; 10 | int take = solve(nums,idx+1,target-nums[idx]); 11 | int not_take = solve(nums,idx+1,target); 12 | 13 | return dp[idx][target] = take || not_take; 14 | } 15 | bool canPartition(vector& nums) { 16 | int sum = accumulate(nums.begin(),nums.end(),0); 17 | if(sum%2 == 1) return false; 18 | int t = sum/2; 19 | dp.resize(nums.size(), vector(t + 1, -1)); 20 | return solve(nums,0,t); 21 | } 22 | }; -------------------------------------------------------------------------------- /0416-partition-equal-subset-sum/README.md: -------------------------------------------------------------------------------- 1 |

416. Partition Equal Subset Sum

Medium

Given an integer array nums, return true if you can partition the array into two subsets such that the sum of the elements in both subsets is equal or false otherwise.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: nums = [1,5,11,5]
 8 | Output: true
 9 | Explanation: The array can be partitioned as [1, 5, 5] and [11].
10 |
11 | 12 |

Example 2:

13 | 14 | 
15 | Input: nums = [1,2,3,5]
16 | Output: false
17 | Explanation: The array cannot be partitioned into equal sum subsets.
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 |
    24 |
  • 1 <= nums.length <= 200
    • 25 |
  • 1 <= nums[i] <= 100
    • 26 |
27 | -------------------------------------------------------------------------------- /0424-longest-repeating-character-replacement/0424-longest-repeating-character-replacement.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int characterReplacement(string s, int k) { 4 | int n = s.size(); 5 | vector mp(26,0); 6 | int len =0, maxfreq=0; 7 | int l=0,r=0; 8 | while(r k) 13 | { 14 | mp[s[l]-'A']--; 15 | maxfreq =0; 16 | for(int f : mp) 17 | { 18 | maxfreq = max(maxfreq, f); 19 | } 20 | l++; 21 | } 22 | if((r-l+1) - maxfreq <= k) 23 | { 24 | len = max(len, r-l+1); 25 | } 26 | r++; 27 | } 28 | return len; 29 | 30 | } 31 | }; -------------------------------------------------------------------------------- /0435-non-overlapping-intervals/0435-non-overlapping-intervals.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int eraseOverlapIntervals(vector>& intervals) { 4 | int n = intervals.size(); 5 | sort(intervals.begin(),intervals.end()); 6 | int count =0; 7 | int i=0, j=1; 8 | while(j < n) 9 | { 10 | vector curr_interval = intervals[i]; 11 | vector next_interval = intervals[j]; 12 | int cs = curr_interval[0]; 13 | int ce = curr_interval[1]; 14 | int ns = next_interval[0]; 15 | int ne = next_interval[1]; 16 | if(ce <= ns) // no overlapping 17 | { 18 | i=j; 19 | j++; 20 | } 21 | else if(ce <= ne) // overlapping 22 | { 23 | j++; 24 | count++; 25 | } 26 | else if(ce > ne) 27 | { 28 | i=j; 29 | j++; 30 | count++; 31 | } 32 | } 33 | return count; 34 | } 35 | }; -------------------------------------------------------------------------------- /0438-find-all-anagrams-in-a-string/0438-find-all-anagrams-in-a-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector findAnagrams(string s, string p) { 4 | int n = s.size(); 5 | int m = p.size(); 6 | unordered_map mp; 7 | for(int i=0;i ans; 12 | int i=0, j=0; 13 | while(j= 1){ 24 | greater=true; 25 | break; 26 | } 27 | } 28 | if(!greater){ 29 | ans.push_back(i); 30 | } 31 | 32 | mp[s[i]]++; 33 | i++; 34 | } 35 | j++; 36 | } 37 | 38 | return ans; 39 | } 40 | }; -------------------------------------------------------------------------------- /0440-k-th-smallest-in-lexicographical-order/0440-k-th-smallest-in-lexicographical-order.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int Count(long curr, long next, int n) { 4 | int countNum = 0; 5 | 6 | while(curr <= n) { 7 | countNum += (next - curr); 8 | 9 | curr *= 10; 10 | next *= 10; 11 | 12 | next = min(next, long(n+1)); 13 | } 14 | 15 | return countNum; 16 | } 17 | 18 | int findKthNumber(int n, int k) { 19 | int curr = 1; 20 | k -= 1; 21 | while(k > 0) { 22 | int count = Count(curr, curr+1, n); 23 | if(count <= k) { 24 | curr++; 25 | k -= count; 26 | } else { 27 | curr *= 10; 28 | k -= 1; 29 | } 30 | } 31 | 32 | return curr; 33 | 34 | } 35 | }; -------------------------------------------------------------------------------- /0440-k-th-smallest-in-lexicographical-order/README.md: -------------------------------------------------------------------------------- 1 |

440. K-th Smallest in Lexicographical Order

Hard

Given two integers n and k, return the kth lexicographically smallest integer in the range [1, n].

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: n = 13, k = 2
 8 | Output: 10
 9 | Explanation: The lexicographical order is [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9], so the second smallest number is 10.
10 |
11 | 12 |

Example 2:

13 | 14 | 
15 | Input: n = 1, k = 1
16 | Output: 1
17 |
18 | 19 |

 

20 |

Constraints:

21 | 22 |
    23 |
  • 1 <= k <= n <= 109
    • 24 |
25 | -------------------------------------------------------------------------------- /0462-minimum-moves-to-equal-array-elements-ii/0462-minimum-moves-to-equal-array-elements-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minMoves2(vector& nums) { 4 | sort(nums.begin(),nums.end()); 5 | int n = nums.size(); 6 | int mid = nums[n/2]; 7 | int count =0; 8 | for(int i=0;i>> dp; 4 | int solve(vector& strs, int m, int n, int idx) 5 | { 6 | if(idx >= strs.size()) return 0; 7 | if(dp[m][n][idx] != -1) return dp[m][n][idx]; 8 | int oneCount = count(strs[idx].begin(),strs[idx].end(),'1'); 9 | int zeroCount = strs[idx].size()-oneCount; 10 | 11 | 12 | int not_take = solve(strs,m, n,idx+1); 13 | 14 | if(m-zeroCount >=0 && n-oneCount >= 0) 15 | { 16 | int take = 1 + solve(strs,m-zeroCount, n-oneCount,idx+1); 17 | return dp[m][n][idx] = max(take, not_take); 18 | } 19 | return dp[m][n][idx] = not_take; 20 | } 21 | int findMaxForm(vector& strs, int m, int n) { 22 | dp.resize(m+1,vector>(n+1,vector(strs.size(), -1))); 23 | return solve(strs,m,n,0); 24 | } 25 | }; -------------------------------------------------------------------------------- /0476-number-complement/0476-number-complement.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findComplement(int num) { 4 | int bitLength = (int)(log2(num))+1; 5 | for(int i=0;i& nums,int sum, int target) 5 | { 6 | if(idx >= nums.size()) 7 | { 8 | if(sum == target) return 1; 9 | return 0; 10 | } 11 | 12 | int opt1 = solve(idx+1,nums,sum+nums[idx],target); 13 | int opt2 = solve(idx+1,nums,sum-nums[idx],target); 14 | 15 | return opt1+opt2; 16 | } 17 | int findTargetSumWays(vector& nums, int target) { 18 | 19 | return solve(0,nums,0,target);; 20 | } 21 | }; -------------------------------------------------------------------------------- /0526-beautiful-arrangement/0526-beautiful-arrangement.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int count =0; 4 | void swap(vector &arr, int i,int j) 5 | { 6 | int temp = arr[i]; 7 | arr[i] = arr[j]; 8 | arr[j] = temp; 9 | } 10 | void check(vector &arr,int j) 11 | { 12 | if(j == arr.size()){ 13 | count++; 14 | return; 15 | } 16 | for(int i=j;i arr(n,0); 29 | for(int i=0;i inorder; 15 | void inorderTraversal(TreeNode* root) 16 | { 17 | if(!root) return; 18 | inorderTraversal(root->left); 19 | inorder.push_back(root->val); 20 | inorderTraversal(root->right); 21 | } 22 | int getMinimumDifference(TreeNode* root) { 23 | inorderTraversal(root); 24 | int diff = INT_MAX; 25 | for(int i=1;i& timePoints) { 4 | int n = timePoints.size(); 5 | vector inMins(n); 6 | for(int i=0;i539. Minimum Time Difference

Medium

Given a list of 24-hour clock time points in "HH:MM" format, return the minimum minutes difference between any two time-points in the list. 2 |

 

3 |

Example 1:

4 | 
Input: timePoints = ["23:59","00:00"]
 5 | Output: 1
 6 |

Example 2:

7 | 
Input: timePoints = ["00:00","23:59","00:00"]
 8 | Output: 0
 9 |
10 |

 

11 |

Constraints:

12 | 13 |
    14 |
  • 2 <= timePoints.length <= 2 * 104
    • 15 |
  • timePoints[i] is in the format "HH:MM".
    • 16 |
17 | -------------------------------------------------------------------------------- /0541-reverse-string-ii/0541-reverse-string-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string reverseStr(string s, int k) { 4 | int n = s.length(); 5 | for(int i=0;i541. Reverse String II

Easy

Given a string s and an integer k, reverse the first k characters for every 2k characters counting from the start of the string.

2 | 3 |

If there are fewer than k characters left, reverse all of them. If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and leave the other as original.

4 | 5 |

 

6 |

Example 1:

7 | 
Input: s = "abcdefg", k = 2
 8 | Output: "bacdfeg"
 9 |

Example 2:

10 | 
Input: s = "abcd", k = 2
11 | Output: "bacd"
12 |
13 |

 

14 |

Constraints:

15 | 16 |
    17 |
  • 1 <= s.length <= 104
    • 18 |
  • s consists of only lowercase English letters.
    • 19 |
  • 1 <= k <= 104
    • 20 |
21 | -------------------------------------------------------------------------------- /0567-permutation-in-string/0567-permutation-in-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool checkInclusion(string s1, string s2) { 4 | int n = s2.size(); 5 | int m = s1.size(); 6 | unordered_map mp; 7 | for(int i=0;i= 1){ 23 | greater=true; 24 | break; 25 | } 26 | } 27 | if(!greater){ 28 | return true; 29 | } 30 | 31 | mp[s2[i]]++; 32 | i++; 33 | } 34 | j++; 35 | } 36 | 37 | return false; 38 | } 39 | }; -------------------------------------------------------------------------------- /0570-managers-with-at-least-5-direct-reports/0570-managers-with-at-least-5-direct-reports.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT e1.name FROM Employee as e1 3 | JOIN Employee as e2 4 | ON e1.id = e2.managerId 5 | GROUP BY e2.managerId 6 | HAVING count(e2.managerId) >=5; -------------------------------------------------------------------------------- /0577-employee-bonus/0577-employee-bonus.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT e.name, b.bonus FROM 3 | Employee as e 4 | LEFT JOIN Bonus as b 5 | ON e.empID = b.empID 6 | WHERE b.bonus < 1000 || bonus IS NULL; -------------------------------------------------------------------------------- /0584-find-customer-referee/0584-find-customer-referee.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT name FROM Customer WHERE referee_id != 2 or referee_id is null; -------------------------------------------------------------------------------- /0595-big-countries/0595-big-countries.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT name, population, area FROM WORLD WHERE area >= 3000000 or population >= 25000000; -------------------------------------------------------------------------------- /0617-merge-two-binary-trees/0617-merge-two-binary-trees.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 8 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 9 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) { 15 | if(!root1) return root2; 16 | if(!root2) return root1; 17 | root1->val += root2->val; 18 | root1->left = mergeTrees(root1->left, root2->left); 19 | root1->right = mergeTrees(root1->right, root2->right); 20 | return root1; 21 | } 22 | }; -------------------------------------------------------------------------------- /0620-not-boring-movies/0620-not-boring-movies.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | select * from Cinema 3 | where id%2 = 1 and description not in ('boring') 4 | order by rating desc; -------------------------------------------------------------------------------- /0624-maximum-distance-in-arrays/0624-maximum-distance-in-arrays.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxDistance(vector>& arrays) { 4 | int n = arrays.size(); 5 | int minVal = arrays[0][0]; 6 | int maxVal = arrays[0].back(); 7 | int maxDist = 0; 8 | 9 | for (int i = 1; i < n; ++i) { 10 | maxDist = max(maxDist, abs(arrays[i].back() - minVal)); 11 | maxDist = max(maxDist, abs(maxVal - arrays[i][0])); 12 | 13 | minVal = min(minVal, arrays[i][0]); 14 | maxVal = max(maxVal, arrays[i].back()); 15 | } 16 | 17 | return maxDist; 18 | } 19 | }; -------------------------------------------------------------------------------- /0624-maximum-distance-in-arrays/README.md: -------------------------------------------------------------------------------- 1 |

624. Maximum Distance in Arrays

Medium

null -------------------------------------------------------------------------------- /0650-2-keys-keyboard/0650-2-keys-keyboard.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int dp[1001][1001]; 4 | int solve(int n, int currA, int clipBoardA) 5 | { 6 | if(currA == n) return 0; 7 | if(currA > n) return 100000; 8 | if(dp[currA][clipBoardA] != -1) return dp[currA][clipBoardA]; 9 | int CopyPaste = 1+1+solve(n, currA + currA,currA); 10 | int Paste = 1+solve(n, currA + clipBoardA,clipBoardA); 11 | return dp[currA][clipBoardA] = min(CopyPaste ,Paste); 12 | } 13 | int minSteps(int n) { 14 | if(n==1) return 0; 15 | memset(dp,-1,sizeof(dp)); 16 | return 1+solve(n,1,1); 17 | } 18 | }; -------------------------------------------------------------------------------- /0664-strange-printer/0664-strange-printer.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int n; 4 | vector> dp; 5 | int solve(int l, int r,string &s) 6 | { 7 | if(l==r) return 1; 8 | if(l>r) return 0; 9 | if(dp[l][r] != -1) return dp[l][r]; 10 | int i = l+1; 11 | while(i<=r && s[i] == s[l]) i++; 12 | if(i==r+1) return dp[l][r] = 1; 13 | int basic = 1+ solve(i,r,s); 14 | 15 | int greedy = INT_MAX; 16 | for(int j=i;j<=r;j++) 17 | { 18 | if(s[j] == s[l]) 19 | { 20 | int ans = solve(i,j-1,s) + solve(j,r,s); 21 | greedy = min(greedy, ans); 22 | } 23 | } 24 | return dp[l][r] = min(basic,greedy); 25 | } 26 | int strangePrinter(string s) { 27 | n = s.size(); 28 | dp.resize(n+1,vector(n+1,-1)); 29 | return solve(0,n-1,s); 30 | } 31 | }; -------------------------------------------------------------------------------- /0698-partition-to-k-equal-sum-subsets/README.md: -------------------------------------------------------------------------------- 1 |

698. Partition to K Equal Sum Subsets

Medium

Given an integer array nums and an integer k, return true if it is possible to divide this array into k non-empty subsets whose sums are all equal.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: nums = [4,3,2,3,5,2,1], k = 4
 8 | Output: true
 9 | Explanation: It is possible to divide it into 4 subsets (5), (1, 4), (2,3), (2,3) with equal sums.
10 |
11 | 12 |

Example 2:

13 | 14 | 
15 | Input: nums = [1,2,3,4], k = 3
16 | Output: false
17 |
18 | 19 |

 

20 |

Constraints:

21 | 22 |
    23 |
  • 1 <= k <= nums.length <= 16
    • 24 |
  • 1 <= nums[i] <= 104
    • 25 |
  • The frequency of each element is in the range [1, 4].
    • 26 |
27 | -------------------------------------------------------------------------------- /0713-subarray-product-less-than-k/0713-subarray-product-less-than-k.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numSubarrayProductLessThanK(vector& nums, int k) { 4 | int n = nums.size(); 5 | int l=0,r=0; 6 | int count =0; 7 | int prod = 1; 8 | while(r= k) 12 | { 13 | if(prod == 1) break; 14 | prod = prod/nums[l]; 15 | l++; 16 | } 17 | if(prod < k) 18 | { 19 | count += r-l+1; 20 | } 21 | r++; 22 | } 23 | return count; 24 | } 25 | }; -------------------------------------------------------------------------------- /0718-maximum-length-of-repeated-subarray/0718-maximum-length-of-repeated-subarray.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findLength(vector& nums1, vector& nums2) { 4 | int n1 = nums1.size(); 5 | int n2 = nums2.size(); 6 | vector> dp(n1+1,vector(n2+1,0)); 7 | int maxi = 0; 8 | for(int i=1;i<=n1;i++) 9 | { 10 | for(int j=1;j<=n2;j++) 11 | { 12 | if(nums1[i-1] == nums2[j-1]) 13 | { 14 | dp[i][j] = dp[i-1][j-1]+1; 15 | maxi = max(dp[i][j],maxi); 16 | } 17 | } 18 | } 19 | return maxi; 20 | 21 | } 22 | }; -------------------------------------------------------------------------------- /0718-maximum-length-of-repeated-subarray/README.md: -------------------------------------------------------------------------------- 1 |

718. Maximum Length of Repeated Subarray

Medium

Given two integer arrays nums1 and nums2, return the maximum length of a subarray that appears in both arrays.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
 8 | Output: 3
 9 | Explanation: The repeated subarray with maximum length is [3,2,1].
10 |
11 | 12 |

Example 2:

13 | 14 | 
15 | Input: nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
16 | Output: 5
17 | Explanation: The repeated subarray with maximum length is [0,0,0,0,0].
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 |
    24 |
  • 1 <= nums1.length, nums2.length <= 1000
    • 25 |
  • 0 <= nums1[i], nums2[i] <= 100
    • 26 |
27 | -------------------------------------------------------------------------------- /0719-find-k-th-smallest-pair-distance/0719-find-k-th-smallest-pair-distance.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int smallestDistancePair(vector& nums, int k) { 4 | int n = nums.size(); 5 | int maxEl = *max_element(nums.begin(),nums.end()); 6 | vector vec(maxEl+1,0); 7 | for(int i=0;i> st; 4 | MyCalendar() { 5 | 6 | } 7 | 8 | bool book(int start, int end) { 9 | auto it = st.lower_bound({start,end}); 10 | 11 | if(it != st.end() && it->firstsecond) return false; 16 | } 17 | 18 | st.insert({start,end}); 19 | 20 | return true; 21 | } 22 | }; 23 | 24 | /** 25 | * Your MyCalendar object will be instantiated and called as such: 26 | * MyCalendar* obj = new MyCalendar(); 27 | * bool param_1 = obj->book(start,end); 28 | */ -------------------------------------------------------------------------------- /0731-my-calendar-ii/0731-my-calendar-ii.cpp: -------------------------------------------------------------------------------- 1 | class MyCalendarTwo { 2 | public: 3 | vector> doubleOverlappedRegion; 4 | vector> overallBookings; 5 | 6 | bool checkOverlap(int start1, int end1, int start2, int end2) { 7 | return max(start1, start2) < min(end1, end2); 8 | } 9 | 10 | pair findOverlappedRegion(int start1, int end1, int start2, int end2) { 11 | return {max(start1, start2), min(end1, end2)}; 12 | } 13 | 14 | MyCalendarTwo() { 15 | 16 | } 17 | 18 | bool book(int start, int end) { 19 | for(pair region : doubleOverlappedRegion) { 20 | if(checkOverlap(region.first, region.second, start, end)) { 21 | return false; 22 | } 23 | } 24 | 25 | for(pair booking : overallBookings) { 26 | if(checkOverlap(booking.first, booking.second, start, end)) { 27 | doubleOverlappedRegion.push_back(findOverlappedRegion(booking.first, booking.second, start, end)); 28 | } 29 | } 30 | 31 | overallBookings.push_back({start, end}); 32 | return true; 33 | } 34 | }; -------------------------------------------------------------------------------- /0739-daily-temperatures/0739-daily-temperatures.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector dailyTemperatures(vector& temperatures) { 4 | int n = temperatures.size(); 5 | vector answer(n); 6 | stack st; 7 | for(int i=n-1;i>=0;i--) 8 | { 9 | while(!st.empty() && temperatures[i] >= temperatures[st.top()] ) st.pop(); 10 | if(st.empty()) 11 | { 12 | answer[i]=0; 13 | }else{ 14 | answer[i] = st.top() - i; 15 | } 16 | st.push(i); 17 | } 18 | return answer; 19 | } 20 | }; -------------------------------------------------------------------------------- /0776-n-ary-tree-postorder-traversal/0776-n-ary-tree-postorder-traversal.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | // Definition for a Node. 3 | class Node { 4 | public: 5 | int val; 6 | vector children; 7 | 8 | Node() {} 9 | 10 | Node(int _val) { 11 | val = _val; 12 | } 13 | 14 | Node(int _val, vector _children) { 15 | val = _val; 16 | children = _children; 17 | } 18 | }; 19 | */ 20 | 21 | class Solution { 22 | public: 23 | vector ans; 24 | void helper(Node* & root) 25 | { 26 | if(root == NULL) return; 27 | 28 | for(int i=0;ichildren.size();i++) 29 | { 30 | helper(root->children[i]); 31 | } 32 | ans.push_back(root->val); 33 | } 34 | vector postorder(Node* root) { 35 | helper(root); 36 | return ans; 37 | } 38 | }; -------------------------------------------------------------------------------- /0778-reorganize-string/0778-reorganize-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string reorganizeString(string s) { 4 | int n = s.length(); 5 | unordered_map mp; 6 | priority_queue> pq; 7 | for(auto ch : s) 8 | { 9 | mp[ch]++; 10 | if(mp[ch] > (n+1)/2) return ""; 11 | } 12 | for(auto p : mp) 13 | { 14 | pq.push({p.second,p.first}); 15 | } 16 | string result = ""; 17 | while(pq.size() >= 2) 18 | { 19 | auto p1 = pq.top(); 20 | pq.pop(); 21 | auto p2 = pq.top(); 22 | pq.pop(); 23 | 24 | result.push_back(p1.second); 25 | result.push_back(p2.second); 26 | p1.first -= 1; 27 | p2.first -= 1; 28 | if(p1.first >=1) pq.push(p1); 29 | if(p2.first >=1) pq.push(p2); 30 | } 31 | if(!pq.empty()) result.push_back(pq.top().second); 32 | return result; 33 | } 34 | }; -------------------------------------------------------------------------------- /0778-reorganize-string/README.md: -------------------------------------------------------------------------------- 1 |

778. Reorganize String

Medium

Given a string s, rearrange the characters of s so that any two adjacent characters are not the same.

2 | 3 |

Return any possible rearrangement of s or return "" if not possible.

4 | 5 |

 

6 |

Example 1:

7 | 
Input: s = "aab"
 8 | Output: "aba"
 9 |

Example 2:

10 | 
Input: s = "aaab"
11 | Output: ""
12 |
13 |

 

14 |

Constraints:

15 | 16 |
    17 |
  • 1 <= s.length <= 500
    • 18 |
  • s consists of lowercase English letters.
    • 19 |
20 | -------------------------------------------------------------------------------- /0789-kth-largest-element-in-a-stream/0789-kth-largest-element-in-a-stream.cpp: -------------------------------------------------------------------------------- 1 | class KthLargest { 2 | public: 3 | priority_queue, greater> pq; 4 | int K; 5 | KthLargest(int k, vector& nums) { 6 | K =k; 7 | for(auto x : nums) 8 | { 9 | pq.push(x); 10 | if(pq.size()>k) pq.pop(); 11 | } 12 | 13 | } 14 | 15 | int add(int val) { 16 | pq.push(val); 17 | if(pq.size()>K) pq.pop(); 18 | return pq.top(); 19 | } 20 | }; 21 | 22 | /** 23 | * Your KthLargest object will be instantiated and called as such: 24 | * KthLargest* obj = new KthLargest(k, nums); 25 | * int param_1 = obj->add(val); 26 | */ -------------------------------------------------------------------------------- /0890-lemonade-change/0890-lemonade-change.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool lemonadeChange(vector& bills) { 4 | int n = bills.size(); 5 | unordered_map mp; 6 | for(int i : bills) 7 | { 8 | if(i==5) 9 | { 10 | mp[i]++; 11 | } 12 | else if(i == 10) 13 | { 14 | if(mp[5] >0) 15 | { 16 | mp[5]--; 17 | mp[i]++; 18 | }else return false; 19 | }else{ 20 | if(mp[10] > 0 && mp[5] > 0) 21 | { 22 | mp[5]--; 23 | mp[10]--; 24 | } 25 | else if(mp[5]>=3) 26 | { 27 | mp[5]--; 28 | mp[5]--; 29 | mp[5]--; 30 | }else return false; 31 | } 32 | } 33 | return true; 34 | } 35 | }; -------------------------------------------------------------------------------- /0920-uncommon-words-from-two-sentences/0920-uncommon-words-from-two-sentences.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector uncommonFromSentences(string s1, string s2) { 4 | unordered_map mp; 5 | string token = ""; 6 | stringstream ss1(s1); 7 | stringstream ss2(s2); 8 | while(getline(ss1,token,' ')) 9 | { 10 | mp[token]++; 11 | } 12 | while(getline(ss2,token,' ')) 13 | { 14 | mp[token]++; 15 | } 16 | vector ans; 17 | for(auto p : mp) 18 | { 19 | if(p.second == 1) 20 | { 21 | ans.push_back(p.first); 22 | } 23 | } 24 | return ans; 25 | } 26 | }; -------------------------------------------------------------------------------- /0921-spiral-matrix-iii/0921-spiral-matrix-iii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> spiralMatrixIII(int rows, int cols, int rStart, int cStart) { 4 | vector> mp = {{0,1},{1,0},{0,-1},{-1,0}}; // E,S,W,N 5 | vector> ans; 6 | ans.push_back({rStart, cStart}); 7 | int dir =0, steps=0; 8 | while(ans.size() = 0 && rStart < rows && cStart >= 0 && cStart < cols) 16 | { 17 | ans.push_back({rStart, cStart}); 18 | } 19 | } 20 | dir = (dir+1)%4; 21 | } 22 | return ans; 23 | } 24 | }; -------------------------------------------------------------------------------- /0937-online-stock-span/0937-online-stock-span.cpp: -------------------------------------------------------------------------------- 1 | class StockSpanner { 2 | public: 3 | stack> st; 4 | StockSpanner() { 5 | 6 | } 7 | 8 | int next(int price) { 9 | int span = 1; 10 | while (!st.empty() && st.top().first <= price) { 11 | span += st.top().second; 12 | st.pop(); 13 | } 14 | st.push({price, span}); 15 | return span; 16 | } 17 | }; 18 | 19 | /** 20 | * Your StockSpanner object will be instantiated and called as such: 21 | * StockSpanner* obj = new StockSpanner(); 22 | * int param_1 = obj->next(price); 23 | */ -------------------------------------------------------------------------------- /0943-sum-of-subarray-minimums/0943-sum-of-subarray-minimums.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int sumSubarrayMins(vector& arr) { 4 | int n = arr.size(); 5 | vector left(n), right(n); 6 | stack> st; 7 | 8 | for (int i = 0; i < n; i++) { 9 | while (!st.empty() && st.top().first > arr[i]) 10 | st.pop(); 11 | left[i] = st.empty() ? -1 : st.top().second; 12 | st.push({arr[i], i}); 13 | } 14 | 15 | while (!st.empty()) st.pop(); 16 | 17 | for (int i = n - 1; i >= 0; i--) { 18 | while (!st.empty() && st.top().first >= arr[i]) 19 | st.pop(); 20 | right[i] = st.empty() ? n : st.top().second; 21 | st.push({arr[i], i}); 22 | } 23 | 24 | long long result = 0; 25 | const int MOD = 1e9 + 7; 26 | for (int i = 0; i < n; ++i) { 27 | result = (result + (long long)arr[i] * (i - left[i]) * (right[i] - i)) % MOD; 28 | } 29 | 30 | return result; 31 | } 32 | }; -------------------------------------------------------------------------------- /0943-sum-of-subarray-minimums/README.md: -------------------------------------------------------------------------------- 1 |

943. Sum of Subarray Minimums

Medium

Given an array of integers arr, find the sum of min(b), where b ranges over every (contiguous) subarray of arr. Since the answer may be large, return the answer modulo 109 + 7.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: arr = [3,1,2,4]
 8 | Output: 17
 9 | Explanation: 
10 | Subarrays are [3], [1], [2], [4], [3,1], [1,2], [2,4], [3,1,2], [1,2,4], [3,1,2,4]. 
11 | Minimums are 3, 1, 2, 4, 1, 1, 2, 1, 1, 1.
12 | Sum is 17.
13 |
14 | 15 |

Example 2:

16 | 17 | 
18 | Input: arr = [11,81,94,43,3]
19 | Output: 444
20 |
21 | 22 |

 

23 |

Constraints:

24 | 25 |
    26 |
  • 1 <= arr.length <= 3 * 104
    • 27 |
  • 1 <= arr[i] <= 3 * 104
    • 28 |
29 | -------------------------------------------------------------------------------- /0948-sort-an-array/0948-sort-an-array.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector sortArray(vector& nums) { 4 | unordered_map mp; 5 | for( int n : nums) 6 | { 7 | mp[n]++; 8 | } 9 | int mini = *min_element(nums.begin(),nums.end()); 10 | int maxi = *max_element(nums.begin(),nums.end()); 11 | 12 | int i=0; 13 | for(int p = mini;p<=maxi;p++) 14 | { 15 | while(mp[p]>0) 16 | { 17 | nums[i] = p; 18 | i++; 19 | mp[p]--; 20 | } 21 | } 22 | return nums; 23 | } 24 | }; -------------------------------------------------------------------------------- /0957-minimum-add-to-make-parentheses-valid/0957-minimum-add-to-make-parentheses-valid.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minAddToMakeValid(string s) { 4 | int n = s.size(); 5 | stack st; 6 | int count = 0; 7 | for(int i=0;i 0) return count+st.size(); 18 | return count; 19 | } 20 | }; -------------------------------------------------------------------------------- /0966-binary-subarrays-with-sum/0966-binary-subarrays-with-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numSubarraysWithSum(vector& nums, int goal) { 4 | int n = nums.size(); 5 | unordered_map mp; 6 | mp[0] = 1; 7 | int sum = 0; 8 | int cnt =0; 9 | for(int i=0;ileft,low,high); 20 | if(root->val >= low && root->val <= high) count += root->val; 21 | sum(root->right,low,high); 22 | } 23 | int rangeSumBST(TreeNode* root, int low, int high) { 24 | sum(root,low,high); 25 | return count; 26 | } 27 | }; -------------------------------------------------------------------------------- /0984-most-stones-removed-with-same-row-or-column/0984-most-stones-removed-with-same-row-or-column.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int n; 4 | int count; 5 | vector vis; 6 | void dfs(int idx, vector>& stones) 7 | { 8 | vis[idx] = true; 9 | 10 | for(int i=0;i>& stones) { 19 | n = stones.size(); 20 | int groups = 0; 21 | vis.resize(n,false); 22 | for(int i=0;i& arr) { 4 | int n = arr.size(); 5 | int maxi = 0; 6 | int max_right[n]; 7 | max_right[n-1] = arr[n-1]; 8 | for(int i=n-2;i>=0;i--) 9 | { 10 | max_right[i] = max(max_right[i+1] ,arr[i]); 11 | } 12 | int i=0; 13 | int j=0; 14 | while(j dp(n+1); 7 | dp[0] = 0; 8 | dp[1] = 1; 9 | for(int i=2;i<=n;i++) 10 | { 11 | dp[i] = dp[i-1] + dp[i-2]; 12 | } 13 | return dp[n]; 14 | } 15 | }; -------------------------------------------------------------------------------- /1028-interval-list-intersections/1028-interval-list-intersections.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> intervalIntersection(vector>& f, vector>& s) { 4 | vector> ans; 5 | int i = 0, j = 0; 6 | while (i < f.size() && j < s.size()) { 7 | int start = max(f[i][0], s[j][0]); 8 | int end = min(f[i][1], s[j][1]); 9 | 10 | if (start <= end) { 11 | ans.push_back({start, end}); 12 | } 13 | 14 | if (f[i][1] < s[j][1]) { 15 | i++; 16 | } else { 17 | j++; 18 | } 19 | } 20 | return ans; 21 | } 22 | }; -------------------------------------------------------------------------------- /1196-filling-bookcase-shelves/1196-filling-bookcase-shelves.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int WIDTH; 4 | int dp[1001][1001]; 5 | int solve(int i, vector>& books, int remainingWidth,int maxHeight) 6 | { 7 | if(i>= books.size()) return maxHeight; 8 | if(dp[i][remainingWidth] != -1) return dp[i][remainingWidth]; 9 | int bookW = books[i][0]; 10 | int bookH = books[i][1]; 11 | int keep=INT_MAX, skip=INT_MAX; 12 | if(bookW <= remainingWidth){ 13 | keep = solve(i+1,books,remainingWidth-bookW,max(maxHeight,bookH)); 14 | } 15 | skip = maxHeight + solve(i+1,books,WIDTH-bookW,bookH); 16 | return dp[i][remainingWidth] = min(keep,skip); 17 | } 18 | int minHeightShelves(vector>& books, int shelfWidth) { 19 | memset(dp,-1,sizeof(dp)); 20 | WIDTH = shelfWidth; 21 | return solve(0,books,shelfWidth,0); 22 | } 23 | }; -------------------------------------------------------------------------------- /1250-longest-common-subsequence/1250-longest-common-subsequence.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | 4 | int longestCommonSubsequence(string text1, string text2) { 5 | int n = text1.size(); 6 | int m = text2.size(); 7 | if(n <= 0 || m <= 0) return 0; 8 | vector> dp(n+1, vector(m+1)); 9 | for(int i=0;i arrayRankTransform(vector& arr) { 4 | unordered_map mp; 5 | set st(arr.begin(),arr.end()); 6 | int rank =1; 7 | for(int num : st) 8 | { 9 | mp[num] = rank; 10 | rank++; 11 | } 12 | for(int i=0;i> st; 5 | for (char ch : s) { 6 | if (!st.empty() && st.top().first == ch) { 7 | st.top().second++; 8 | if (st.top().second == k) { 9 | st.pop(); 10 | } 11 | } else { 12 | st.push({ch, 1}); 13 | } 14 | } 15 | 16 | string result; 17 | while (!st.empty()) { 18 | result.append(st.top().second, st.top().first); 19 | st.pop(); 20 | } 21 | reverse(result.begin(), result.end()); // reverse the result to correct the order 22 | return result; 23 | } 24 | }; -------------------------------------------------------------------------------- /1333-sort-the-jumbled-numbers/1333-sort-the-jumbled-numbers.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector sortJumbled(vector& mapping, vector& nums) { 4 | vector> mp; 5 | int n = nums.size(); 6 | for(int i=0;i ans; 18 | for(auto p : mp) 19 | { 20 | int ind = p.second; 21 | ans.push_back(nums[ind]); 22 | } 23 | return ans; 24 | } 25 | }; -------------------------------------------------------------------------------- /1402-count-square-submatrices-with-all-ones/1402-count-square-submatrices-with-all-ones.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int countSquares(vector>& matrix) { 4 | int n = matrix.size(); 5 | int m = matrix[0].size(); 6 | vector> dp(n,vector(m,0)); 7 | for(int j=0;j xorQueries(vector& arr, vector>& queries) { 4 | int n = queries.size(); 5 | int m = arr.size(); 6 | vector ans; 7 | vector PreXor(m); 8 | PreXor[0] = arr[0]; 9 | for(int i=1;i st; 4 | vector inc; 5 | int size; 6 | int top; 7 | 8 | CustomStack(int maxSize) { 9 | st = vector(maxSize); 10 | inc = vector(maxSize, 0); 11 | size = maxSize; 12 | top = -1; 13 | } 14 | 15 | void push(int x) { 16 | if(top + 1 < size) { 17 | top++; 18 | st[top] = x; 19 | } 20 | } 21 | 22 | int pop() { 23 | if(top == -1) return -1; 24 | int poppedValue = st[top] + inc[top]; 25 | if(top > 0) { 26 | inc[top-1] += inc[top]; 27 | } 28 | 29 | inc[top] = 0; 30 | top--; 31 | 32 | return poppedValue; 33 | } 34 | 35 | void increment(int k, int val) { 36 | int limit = min(k, top + 1); 37 | if(limit > 0) { 38 | inc[limit - 1] += val; 39 | } 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /1509-replace-employee-id-with-the-unique-identifier/1509-replace-employee-id-with-the-unique-identifier.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT u.unique_id, e.name FROM Employees as e 3 | LEFT JOIN EmployeeUNI as u ON e.id = u.id; -------------------------------------------------------------------------------- /1511-count-number-of-teams/1511-count-number-of-teams.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numTeams(vector& rating) { 4 | int n = rating.size(); 5 | int count =0; 6 | for(int j=1;jrating[j]) countLargerLeft++; 14 | } 15 | for(int i=j;irating[j]) countLargerRight++; 19 | } 20 | count+= countSmallerLeft*countLargerRight; 21 | count+= countLargerLeft*countSmallerRight; 22 | } 23 | return count; 24 | } 25 | }; -------------------------------------------------------------------------------- /1556-make-two-arrays-equal-by-reversing-subarrays/1556-make-two-arrays-equal-by-reversing-subarrays.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool canBeEqual(vector& target, vector& arr) { 4 | unordered_map freq; 5 | for(int i : arr) 6 | { 7 | freq[i]++; 8 | } 9 | for(int i : target) 10 | { 11 | freq[i]--; 12 | } 13 | for(auto p : freq) 14 | { 15 | if(p.second >= 1) return false; 16 | } 17 | return true; 18 | } 19 | }; -------------------------------------------------------------------------------- /1615-range-sum-of-sorted-subarray-sums/1615-range-sum-of-sorted-subarray-sums.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | #define mod 1000000007 4 | int rangeSum(vector& nums, int n, int left, int right) { 5 | vector v; 6 | for(int i=0;i& arr, int k) { 4 | int n = arr.size(); 5 | vector mp(k,0); 6 | for(int i=0;i>& points, int k) { 4 | int n = points.size(); 5 | priority_queue> pq; 6 | int maxValue = INT_MIN; 7 | for(auto &pt : points){ 8 | int x_j = pt[0]; 9 | int y_j = pt[1]; 10 | 11 | while(!pq.empty() && x_j - pq.top().second > k){ 12 | pq.pop(); 13 | } 14 | if (!pq.empty()) { 15 | maxValue = max(maxValue, y_j + x_j + pq.top().first); 16 | } 17 | pq.emplace(y_j - x_j, x_j); 18 | } 19 | return maxValue; 20 | } 21 | }; -------------------------------------------------------------------------------- /1666-make-the-string-great/1666-make-the-string-great.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string makeGood(string s) { 4 | string res = ""; 5 | for(int i=0;i& nums, int p) { 4 | int n = nums.size(); 5 | long long sum = accumulate(nums.begin(),nums.end(),0LL); 6 | int rem = sum%p; 7 | if(rem == 0) return 0; 8 | unordered_map mp; 9 | mp[0] = -1; 10 | int ans = n; 11 | long long prefix_sum = 0; 12 | long long curr_mod; 13 | int target_mod; 14 | for(int i=0;i& neededTime) { 4 | int n = colors.size(); 5 | int time =0; 6 | int prevMax = 0; 7 | 8 | for(int i=0;i0 && colors[i] != colors[i-1]){ 11 | prevMax=0; 12 | } 13 | 14 | int curr = neededTime[i]; 15 | time += min(prevMax, curr); 16 | prevMax = max(prevMax,curr); 17 | } 18 | return time; 19 | } 20 | }; -------------------------------------------------------------------------------- /1724-customer-who-visited-but-did-not-make-any-transactions/1724-customer-who-visited-but-did-not-make-any-transactions.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT v.customer_id, count(v.visit_id) as count_no_trans 3 | FROM Visits as v 4 | LEFT JOIN Transactions as t 5 | ON v.visit_id = t.visit_id 6 | WHERE t.transaction_id IS NULL 7 | GROUP BY v.customer_id; -------------------------------------------------------------------------------- /1756-minimum-deletions-to-make-string-balanced/1756-minimum-deletions-to-make-string-balanced.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minimumDeletions(string s) { 4 | int n = s.size(); 5 | int count=0; 6 | stack st; 7 | for(int i=0;i& heights, int bricks, int ladders) { 4 | int n = heights.size(); 5 | int count = 0; 6 | priority_queue pq; 7 | int i; 8 | for (i = 0; i < n - 1; i++) { 9 | int diff = heights[i + 1] - heights[i]; 10 | 11 | if(heights[i+1] <= heights[i]) continue; 12 | if(diff<=bricks) 13 | { 14 | bricks-= diff; 15 | pq.push(diff); 16 | }else if(ladders >0) 17 | { 18 | if(!pq.empty()) 19 | { 20 | int maxPast = pq.top(); 21 | if(maxPast>diff) 22 | { 23 | bricks += maxPast; 24 | pq.pop(); 25 | bricks -= diff; 26 | pq.push(diff); 27 | } 28 | } 29 | ladders--; 30 | }else break; 31 | } 32 | 33 | return i; 34 | } 35 | }; -------------------------------------------------------------------------------- /1770-minimum-deletions-to-make-character-frequencies-unique/1770-minimum-deletions-to-make-character-frequencies-unique.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minDeletions(string s) { 4 | unordered_map freq; 5 | for (char c : s) { 6 | freq[c]++; 7 | } 8 | 9 | vector counts; 10 | for (auto& p : freq) { 11 | counts.push_back(p.second); 12 | } 13 | 14 | sort(counts.begin(), counts.end(), greater()); 15 | 16 | int deletions = 0; 17 | for (int i = 1; i < counts.size(); i++) { 18 | while (i < counts.size() && counts[i] >= counts[i - 1] && counts[i] > 0) { 19 | counts[i]--; 20 | deletions++; 21 | } 22 | } 23 | 24 | return deletions; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /1781-check-if-two-string-arrays-are-equivalent/1781-check-if-two-string-arrays-are-equivalent.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool arrayStringsAreEqual(vector& word1, vector& word2) { 4 | string str1 = ""; 5 | string str2 = ""; 6 | for(int i=0;i& words) { 4 | int n = words.size(); 5 | unordered_set mp; 6 | int count =0; 7 | for(int i=0;i mostCompetitive(vector& nums, int k) { 4 | int n = nums.size(); 5 | stack st; 6 | 7 | for (int i = 0; i < n; ++i) { 8 | while (!st.empty() && nums[i] < nums[st.top()] && st.size() + (n - i) > k) { 9 | st.pop(); 10 | } 11 | 12 | if (st.size() < k) { 13 | st.push(i); 14 | } 15 | } 16 | 17 | vector ans; 18 | while (!st.empty()) { 19 | ans.push_back(nums[st.top()]); 20 | st.pop(); 21 | } 22 | 23 | reverse(ans.begin(), ans.end()); 24 | 25 | return ans; 26 | } 27 | }; -------------------------------------------------------------------------------- /1801-average-time-of-process-per-machine/1801-average-time-of-process-per-machine.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT a1.machine_id , round(avg(a2.timestamp-a1.timestamp),3) as processing_time 3 | FROM activity a1 4 | JOIN activity a2 5 | ON a1.machine_id = a2.machine_id 6 | AND a1.process_id = a2.process_id 7 | AND a1.timestamp & nums) { 4 | int n = nums.size(); 5 | unordered_set st; 6 | int i=0, j=0; 7 | int currSum = 0; 8 | int maxi = 0; 9 | while(j st = {'A','E','I','O','U','a','e','i','o','u'}; 5 | string str1 = s.substr(0,s.length()/2); 6 | string str2 = s.substr((s.length()/2),s.length()/2); 7 | int n1 = 0; 8 | int n2 = 0; 9 | for(int i=0;i 15; -------------------------------------------------------------------------------- /1908-recyclable-and-low-fat-products/1908-recyclable-and-low-fat-products.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT product_id FROM Products Where low_fats='Y' and recyclable='Y'; -------------------------------------------------------------------------------- /1923-sentence-similarity-iii/1923-sentence-similarity-iii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool areSentencesSimilar(string s1, string s2) { 4 | if(s1.size() < s2.size()) swap(s1,s2); 5 | 6 | vector v1, v2; 7 | stringstream ss1(s1); 8 | string token; 9 | while(ss1>>token) 10 | { 11 | v1.push_back(token); 12 | } 13 | stringstream ss2(s2); 14 | while(ss2>>token) 15 | { 16 | v2.push_back(token); 17 | } 18 | 19 | int i=0, j= v1.size()-1; 20 | int k=0, l= v2.size()-1; 21 | while(i= i && l>=k && v1[j] == v2[l]) 27 | { 28 | j--; 29 | l--; 30 | } 31 | return l& chalk, int k) { 4 | int n = chalk.size(); 5 | long long sum = accumulate(chalk.begin(),chalk.end(),0LL); 6 | int rem = k%sum; 7 | int i=0; 8 | while(rem >= chalk[i]) 9 | { 10 | rem -= chalk[i]; 11 | i = (i+1) % n; 12 | } 13 | return i; 14 | } 15 | }; -------------------------------------------------------------------------------- /2067-maximum-number-of-points-with-cost/2067-maximum-number-of-points-with-cost.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | long long maxPoints(vector>& points) { 4 | int m = points.size(); 5 | int n = points[0].size(); 6 | vector prev(n); 7 | for(int col=0;col left(n,0); 14 | vector right(n,0); 15 | left[0] = prev[0]; 16 | for(int j=1;j=0;j--) 22 | { 23 | right[j] = max(prev[j],right[j+1]-1); 24 | } 25 | vector curr(n); 26 | for(int j=0;j st; 7 | for(int i=0;i> construct2DArray(vector& original, int m, int n) { 4 | if (m * n != original.size()) { 5 | return {}; 6 | } 7 | vector> v(m,vector(n)); 8 | for(int i=0;i missingRolls(vector& rolls, int mean, int n) { 4 | int m=rolls.size(),sumM=0; 5 | for(auto x:rolls) sumM+=x; 6 | int rhs=mean*(n+m); 7 | rhs-=sumM; 8 | int x=rhs/n,y=rhs%n; 9 | if(x<=0 || x>6) return {}; 10 | if(x==6 && y>0) return {}; 11 | vectorans(n); 12 | for(int i=0;i& arr, int k) { 4 | int n = arr.size(); 5 | unordered_map mp; 6 | for(int i=0;i 2 | #include 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | int minSwaps(vector& nums) { 8 | int n = nums.size(); 9 | int oneCount = 0; 10 | 11 | for(int i = 0; i < n; i++) { 12 | if(nums[i] == 1) oneCount++; 13 | } 14 | 15 | if (oneCount == 0 || oneCount == n) return 0; 16 | 17 | nums.insert(nums.end(), nums.begin(), nums.end()); 18 | 19 | int zeroCount = 0; 20 | for(int i = 0; i < oneCount; i++) { 21 | if(nums[i] == 0) zeroCount++; 22 | } 23 | 24 | int minSwaps = zeroCount; 25 | for(int i = oneCount; i < 2 * n; i++) { 26 | if(nums[i - oneCount] == 0) zeroCount--; 27 | if(nums[i] == 0) zeroCount++; 28 | minSwaps = min(minSwaps, zeroCount); 29 | } 30 | 31 | return minSwaps; 32 | } 33 | }; 34 | -------------------------------------------------------------------------------- /2323-minimum-bit-flips-to-convert-number/2323-minimum-bit-flips-to-convert-number.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minBitFlips(int start, int goal) { 4 | int count =0; 5 | while(start >0 || goal > 0) 6 | { 7 | if((start&1) != (goal&1)) 8 | { 9 | count++; 10 | } 11 | start = start>>1; 12 | goal = goal>>1; 13 | } 14 | return count; 15 | } 16 | }; -------------------------------------------------------------------------------- /2488-divide-intervals-into-minimum-number-of-groups/2488-divide-intervals-into-minimum-number-of-groups.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minGroups(vector>& intervals) { 4 | int n = intervals.size(); 5 | sort(intervals.begin(),intervals.end()); 6 | priority_queue, greater> pq; 7 | for(auto p : intervals) 8 | { 9 | int start = p[0]; 10 | int end = p[1]; 11 | if(!pq.empty() && start > pq.top()){ 12 | pq.pop(); 13 | pq.push(end); 14 | }else{ 15 | pq.push(end); 16 | } 17 | } 18 | return pq.size(); 19 | } 20 | }; -------------------------------------------------------------------------------- /2503-longest-subarray-with-maximum-bitwise-and/2503-longest-subarray-with-maximum-bitwise-and.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int longestSubarray(vector& nums) { 4 | int n = nums.size(); 5 | int maxi = *max_element(nums.begin(), nums.end()); 6 | int max_ans = 0; 7 | int count = 0; 8 | 9 | for (int i = 0; i < n; i++) { 10 | if (nums[i] == maxi) { 11 | count++; 12 | max_ans = max(max_ans, count); 13 | } else { 14 | count = 0; 15 | } 16 | } 17 | 18 | return max_ans; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /2581-divide-players-into-teams-of-equal-skill/2581-divide-players-into-teams-of-equal-skill.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | long long dividePlayers(vector& skill) { 4 | int n = skill.size(); 5 | if(n == 2) return skill[0]*skill[1]; 6 | sort(skill.begin(),skill.end()); 7 | int i=1; 8 | int j=n-2; 9 | long long common = skill[0]+skill[n-1]; 10 | long long ans = skill[0]*skill[n-1]; 11 | while(i& details) { 4 | int n = details.size(); 5 | int count =0; 6 | for(int i=0;i60) count++; 11 | } 12 | return count; 13 | } 14 | }; -------------------------------------------------------------------------------- /2732-counter/2732-counter.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {Function} counter 4 | */ 5 | var createCounter = function(n) { 6 | 7 | return function() { 8 | return n++; 9 | }; 10 | }; 11 | 12 | /** 13 | * const counter = createCounter(10) 14 | * counter() // 10 15 | * counter() // 11 16 | * counter() // 12 17 | */ -------------------------------------------------------------------------------- /2755-extra-characters-in-a-string/2755-extra-characters-in-a-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector dp; 4 | int solve(int i, unordered_set &st, string &s, int n) 5 | { 6 | if(i>=n) return 0; 7 | if(dp[i] != -1) return dp[i]; 8 | int res = 1+ solve(i+1,st,s,n); 9 | for(int j=i;j& dict) { 20 | int n = s.size(); 21 | dp.resize(n,-1); 22 | unordered_set st(dict.begin(),dict.end()); 23 | return solve(0,st,s,n); 24 | } 25 | }; -------------------------------------------------------------------------------- /2789-counter-ii/2789-counter-ii.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {integer} init 3 | * @return { increment: Function, decrement: Function, reset: Function } 4 | */ 5 | var createCounter = function(init) { 6 | let curr = init; 7 | function increment(){ 8 | return ++curr; 9 | } 10 | function decrement(){ 11 | return --curr; 12 | } 13 | function reset(){ 14 | return curr = init; 15 | } 16 | 17 | return {increment, decrement, reset}; 18 | }; 19 | 20 | /** 21 | * const counter = createCounter(5) 22 | * counter.increment(); // 6 23 | * counter.reset(); // 5 24 | * counter.decrement(); // 4 25 | */ -------------------------------------------------------------------------------- /2800-minimum-string-length-after-removing-substrings/2800-minimum-string-length-after-removing-substrings.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minLength(string s) { 4 | string s1 = "AB"; 5 | string s2 = "CD"; 6 | stack st; 7 | for(int i=0;i 8 | { 9 | if(val === v) return true; 10 | else throw new Error("Not Equal"); 11 | }, 12 | notToBe : (v) =>{ 13 | if(val !== v) return true; 14 | else throw new Error("Equal"); 15 | }}; 16 | }; 17 | 18 | /** 19 | * expect(5).toBe(5); // true 20 | * expect(5).notToBe(5); // throws "Equal" 21 | */ -------------------------------------------------------------------------------- /3275-minimum-number-of-pushes-to-type-word-i/3275-minimum-number-of-pushes-to-type-word-i.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minimumPushes(string word) { 4 | vector mp(26,0); 5 | for(char ch : word) 6 | { 7 | mp[ch-'a']++; 8 | } 9 | sort(mp.begin(),mp.end(),greater()); 10 | int sum =0; 11 | for(int i=0;i<26;i++) 12 | { 13 | int freq = mp[i]; 14 | int press = i/8+1; 15 | sum+= press * freq; 16 | } 17 | return sum; 18 | } 19 | }; -------------------------------------------------------------------------------- /3276-minimum-number-of-pushes-to-type-word-ii/3276-minimum-number-of-pushes-to-type-word-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minimumPushes(string word) { 4 | vector mp(26,0); 5 | for(char ch : word) 6 | { 7 | mp[ch-'a']++; 8 | } 9 | sort(mp.begin(),mp.end(),greater()); 10 | int sum =0; 11 | for(int i=0;i<26;i++) 12 | { 13 | int freq = mp[i]; 14 | int press = i/8+1; 15 | sum+= press * freq; 16 | } 17 | return sum; 18 | } 19 | }; -------------------------------------------------------------------------------- /3501-delete-nodes-from-linked-list-present-in-array/3501-delete-nodes-from-linked-list-present-in-array.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode() : val(0), next(nullptr) {} 7 | * ListNode(int x) : val(x), next(nullptr) {} 8 | * ListNode(int x, ListNode *next) : val(x), next(next) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | ListNode* modifiedList(vector& nums, ListNode* head) { 14 | unordered_set numSet(nums.begin(), nums.end()); 15 | ListNode* curr = head; 16 | ListNode* prev = new ListNode(-1); 17 | ListNode* newHead = prev; 18 | prev->next = curr; 19 | while(curr) 20 | { 21 | int value = prev->next->val; 22 | if(numSet.find(value) != numSet.end()) 23 | { 24 | prev->next = curr ->next; 25 | curr = curr->next; 26 | }else{ 27 | prev = prev->next; 28 | curr = curr ->next; 29 | } 30 | } 31 | return newHead->next; 32 | } 33 | }; 34 | -------------------------------------------------------------------------------- /3510-maximize-the-total-height-of-unique-towers/3510-maximize-the-total-height-of-unique-towers.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | long long maximumTotalSum(vector& maximumHeight) { 4 | int n = maximumHeight.size(); 5 | 6 | sort(maximumHeight.begin(), maximumHeight.end()); 7 | 8 | long long totalSum = 0; 9 | int currentHeight = maximumHeight[n - 1]; 10 | 11 | for (int i = n - 1; i >= 0; --i) { 12 | if (currentHeight > maximumHeight[i]) { 13 | currentHeight = maximumHeight[i]; 14 | } 15 | 16 | if (currentHeight <= 0) { 17 | return -1; 18 | } 19 | 20 | totalSum += currentHeight; 21 | currentHeight--; 22 | } 23 | 24 | return totalSum; 25 | } 26 | }; -------------------------------------------------------------------------------- /3519-find-the-number-of-winning-players/3519-find-the-number-of-winning-players.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int winningPlayerCount(int n, vector>& pick) { 4 | vector> playerColorCount(n); 5 | 6 | for (auto p : pick) { 7 | int player = p[0]; 8 | int color = p[1]; 9 | playerColorCount[player][color]++; 10 | } 11 | 12 | int winningPlayers = 0; 13 | 14 | for (int i = 0; i < n; ++i) { 15 | for (auto entry : playerColorCount[i]) { 16 | if (entry.second > i) { 17 | winningPlayers++; 18 | break; 19 | } 20 | } 21 | } 22 | 23 | return winningPlayers; 24 | } 25 | }; -------------------------------------------------------------------------------- /3600-find-the-k-th-character-in-string-game-i/3600-find-the-k-th-character-in-string-game-i.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | char kthCharacter(int k) { 4 | string s = "a"; 5 | while(s.size() < k) 6 | { 7 | string temp = ""; 8 | for(char c : s) 9 | { 10 | temp += ++c; 11 | } 12 | s = s+ temp; 13 | } 14 | return s[k-1]; 15 | } 16 | }; -------------------------------------------------------------------------------- /Arrays/3Sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | vector> threeSum(vector& nums) { 7 | int n = nums.size(); 8 | vector> ans; 9 | sort(nums.begin(), nums.end()); 10 | for(int i = 0; i < n - 2; ++i) { 11 | if (i > 0 && nums[i] == nums[i - 1]) continue; 12 | int j = i + 1; 13 | int k = n - 1; 14 | while(j < k) { 15 | int sum = nums[i] + nums[j] + nums[k]; 16 | if (sum == 0) { 17 | ans.push_back({nums[i], nums[j], nums[k]}); 18 | while (j < k && nums[j] == nums[j + 1]) ++j; 19 | while (j < k && nums[k] == nums[k - 1]) --k; 20 | ++j; 21 | --k; 22 | } else if (sum < 0) { 23 | ++j; 24 | } else { 25 | --k; 26 | } 27 | } 28 | } 29 | return ans; 30 | } 31 | }; 32 | 33 | int main(){ 34 | 35 | return 0; 36 | } -------------------------------------------------------------------------------- /Arrays/BuyAndSellStocks.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | class Solution { 6 | public: 7 | int maxProfit(vector& prices) { 8 | int min_price =INT_MAX; 9 | int max_profit = 0; 10 | for(int i=0;i 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int maxProfit(vector& prices) { 7 | int maxProfit = 0; 8 | for (int i = 1; i < prices.size(); i++) { 9 | if (prices[i] > prices[i - 1]) { 10 | maxProfit += prices[i] - prices[i - 1]; 11 | } 12 | } 13 | return maxProfit; 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /Arrays/ChocolateDistribution.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // sorting method 5 | class Solution{ 6 | public: 7 | long long findMinDiff(vector a, long long n, long long m){ 8 | sort(a.begin(),a.end()); 9 | long long mini = INT_MAX; 10 | for(int i=0;i+m-1>t; 22 | while(t--) 23 | { 24 | long long n; 25 | cin>>n; 26 | vector a; 27 | long long x; 28 | for(long long i=0;i>x; 31 | a.push_back(x); 32 | } 33 | 34 | long long m; 35 | cin>>m; 36 | Solution ob; 37 | cout< 2 | using namespace std; 3 | 4 | // https://leetcode.com/problems/find-the-duplicate-number/ 5 | 6 | // using sort method 7 | // O(n) 8 | class Solution { 9 | public: 10 | int findDuplicate(vector& nums) { 11 | sort(nums.begin(),nums.end()); 12 | int n = nums.size(); 13 | for(int i=0;i there is a cycle 23 | class Solution { 24 | public: 25 | int findDuplicate(vector& nums) { 26 | int n = nums.size(); 27 | int slow = nums[0]; 28 | int fast = nums[0]; 29 | slow = nums[slow]; 30 | fast = nums[nums[fast]]; 31 | while(slow != fast) 32 | { 33 | slow = nums[slow]; 34 | fast = nums[nums[fast]]; 35 | } 36 | slow=nums[0]; 37 | while(slow != fast) 38 | { 39 | slow = nums[slow]; 40 | fast = nums[fast]; 41 | } 42 | return slow; 43 | } 44 | }; -------------------------------------------------------------------------------- /Arrays/MajorityElement.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | //1) using maps -> return max frequency element 5 | //2) using sorting 6 | class Solution { 7 | public: 8 | int majorityElement(vector& nums) { 9 | int n=nums.size(); 10 | sort(nums.begin(),nums.end()); 11 | return nums[n/2]; 12 | } 13 | }; -------------------------------------------------------------------------------- /Arrays/MergeSortedArray.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | //1) using extra space (Array) 5 | 6 | //2) using two pointers 7 | class Solution { 8 | public: 9 | void merge(vector& nums1, int m, vector& nums2, int n) { 10 | int i = m - 1, j = n - 1, k = (m + n - 1); 11 | while (i>=0 && j>=0) 12 | { 13 | if (nums1[i] >= nums2[j]) 14 | { 15 | nums1[k--] = nums1[i--]; 16 | } 17 | else 18 | { 19 | nums1[k--] = nums2[j--]; 20 | } 21 | } 22 | while (i>=0) 23 | { 24 | nums1[k--] = nums1[i--]; 25 | } 26 | while (j>=0) 27 | { 28 | nums1[k--] = nums2[j--]; 29 | } 30 | } 31 | }; -------------------------------------------------------------------------------- /Arrays/MoveZeros.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | //1) using extra space 5 | 6 | //2) using 2 pointers 7 | class Solution { 8 | public: 9 | void moveZeroes(vector& nums) { 10 | int n = nums.size(); 11 | int k=0; 12 | for(int i=0;i 2 | using namespace std; 3 | 4 | // using two pointers 5 | class Solution { 6 | public: 7 | int removeDuplicates(vector& nums) { 8 | int i=0; 9 | int j=0; 10 | while(j 2 | using namespace std; 3 | 4 | // Brute Force 5 | class Solution { 6 | public: 7 | int subarraySum(vector& nums, int k) { 8 | int n = nums.size(); 9 | int count=0; 10 | for(int i=0;i& nums, int k) { 26 | unordered_map mp; 27 | mp[0] = 1; 28 | int Sum = 0, count =0; 29 | for(int i=0; i< nums.size();i++) 30 | { 31 | Sum += nums[i]; 32 | int remove = Sum -k; 33 | count += mp[remove]; 34 | mp[Sum] +=1; 35 | } 36 | return count; 37 | } 38 | }; -------------------------------------------------------------------------------- /Arrays/SlidingWindow/subArraySumDivsibleByK.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int subarraysDivByK(vector& nums, int k) { 7 | unordered_map mp; 8 | mp[0] = 1; 9 | int sum = 0, ans=0; 10 | for(int i=0;i 2 | using namespace std; 3 | 4 | // brute force 5 | class Solution { 6 | public: 7 | vector twoSum(vector& nums, int target) { 8 | int n = nums.size(); 9 | for(int i=0;i twoSum(vector& nums, int target) { 25 | int n = nums.size(); 26 | unordered_map mp; 27 | for(int i=0;i 2 | using namespace std; 3 | 4 | bool sortArr(int a[], int n) 5 | { 6 | int x = -1; 7 | int y = -1; 8 | 9 | for (int i = 0; i < n - 1; i++) { 10 | if (a[i] > a[i + 1]) { 11 | if (x == -1) { 12 | x = i; 13 | } 14 | y = i + 1; 15 | } 16 | } 17 | 18 | if (x != -1) { 19 | reverse(a + x, a + y + 1); 20 | for (int i = 0; i < n - 1; i++) { 21 | if (a[i] > a[i + 1]) { 22 | return false; 23 | return 0; 24 | } 25 | } 26 | } 27 | 28 | return true; 29 | } 30 | 31 | int main() 32 | { 33 | int arr[] = { 1, 2, 5, 4, 3 }; 34 | int n = sizeof(arr) / sizeof(arr[0]); 35 | 36 | sortArr(arr, n) ? (cout << "Yes" << endl) 37 | : (cout << "No" << endl); 38 | return 0; 39 | } 40 | 41 | -------------------------------------------------------------------------------- /Arrays/containerWithMostWater.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int maxArea(vector& height) { 7 | int n = height.size(); 8 | int i=0; 9 | int j=n-1; 10 | int maxi = 0; 11 | while(i 2 | using namespace std; 3 | 4 | //1) sort the array and then check for duplicates 5 | //2) use maps to store the frequency 6 | 7 | class Solution { 8 | public: 9 | vector findDuplicates(vector& nums) { 10 | unordered_map mp; 11 | vector ans; 12 | for(int i=0;i 2 | using namespace std; 3 | 4 | 5 | class Solution { 6 | public: 7 | int findPair(int n, int x, vector &arr) { 8 | sort(arr.begin(), arr.end()); 9 | 10 | int i = 0; 11 | int j = 1; 12 | 13 | while (i < n && j < n) { 14 | int diff = arr[j] - arr[i]; 15 | if (i != j && diff == x) { 16 | return 1; 17 | } else if (diff < x) { 18 | j++; 19 | } else { 20 | i++; 21 | } 22 | } 23 | 24 | return -1; 25 | } 26 | }; -------------------------------------------------------------------------------- /Arrays/largestSubarrayWithZeroSum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int maxLen(vector& arr, int n) { 7 | unordered_map mp; // sum, index 8 | int sum =0; 9 | int ans =0; 10 | mp[0] = -1; 11 | for(int i=0;i 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int maxScore(vector& nums, int k) { 7 | int n = nums.size(); 8 | int lsum =0; 9 | int rsum =0; 10 | for(int i=0;i=0;i--) 17 | { 18 | lsum -= nums[i]; 19 | rsum += nums[r]; 20 | r--; 21 | maxSum = max(maxSum,lsum+rsum); 22 | } 23 | return maxSum; 24 | } 25 | }; -------------------------------------------------------------------------------- /Arrays/removeKdigits.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | string removeKdigits(string num, int k) { 7 | int n = num.length(); 8 | string result = ""; 9 | for(int i=0;i0 && result.back()>num[i] && k>0) 12 | { 13 | result.pop_back(); 14 | k--; 15 | } 16 | if(result.length()>0 || num[i] != '0') 17 | result.push_back(num[i]); 18 | } 19 | while(k>0 && !result.empty()){ 20 | result.pop_back(); 21 | k--; 22 | } 23 | return result == "" ? "0": result; 24 | } 25 | }; -------------------------------------------------------------------------------- /Arrays/sortColors.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | //1) using extra space --> map 5 | //2) using sorting 6 | //3) using 3 pointers 7 | class Solution { 8 | public: 9 | void sortColors(vector& nums) { 10 | int n = nums.size(); 11 | int i=0; 12 | int k=0; 13 | int j=n-1; 14 | while(k<=j){ 15 | if(nums[k]==2) 16 | { 17 | swap(nums[k],nums[j]); 18 | j--; 19 | } 20 | else if(nums[k]==0) 21 | { 22 | swap(nums[k],nums[i]); 23 | k++; 24 | i++; 25 | }else k++; 26 | } 27 | } 28 | }; -------------------------------------------------------------------------------- /DP/climbingStairs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int dp[46] = {0}; 7 | int climbStairs(int n) { 8 | if(n <=1) return 1; 9 | if(dp[n]) return dp[n]; 10 | int oneStep = climbStairs(n-1); 11 | int twoStep = climbStairs(n-2); 12 | 13 | return dp[n] = oneStep+twoStep; 14 | } 15 | }; -------------------------------------------------------------------------------- /DP/longestCommonSubstring.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int dp[1001][1001]; 7 | 8 | int solve(string& s1, string& s2, int i, int j) { 9 | if (i >= s1.size() || j >= s2.size()) return 0; 10 | if (dp[i][j] != -1) return dp[i][j]; 11 | if (s1[i] == s2[j]) { 12 | dp[i][j] = 1 + solve(s1, s2, i + 1, j + 1); 13 | } else { 14 | dp[i][j] = 0; 15 | } 16 | return dp[i][j]; 17 | } 18 | 19 | int longestCommonSubstr(string s1, string s2) { 20 | memset(dp, -1, sizeof(dp)); 21 | int maxLength = 0; 22 | for (int i = 0; i < s1.size(); ++i) { 23 | for (int j = 0; j < s2.size(); ++j) { 24 | maxLength = max(maxLength, solve(s1, s2, i, j)); 25 | } 26 | } 27 | return maxLength; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /Graphs/BipartiteGraph.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // using 2 colors --> 0,1 5 | class Solution { 6 | public: 7 | vector visited; 8 | bool Bipartite = true; 9 | void dfs(int u,vectoradj[], int color) 10 | { 11 | if(visited[u] != -1) return; 12 | visited[u] = color; 13 | for(int v : adj[u]) 14 | { 15 | if(visited[v] == -1) dfs(v,adj,1-color); 16 | else if(visited[v] == color) 17 | { 18 | Bipartite = false; 19 | return; 20 | } 21 | } 22 | 23 | } 24 | bool isBipartite(int V, vectoradj[]){ 25 | int n = V; 26 | visited.resize(n, -1); 27 | 28 | for (int i = 0; i < n; i++) { 29 | if (visited[i] == -1) { 30 | dfs(i, adj, 1); 31 | } 32 | } 33 | 34 | return Bipartite; 35 | } 36 | 37 | }; 38 | -------------------------------------------------------------------------------- /Graphs/bfs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | // Function to return Breadth First Traversal of given graph. 7 | vector bfsOfGraph(int V, vector adj[]) { 8 | queue q; 9 | vector vis(V,false); 10 | vector ans; 11 | q.push(0); 12 | vis[0] = true; 13 | while(!q.empty()) 14 | { 15 | int node = q.front(); 16 | ans.push_back(node); 17 | q.pop(); 18 | for(int n : adj[node]) 19 | { 20 | if(!vis[n]) 21 | { 22 | q.push(n); 23 | vis[n] = true; 24 | } 25 | } 26 | } 27 | return ans; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /Graphs/dfs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | class Solution { 6 | public: 7 | vector vis; 8 | void solve(int V, vector adj[], vector &ans, int u) 9 | { 10 | if(vis[u]) return; 11 | vis[u]=true; 12 | ans.push_back(u); 13 | for(auto v : adj[u]) 14 | { 15 | if(!vis[v]) 16 | { 17 | solve(V,adj,ans,v); 18 | } 19 | } 20 | } 21 | vector dfsOfGraph(int V, vector adj[]) { 22 | vector ans; 23 | vis.resize(V, false); 24 | solve(V, adj, ans,0); 25 | return ans; 26 | } 27 | }; -------------------------------------------------------------------------------- /Graphs/floodFill.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | void dfs(int sr,int sc, vector>& image, int color, int iniColor,int n,int m) { 7 | if (sr < 0 || sc < 0 || sr >= n || sc >= m || image[sr][sc] != iniColor) { 8 | return; 9 | } 10 | 11 | image[sr][sc] = color; 12 | 13 | dfs (sr+ 1, sc, image, color, iniColor, n, m); // Down 14 | dfs(sr - 1, sc, image, color, iniColor, n, m); // Up 15 | dfs(sr, sc + 1, image, color, iniColor, n, m); // Right 16 | dfs(sr, sc - 1, image, color, iniColor, n, m); // Left 17 | } 18 | vector> floodFill(vector>& image, int sr, int sc, int color) { 19 | vector> temp = image; 20 | int iniColor= image[sr][sc]; 21 | int n = image.size(); 22 | int m = image[0].size(); 23 | if(iniColor == color) return image; 24 | dfs(sr,sc,temp,color,iniColor,n,m); 25 | return temp; 26 | } 27 | }; -------------------------------------------------------------------------------- /Graphs/numberOfIslands.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int n,m; 7 | vector> visited; 8 | void dfs(vector>& grid,int i,int j) 9 | { 10 | if(i<0 || j<0 || i>=n || j>=m || grid[i][j]=='0' || visited[i][j]) return; 11 | 12 | visited[i][j] = true; 13 | 14 | dfs(grid,i+1,j); 15 | dfs(grid,i-1,j); 16 | dfs(grid,i,j+1); 17 | dfs(grid,i,j-1); 18 | } 19 | int numIslands(vector>& grid) { 20 | n = grid.size(); 21 | m = grid[0].size(); 22 | visited.resize(n,vector(m,false)); 23 | int count =0; 24 | for(int i=0;i 2 | using namespace std; 3 | 4 | // Converts coin[] to prefix sum array 5 | void preprocess(int coin[], int n) 6 | { 7 | // sort the coins value 8 | sort(coin, coin + n); 9 | 10 | // Maintain prefix sum array 11 | for (int i = 1; i <= n - 1; i++) 12 | coin[i] += coin[i - 1]; 13 | } 14 | 15 | // Function to calculate min 16 | // cost when we can get k extra 17 | // coins after paying cost of one. 18 | int minCost(int coin[], int n, int k) 19 | { 20 | // calculate no. of coins needed 21 | int coins_needed = ceil(1.0 * n / (k + 1)); 22 | 23 | // return sum of from prefix array 24 | return coin[coins_needed - 1]; 25 | } 26 | 27 | int main() 28 | { 29 | int coin[] = {8, 5, 3, 10, 30 | 2, 1, 15, 25}; 31 | int n = sizeof(coin) / sizeof(coin[0]); 32 | preprocess(coin, n); 33 | int k = 3; 34 | cout << minCost(coin, n, k) << endl; 35 | k = 7; 36 | cout << minCost(coin, n, k) << endl; 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /Greedy/minCostAquiringCoins.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int minCost(int coin[], int n, int k) 5 | { 6 | sort(coin, coin + n); 7 | 8 | int coins_needed = ceil(1.0 * n / 9 | (k + 1)); 10 | 11 | int ans = 0; 12 | for (int i = 0; i <= coins_needed - 1; 13 | i++) 14 | ans += coin[i]; 15 | 16 | return ans; 17 | } 18 | -------------------------------------------------------------------------------- /LinkedList/BinaryToInteger.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode() : val(0), next(nullptr) {} 8 | ListNode(int x) : val(x), next(nullptr) {} 9 | ListNode(int x, ListNode *next) : val(x), next(next) {} 10 | }; 11 | // 1) store in array and then find decimal 12 | // 2) reverse the ll and then find decimal 13 | 14 | class Solution { 15 | public: 16 | int getDecimalValue(ListNode* head) { 17 | int result = 0; 18 | ListNode* temp = head; 19 | while(temp!= NULL) 20 | { 21 | result *= 2; 22 | result += temp -> val; 23 | temp = temp -> next; 24 | 25 | }return result; 26 | } 27 | }; -------------------------------------------------------------------------------- /LinkedList/CopyListWithRandomPtrs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct Node 5 | { 6 | int val; 7 | Node* next; 8 | Node* random; 9 | 10 | Node(int x){ 11 | val = x; 12 | next = NULL; 13 | } 14 | }; 15 | 16 | // Approach 1 --> using map 17 | class Solution { 18 | public: 19 | Node* copyRandomList(Node* head) { 20 | unordered_map mp; 21 | Node* newHead = new Node(-1); 22 | Node* curr1 = head; 23 | Node* prev = newHead; 24 | // traverse for data and next ptr 25 | while(curr1!= NULL) 26 | { 27 | Node* newNode = new Node(curr1->val); 28 | prev->next = newNode; 29 | prev = prev->next; 30 | mp[curr1] = newNode; 31 | curr1 = curr1->next; 32 | } 33 | Node* curr = head; 34 | Node* Head = newHead->next; 35 | while(curr != NULL) 36 | { 37 | Head->random = mp[curr->random]; 38 | curr = curr->next; 39 | Head = Head->next; 40 | } 41 | return newHead->next; 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /LinkedList/LinkedListCycle.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode() : val(0), next(nullptr) {} 8 | ListNode(int x) : val(x), next(nullptr) {} 9 | ListNode(int x, ListNode *next) : val(x), next(next) {} 10 | }; 11 | 12 | // using slow, fast pointers (hare and tortoise) 13 | class Solution { 14 | public: 15 | bool hasCycle(ListNode *head) { 16 | ListNode *fast = head; 17 | ListNode *slow = head; 18 | while(fast != NULL && fast->next != NULL) 19 | { 20 | slow = slow->next; 21 | fast = fast->next->next; 22 | if(fast == slow) 23 | { 24 | return true; // cycle is present 25 | } 26 | } 27 | return false; 28 | } 29 | }; -------------------------------------------------------------------------------- /LinkedList/MiddleOfLL.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode() : val(0), next(nullptr) {} 8 | ListNode(int x) : val(x), next(nullptr) {} 9 | ListNode(int x, ListNode *next) : val(x), next(next) {} 10 | }; 11 | 12 | //1) find the length of LL and then find the middle 13 | //2) using slow-fast pointers 14 | 15 | class Solution { 16 | public: 17 | ListNode* middleNode(ListNode* head) { 18 | ListNode *slow=head, *fast=head; 19 | while(fast != NULL && fast -> next != NULL) 20 | { 21 | slow = slow -> next; 22 | fast = fast -> next -> next; 23 | } 24 | return slow; 25 | } 26 | }; -------------------------------------------------------------------------------- /LinkedList/PalindromeLL.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode() : val(0), next(nullptr) {} 8 | ListNode(int x) : val(x), next(nullptr) {} 9 | ListNode(int x, ListNode *next) : val(x), next(next) {} 10 | }; 11 | 12 | class Solution { 13 | public: 14 | bool isPalindrome(int i, int j, vector &arr) 15 | { 16 | if(i>j) return true; 17 | if(arr[i]==arr[j]) return isPalindrome(i+1,j-1,arr); 18 | return false; 19 | } 20 | bool isPalindrome(ListNode* head) { 21 | vector arr; 22 | ListNode* curr = head; 23 | while(curr != NULL) 24 | { 25 | arr.push_back(curr->val); 26 | curr = curr->next; 27 | } 28 | return isPalindrome(0,arr.size()-1,arr); 29 | } 30 | }; -------------------------------------------------------------------------------- /LinkedList/RemoveDuplicatesFromSortedLL.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode() : val(0), next(nullptr) {} 8 | ListNode(int x) : val(x), next(nullptr) {} 9 | ListNode(int x, ListNode *next) : val(x), next(next) {} 10 | }; 11 | 12 | class Solution { 13 | public: 14 | ListNode* deleteDuplicates(ListNode* head) { 15 | if(head == NULL || head->next == NULL) return head; 16 | ListNode* prev = head; 17 | ListNode* curr = head->next; 18 | while(curr != NULL) 19 | { 20 | if (curr->val == prev->val) { 21 | prev->next = curr->next; 22 | } else { 23 | prev = prev->next; 24 | } 25 | curr = prev->next; 26 | } 27 | return head; 28 | } 29 | }; -------------------------------------------------------------------------------- /LinkedList/addNumbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | /** 5 | * Definition for singly-linked list. 6 | * struct ListNode { 7 | * int val; 8 | * ListNode *next; 9 | * ListNode() : val(0), next(nullptr) {} 10 | * ListNode(int x) : val(x), next(nullptr) {} 11 | * ListNode(int x, ListNode *next) : val(x), next(next) {} 12 | * }; 13 | */ 14 | class Solution { 15 | public: 16 | ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { 17 | ListNode* dummy = new ListNode(0); 18 | ListNode* curr = dummy; 19 | int carry = 0; 20 | 21 | while (l1 != NULL || l2 != NULL || carry != 0) { 22 | int sum = carry; 23 | if (l1 != NULL) { 24 | sum += l1->val; 25 | l1 = l1->next; 26 | } 27 | if (l2 != NULL) { 28 | sum += l2->val; 29 | l2 = l2->next; 30 | } 31 | carry = sum / 10; 32 | sum = sum % 10; 33 | 34 | curr->next = new ListNode(sum); 35 | curr = curr->next; 36 | } 37 | return dummy->next; 38 | } 39 | }; -------------------------------------------------------------------------------- /LinkedList/intersectionOf2LL.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode() : val(0), next(nullptr) {} 8 | ListNode(int x) : val(x), next(nullptr) {} 9 | ListNode(int x, ListNode *next) : val(x), next(next) {} 10 | }; 11 | class Solution { 12 | public: 13 | int Length(ListNode* head) 14 | { 15 | int count = 1; 16 | while(head != NULL) 17 | { 18 | count++; 19 | head = head->next; 20 | } 21 | return count; 22 | } 23 | ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { 24 | int len1 = Length(headA); 25 | int len2 = Length(headB); 26 | 27 | while(len1>len2) 28 | { 29 | len1--; 30 | headA=headA->next; 31 | } 32 | while(len2>len1) 33 | { 34 | len2--; 35 | headB=headB->next; 36 | } 37 | 38 | while(headA != headB) 39 | { 40 | headA=headA->next; 41 | headB=headB->next; 42 | } 43 | return headA; 44 | } 45 | }; -------------------------------------------------------------------------------- /LinkedList/removeLLelements.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode() : val(0), next(nullptr) {} 8 | ListNode(int x) : val(x), next(nullptr) {} 9 | ListNode(int x, ListNode *next) : val(x), next(next) {} 10 | }; 11 | 12 | class Solution { 13 | public: 14 | ListNode* removeElements(ListNode* head, int val) { 15 | ListNode* dummy = new ListNode(-1); 16 | dummy->next = head; 17 | ListNode* curr = dummy; 18 | while(curr->next != NULL) 19 | { 20 | if(curr->next->val == val) 21 | { 22 | curr->next = curr->next->next; 23 | }else{ 24 | curr = curr->next; 25 | } 26 | } 27 | return dummy->next; 28 | } 29 | }; -------------------------------------------------------------------------------- /LinkedList/reverseLL.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct ListNode { 5 | int val; 6 | ListNode *next; 7 | ListNode() : val(0), next(nullptr) {} 8 | ListNode(int x) : val(x), next(nullptr) {} 9 | ListNode(int x, ListNode *next) : val(x), next(next) {} 10 | }; 11 | 12 | // using previous node; 13 | class Solution { 14 | public: 15 | ListNode* reverseList(ListNode* head) { 16 | ListNode* curr = head; 17 | ListNode* prev = NULL; 18 | while(curr!= NULL) 19 | { 20 | ListNode* next = curr->next; 21 | curr->next=prev; 22 | prev=curr; 23 | curr=next; 24 | } 25 | return prev; 26 | } 27 | }; -------------------------------------------------------------------------------- /LinkedList/reverseLL2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | /** 5 | * Definition for singly-linked list. 6 | * struct ListNode { 7 | * int val; 8 | * ListNode *next; 9 | * ListNode() : val(0), next(nullptr) {} 10 | * ListNode(int x) : val(x), next(nullptr) {} 11 | * ListNode(int x, ListNode *next) : val(x), next(next) {} 12 | * }; 13 | */ 14 | class Solution { 15 | public: 16 | ListNode* reverseBetween(ListNode* head, int left, int right) { 17 | if(head == NULL || head->next == NULL || left>right) return head; 18 | ListNode* dummy = new ListNode(-1); 19 | dummy->next = head; 20 | ListNode* prev = dummy; 21 | for(int i=1;inext; 24 | } 25 | 26 | ListNode* curr = prev->next; 27 | for(int i=0;inext; 30 | prev->next = curr->next; 31 | curr->next = curr->next->next; 32 | prev->next->next = temp; 33 | } 34 | return dummy->next; 35 | } 36 | }; -------------------------------------------------------------------------------- /LinkedList/sortList.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | /** 5 | * Definition for singly-linked list. 6 | * struct ListNode { 7 | * int val; 8 | * ListNode *next; 9 | * ListNode() : val(0), next(nullptr) {} 10 | * ListNode(int x) : val(x), next(nullptr) {} 11 | * ListNode(int x, ListNode *next) : val(x), next(next) {} 12 | * }; 13 | */ 14 | class Solution { 15 | public: 16 | ListNode* sortList(ListNode* head) { 17 | vector v; 18 | ListNode* curr = head; 19 | while(curr) 20 | { 21 | v.push_back(curr->val); 22 | curr = curr->next; 23 | } 24 | sort(v.begin(),v.end()); 25 | curr = head; 26 | for(int i=0;ival = v[i]; 29 | curr = curr->next; 30 | } 31 | return head; 32 | } 33 | }; -------------------------------------------------------------------------------- /LinkedList/tempCodeRunnerFile.cpp: -------------------------------------------------------------------------------- 1 | ListNode* curr = head; 2 | ListNode* prev = NULL; 3 | while(curr!= NULL) 4 | { 5 | ListNode* next = curr->next; 6 | curr->next=prev; 7 | prev=curr; 8 | curr=next; 9 | } 10 | return prev; -------------------------------------------------------------------------------- /Mathamatical/ExcelSheetColTitle.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | //log(colNum) base 26 6 | class Solution { 7 | public: 8 | string convertToTitle(int columnNumber) { 9 | int colNum=columnNumber; 10 | string ans=""; 11 | while(colNum>0) 12 | { 13 | colNum--; // to handle remainder = 0 14 | int remainder = colNum%26; 15 | ans+= remainder+'A'; 16 | colNum = colNum/26; 17 | } 18 | reverse(ans.begin(),ans.end()); 19 | return ans; 20 | } 21 | }; -------------------------------------------------------------------------------- /Mathamatical/addBinary.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | string addBinary(string a, string b) { 7 | string ans = ""; 8 | int i=0; 9 | char carry=0; 10 | while(i 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | vector countBits(int n) { 7 | vector ans(n+1); 8 | for(int i=0;i<=n;i++) 9 | { 10 | if(i%2==0) ans[i]=ans[i/2]; 11 | else ans[i]=ans[i/2]+1; 12 | } 13 | return ans; 14 | } 15 | }; -------------------------------------------------------------------------------- /Mathamatical/maxProductOf3numbers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // sorting method 5 | // considering -ve numbers 6 | // negative + negative = positive 7 | class Solution { 8 | public: 9 | int maximumProduct(vector& nums) { 10 | int n = nums.size(); 11 | sort(nums.begin(), nums.end()); 12 | return max(nums[n - 1] * nums[n - 2] * nums[n - 3], nums[0] * nums[1] * nums[n - 1]); 13 | } 14 | 15 | }; -------------------------------------------------------------------------------- /Mathamatical/permutationsInArray.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | bool isPossible(long long a[], long long b[], int n, long long k) { 7 | sort(a, a+n); 8 | sort(b, b+n); 9 | for(int i=0;i 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int studentsAllocated(int maxPages, int arr[], int n) 7 | { 8 | int students=1; 9 | int pagesAllocated = 0; 10 | for(int i=0;in) return -1; 22 | int lowest = 0; 23 | int highest = 0; 24 | for(int i=0;i m) lowest = mid+1; 34 | else highest = mid-1; 35 | } 36 | return lowest; 37 | } 38 | }; 39 | -------------------------------------------------------------------------------- /Sorting/minSwapsToSort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution 5 | { 6 | public: 7 | //Function to find the minimum number of swaps required to sort the array. 8 | int minSwaps(vector&nums) 9 | { 10 | int n = nums.size(); 11 | vector> mp; 12 | for(int i=0;i 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | bool backspaceCompare(string s, string t) { 7 | vector st1; 8 | vector st2; 9 | for(int i=0;i 2 | using namespace std; 3 | 4 | int main(){ 5 | 6 | return 0; 7 | } -------------------------------------------------------------------------------- /Stack/stackUsingQueues.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class MyStack { 5 | public: 6 | queue q1; 7 | queue q2; 8 | MyStack() { 9 | 10 | } 11 | 12 | void push(int x) { 13 | while(!q1.empty()) 14 | { 15 | int top = q1.front(); 16 | q2.push(top); 17 | q1.pop(); 18 | } 19 | q1.push(x); 20 | while(!q2.empty()) 21 | { 22 | int top = q2.front(); 23 | q1.push(top); 24 | q2.pop(); 25 | } 26 | } 27 | 28 | int pop() { 29 | int top = q1.front(); 30 | q1.pop(); 31 | return top; 32 | } 33 | 34 | int top() { 35 | return q1.front(); 36 | } 37 | 38 | bool empty() { 39 | return q1.empty(); 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /Strings/IntegerToroman.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | string intToRoman(int num) { 7 | vector> mp = { 8 | {1000, "M"}, {900, "CM"}, {500, "D"}, {400, "CD"}, 9 | {100, "C"}, {90, "XC"}, {50, "L"}, {40, "XL"}, 10 | {10, "X"}, {9, "IX"}, {5, "V"}, {4, "IV"}, {1, "I"} 11 | }; 12 | 13 | string result = ""; 14 | for (auto& value : mp) { 15 | int count = num / value.first; 16 | num %= value.first; 17 | for (int i = 0; i < count; ++i) { 18 | result += value.second; 19 | } 20 | } 21 | return result; 22 | } 23 | }; -------------------------------------------------------------------------------- /Strings/ValidParenthesis.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // using stack 5 | class Solution { 6 | public: 7 | bool isValid(string s) { 8 | stack st; 9 | for(int i=0;i 2 | using namespace std; 3 | 4 | void printDuplicate(string str) 5 | { 6 | unordered_map count; 7 | for (int i = 0; i < str.length(); i++) { 8 | count[str[i]]++; 9 | } 10 | for (auto it : count) { 11 | if (it.second > 1) 12 | cout << it.first << ", count = " << it.second 13 | << "\n"; 14 | } 15 | } -------------------------------------------------------------------------------- /Strings/firstIndexOfFirstOccurence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | int strStr(string haystack, string needle) { 7 | int i,j; 8 | int len1=haystack.size(), len2=needle.size(); 9 | for (i = 0; i <= len1-len2; i++) { 10 | for (j = 0; j 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | vector> groupAnagrams(vector& strs) { 7 | unordered_map> anagramGroups; 8 | 9 | for (string& str : strs) { 10 | string sortedStr = str; 11 | sort(sortedStr.begin(), sortedStr.end()); 12 | anagramGroups[sortedStr].push_back(str); 13 | } 14 | 15 | vector> result; 16 | for (auto& group : anagramGroups) { 17 | result.push_back(group.second); 18 | } 19 | 20 | return result; 21 | } 22 | }; -------------------------------------------------------------------------------- /Strings/longestCommonPrefix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // using Sorting Method 5 | class Solution { 6 | public: 7 | string longestCommonPrefix(vector& strs) { 8 | int n = strs.size(); 9 | sort(strs.begin(), strs.end()); 10 | string str1 = strs[0]; 11 | string str2 = strs[n-1]; 12 | string answer = ""; 13 | int i=0; 14 | while(i 2 | using namespace std; 3 | 4 | // 1) using stringStream 5 | // 1) using 2 pointer 6 | 7 | class Solution { 8 | public: 9 | string reverseWords(string s) { 10 | reverse(s.begin(),s.end()); 11 | int i=0; 12 | int n = s.length(); 13 | int l=0,r=0; 14 | while(i 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | string simplifyPath(string path) { 7 | string result = ""; 8 | stack st; 9 | stringstream ss(path); 10 | string token; 11 | while(getline(ss,token,'/')) 12 | { 13 | if(token == "" || token == ".") continue; 14 | if(token != "..") 15 | { 16 | st.push(token); 17 | }else if(!st.empty()) st.pop(); 18 | } 19 | if(st.empty()) return "/"; 20 | 21 | while(!st.empty()) 22 | { 23 | result = '/'+st.top()+result; 24 | st.pop(); 25 | } 26 | return result; 27 | } 28 | }; -------------------------------------------------------------------------------- /Strings/validPalindrome.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // Brute Force --> try removing every character and see if remaining string is palindrome 5 | 6 | class Solution { 7 | public: 8 | bool isPalindrome(const string& s, int left, int right) { 9 | while (left < right) { 10 | if (s[left] != s[right]) { 11 | return false; 12 | } 13 | left++; 14 | right--; 15 | } 16 | return true; 17 | } 18 | 19 | bool validPalindrome(string s) { 20 | int left = 0; 21 | int right = s.size() - 1; 22 | 23 | while (left < right) { 24 | if (s[left] != s[right]) { 25 | return isPalindrome(s, left + 1, right) || isPalindrome(s, left, right - 1); 26 | } 27 | left++; 28 | right--; 29 | } 30 | return true; 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /Trees/InvertBT.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct TreeNode { 5 | int val; 6 | TreeNode *left; 7 | TreeNode *right; 8 | TreeNode() : val(0), left(nullptr), right(nullptr) {} 9 | TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 10 | TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 11 | }; 12 | 13 | class Solution { 14 | public: 15 | TreeNode* invertTree(TreeNode* root) { 16 | if(!root) return root; 17 | 18 | invertTree(root->left); 19 | TreeNode* left = root->left; 20 | root->left = root->right; 21 | root->right = left; 22 | invertTree(root->left); 23 | return root; 24 | } 25 | }; -------------------------------------------------------------------------------- /Trees/SameTree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct TreeNode { 5 | int val; 6 | TreeNode *left; 7 | TreeNode *right; 8 | TreeNode() : val(0), left(nullptr), right(nullptr) {} 9 | TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 10 | TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 11 | }; 12 | 13 | class Solution { 14 | public: 15 | bool isSameTree(TreeNode* p, TreeNode* q) { 16 | if(p == NULL && q == NULL) return true; 17 | if(p == NULL && q != NULL) return false; 18 | if(p != NULL && q == NULL) return false; 19 | bool left = isSameTree(p->left,q->left); 20 | bool right = isSameTree(p->right,q->right); 21 | bool isValSame = p->val == q->val ? true : false; 22 | return left && right && isValSame; 23 | } 24 | }; -------------------------------------------------------------------------------- /Trees/countNodesInRange.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution{ 5 | public: 6 | int getCount(Node *root, int l, int h) 7 | { 8 | if(!root) return 0; 9 | 10 | int left = getCount(root->left,l,h); 11 | int right = getCount(root->right,l,h); 12 | if(root->data >= l && root->data <= h) 13 | { 14 | return 1 + left + right; 15 | } 16 | return left + right; 17 | } 18 | }; -------------------------------------------------------------------------------- /Trees/diameterOfBT.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct TreeNode { 5 | int val; 6 | TreeNode *left; 7 | TreeNode *right; 8 | TreeNode() : val(0), left(nullptr), right(nullptr) {} 9 | TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 10 | TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 11 | }; 12 | 13 | class Solution { 14 | public: 15 | 16 | int solve(TreeNode* root,int &result) 17 | { 18 | if(!root) return 0; 19 | 20 | int left = solve(root->left,result); 21 | int right = solve(root->right,result); 22 | result = max(result,left+right); 23 | return max(left,right)+1; 24 | } 25 | int diameterOfBinaryTree(TreeNode* root) { 26 | int diameter=0; 27 | solve(root,diameter); 28 | return diameter; 29 | } 30 | }; -------------------------------------------------------------------------------- /Trees/medianOfBST.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void dfs(struct Node *root,vector &inorder) 5 | { 6 | if(!root) return; 7 | 8 | dfs(root->left,inorder); 9 | inorder.push_back(root->data); 10 | dfs(root->right,inorder); 11 | } 12 | float findMedian(struct Node *root) 13 | { 14 | vector inorder; 15 | dfs(root,inorder); 16 | int n = inorder.size(); 17 | if (n == 0) return 0.0; 18 | float mid = 0.0; 19 | if (n % 2 == 0) 20 | { 21 | 22 | return (inorder[n / 2 - 1] + inorder[n / 2]) / 2.0; 23 | } 24 | else 25 | { 26 | return inorder[n / 2]; 27 | } 28 | return mid; 29 | } 30 | -------------------------------------------------------------------------------- /backtracking/Subsets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | vector> ans; 7 | void solve(vector& nums, int i, vector &temp) 8 | { 9 | if(i == nums.size()) 10 | { 11 | ans.push_back(temp); 12 | return; 13 | } 14 | temp.push_back(nums[i]); 15 | solve(nums,i+1,temp); 16 | temp.pop_back(); 17 | solve(nums,i+1,temp); 18 | } 19 | vector> subsets(vector& nums) { 20 | vector temp; 21 | solve(nums,0,temp); 22 | return ans; 23 | } 24 | }; -------------------------------------------------------------------------------- /queue/queueUsingStacks.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class MyQueue { 5 | public: 6 | stack s1; 7 | stack s2; 8 | MyQueue() { 9 | 10 | } 11 | 12 | void push(int x) { 13 | s1.push(x); 14 | } 15 | 16 | int pop() { 17 | while(!s1.empty()) 18 | { 19 | int elem = s1.top(); 20 | s1.pop(); 21 | s2.push(elem); 22 | }; 23 | int elem = s2.top(); 24 | s2.pop(); 25 | while(!s2.empty()) 26 | { 27 | int elem = s2.top(); 28 | s2.pop(); 29 | s1.push(elem); 30 | }; 31 | return elem; 32 | } 33 | 34 | int peek() { 35 | while(!s1.empty()) 36 | { 37 | int elem = s1.top(); 38 | s1.pop(); 39 | s2.push(elem); 40 | }; 41 | int elem = s2.top(); 42 | while(!s2.empty()) 43 | { 44 | int elem = s2.top(); 45 | s2.pop(); 46 | s1.push(elem); 47 | }; 48 | return elem; 49 | } 50 | 51 | bool empty() { 52 | return s1.empty(); 53 | } 54 | }; 55 | --------------------------------------------------------------------------------