├── .gitignore ├── .gitmodules ├── LICENSE ├── README.md ├── README.org ├── hr ├── .gitignore ├── hr.clj └── project.clj ├── lc ├── 0001.two-sum.cpp ├── 0001.two-sum.cs ├── 0003.longest-substring-without-repeating-characters.cpp ├── 0009.palindrome-number.cs ├── 0011_container-with-most-water.go ├── 0013.roman-to-integer.cpp ├── 0014.longest-common-prefix.cpp ├── 0015_3sum.go ├── 0017.letter-combinations-of-a-phone-number.cpp ├── 0019.remove-nth-node-from-end-of-list.cpp ├── 0020.valid-parentheses.cpp ├── 0021.merge-two-sorted-lists.cpp ├── 0022.generate-parentheses.cpp ├── 0023.merge-k-sorted-lists.cpp ├── 0023_merge-k-sorted-lists.cpp ├── 0024.swap-nodes-in-pairs.cpp ├── 0028.find-the-index-of-the-first-occurrence-in-a-string.cpp ├── 0028.merge-sorted-array.cpp ├── 0034.find-first-and-last-position-of-element-in-sorted-array.cpp ├── 0036.valid-sudoku.cpp ├── 0039.combination-sum.cpp ├── 0040.combination-sum-ii.cpp ├── 0040.combination-sum-ii.go ├── 0041.first-missing-positive.cpp ├── 0046.permutations.cpp ├── 0048.rotate-image.cpp ├── 0049.group-anagrams.cpp ├── 0049.group-anagrams.cs ├── 0051.n-queens.cpp ├── 0053.maximum-subarray.cpp ├── 0054.spiral-matrix.cpp ├── 0056.merge-intervals.cpp ├── 0057.insert-interval.cpp ├── 0058.length-of-last-word.go ├── 0059.spiral-matrix-ii.cpp ├── 0062.unique-paths.cpp ├── 0064.minimum-path-sum.cpp ├── 0066.plus-one.cpp ├── 0073.set-matrix-zeroes.cpp ├── 0074.search-a-2d-matrix.cpp ├── 0077.combinations.cpp ├── 0078.subsets.cpp ├── 0079.word-search.cpp ├── 0080.remove-duplicates-from-sorted-array-ii.cpp ├── 0086.partition-list.cpp ├── 0098.validate-binary-search-tree.cpp ├── 0102.binary-tree-level-order-traversal.cpp ├── 0103.binary-tree-zigzag-level-order-traversal.cpp ├── 0104.maximum-depth-of-binary-tree.go ├── 0105.construct-binary-tree-from-preorder-and-inorder-traversal.cpp ├── 0106.construct-binary-tree-from-inorder-and-postorder-traversal.cpp ├── 0107.binary-tree-level-order-traversal-ii.cpp ├── 0108.convert-sorted-array-to-binary-search-tree.go ├── 0112.path-sum.cpp ├── 0113.path-sum-ii.cpp ├── 0116.populating-next-right-pointers-in-each-node.cpp ├── 0121.best-time-to-buy-and-sell-stock.cpp ├── 0124.binary-tree-maximum-path-sum.cpp ├── 0125.valid-palindrome.cpp ├── 0130.surrounded-regions.cpp ├── 0133.clone-graph.go ├── 0136.single-number.cpp ├── 0138.copy-list-with-random-pointer.cpp ├── 0141.linked-list-cycle.cpp ├── 0142.linked-list-cycle-ii.cpp ├── 0143_reorder-list.cpp ├── 0144.flatten-binary-tree-to-linked-list.cpp ├── 0147.insertion-sort-list.cpp ├── 0148.sort-list.go ├── 0149.max-points-on-a-line.cpp ├── 0150.evaluate-reverse-polish-notation.cpp ├── 0151.reverse-words-in-a-string.cs ├── 0153.find-minimum-in-rotated-sorted-array.cpp ├── 0154.find-minimum-in-rotated-sorted-array-ii.cpp ├── 0155.min-stack.cpp ├── 0162.find-peak-element.cpp ├── 0164.maximum-gap.cpp ├── 0166.populating-next-right-pointers-in-each-node.cpp ├── 0169.majority-element.cpp ├── 0172..swapping-nodes-in-a-linked-list.cpp ├── 0173.binary-search-tree-iterator.go ├── 0179.largest-number.go ├── 0189.rotate-array.cpp ├── 0199.binary-tree-right-side-view.cpp ├── 0200.number-of-islands.cpp ├── 0206.reverse-linked-list.go ├── 0209.minimum-size-subarray-sum.cpp ├── 0210.course-schedule-ii.cpp ├── 0210.course-schedule-ii.go ├── 0215.kth-largest-element-in-an-array.cpp ├── 0216.combination-sum-iii.cpp ├── 0217.contains-duplicate.cpp ├── 0217.contains-duplicate.cs ├── 0226.invert-binary-tree.cpp ├── 0228.summary-ranges.cpp ├── 0230.kth-smallest-element-in-a-bst.cpp ├── 0231_power-of-two.go ├── 0234.palindrome-linked-list.cpp ├── 0236.lowest-common-ancestor-of-a-binary-tree.cpp ├── 0237.delete-node-in-a-linked-list.go ├── 0238.product-of-array-except-self.cpp ├── 0239_sliding-window-maximum.cpp ├── 0240.search-a-2d-matrix-ii.cpp ├── 0242.valid-anagram.cpp ├── 0242.valid-anagram.cs ├── 0257.binary-tree-paths.cpp ├── 0268.missing-number.cpp ├── 0274.h-index.cpp ├── 0278.first-bad-version.cpp ├── 0283.move-zeroes.cpp ├── 0287.find-the-duplicate-number.cpp ├── 0290.word-pattern.go ├── 0299.bulls-and-cows.cpp ├── 0315.count-of-smaller-numbers-after-self.cpp ├── 0322.coin-change.cpp ├── 0326.power-of-three.cpp ├── 0327.count-of-range-sum.cpp ├── 0330.patching-array.cpp ├── 0334.increasing-triplet-subsequence.cpp ├── 0347.top-k-frequent-elements.cs ├── 0347.top-k-frequent-elements.go ├── 0349.intersection-of-two-arrays.cs ├── 0350.intersection-of-two-arrays-ii.cpp ├── 0373.find-k-pairs-with-smallest-sums.go ├── 0378.kth-smallest-element-in-a-sorted-matrix.cpp ├── 0387.first-unique-character-in-a-string.cpp ├── 0397.integer-replacement.cpp ├── 0404.sum-of-left-leaves.go ├── 0412.fizz-buzz.go ├── 0419.battleships-in-a-board.cpp ├── 0423.reconstruct-original-digits-from-english.cpp ├── 0424_longest-repeating-character-replacement.go ├── 0429.n-ary-tree-level-order-traversal.cpp ├── 0430.flatten-a-multilevel-doubly-linked-list.cpp ├── 0437.path-sum-iii.cpp ├── 0441.arranging-coins.cpp ├── 0445.add-two-numbers.cs ├── 0448.find-all-numbers-disappeared-in-an-array.cpp ├── 0449.serialize-and-deserialize-bst.cpp ├── 0450.delete-node-in-a-bst.cpp ├── 0463.island-perimeter.cpp ├── 0468.validate-ip-address.cs ├── 0503.next-greater-element-ii.cpp ├── 0509.fibonacci-number.go ├── 0520.detect-capital.go ├── 0542.01-matrix.cpp ├── 0543.diameter-of-binary-tree.cpp ├── 0547.number-of-provinces.cpp ├── 0557.reverse-words-in-a-string-iii.go ├── 0560.subarray-sum-equals-k.cpp ├── 0565.array-nesting.cpp ├── 0567.permutation-in-string.cpp ├── 0605.can-place-flowers.cpp ├── 0617.merge-two-binary-trees.go ├── 0623.add-one-row-to-tree.cpp ├── 0628.maximum-product-of-three-numbers.cpp ├── 0637.average-of-levels-in-binary-tree.cpp ├── 0650.2-keys-keyboard.cpp ├── 0665.non-decreasing-array.cpp ├── 0678.valid-parenthesis-string.cpp ├── 0680.valid-palindrome-ii.cpp ├── 0684.redundant-connection.cpp ├── 0687.longest-univalue-path.cpp ├── 0692.top-k-frequent-words.cpp ├── 0692.top-k-frequent-words.go ├── 0695.max-area-of-island.cpp ├── 0713.subarray-product-less-than-k.cpp ├── 0721.accounts-merge.cpp ├── 0735.asteroid-collision.cpp ├── 0739.daily-temperatures.cpp ├── 0743.network-delay-time.cpp ├── 0763.partition-labels.cpp ├── 0771.jewels-and-stones.go ├── 0781.rabbits-in-forest.cpp ├── 0797.all-paths-from-source-to-target.cpp ├── 0811.subdomain-visit-count.go ├── 0814.binary-tree-pruning.cpp ├── 0826.most-profit-assigning-work.cpp ├── 0834.sum-of-distances-in-tree.cpp ├── 0840.magic-squares-in-grid.cpp ├── 0841.keys-and-rooms.cpp ├── 0845.longest-mountain-in-array.cpp ├── 0848.shifting-letters.cpp ├── 0857.minimum-cost-to-hire-k-workers.cpp ├── 0863.all-nodes-distance-k-in-binary-tree.cpp ├── 0865.smallest-subtree-with-all-the-deepest-nodes.cpp ├── 0901.online-stock-span.cpp ├── 0904.fruit-into-baskets.cpp ├── 0912.sort-an-array.cpp ├── 0912.sort-an-array.go ├── 0915.partition-array-into-disjoint-intervals.java ├── 0918.maximum-sum-circular-subarray.cpp ├── 0930.binary-subarrays-with-sum.cpp ├── 0931.minimum-falling-path-sum.cpp ├── 0944.delete-columns-to-make-sorted.cpp ├── 0968.binary-tree-cameras.cpp ├── 0973.k-closest-points-to-origin.cpp ├── 0978.longest-turbulent-subarray.cpp ├── 0981.time-based-key-value-store.cpp ├── 0983.minimum-cost-for-tickets.cpp ├── 0986.interval-list-intersections.cpp ├── 0987.vertical-order-traversal-of-a-binary-tree.cpp ├── 0988.smallest-string-starting-from-leaf.cpp ├── 0994.rotting-oranges.cpp ├── 1004.max-consecutive-ones-iii.cpp ├── 1019.next-greater-node-in-linked-list.cpp ├── 1024.video-stitching.cpp ├── 1054.distant-barcodes.cpp ├── 1108.defanging-an-ip-address.go ├── 1138.alphabet-board-path.go ├── 1189.maximum-number-of-balloons.cpp ├── 1282.group-the-people-given-the-group-size-they-belong-to.cpp ├── 1302.deepest-leaves-sum.cpp ├── 1305.all-elements-in-two-binary-search-trees.cpp ├── 1315.sum-of-nodes-with-even-valued-grandparent.go ├── 1319.number-of-operations-to-make-network-connected.cpp ├── 1328.break-a-palindrome.cpp ├── 1333.filter-restaurants-by-vegan-friendly-price-and-distance.go ├── 1358.number-of-substrings-containing-all-three-characters.cpp ├── 1360_number-of-days-between-two-dates.go ├── 1361.validate-binary-tree-nodes.cpp ├── 1382.balance-a-binary-search-tree.cpp ├── 1405.longest-happy-string.go ├── 1447.simplified-fractions.go ├── 1472.design-browser-history.cpp ├── 1476.subrectangle-queries.cpp ├── 1480.running-sum-of-1d-array.go ├── 1514.path-with-maximum-probability.cpp ├── 1523.count-odd-numbers-in-an-interval-range.cpp ├── 1557.minimum-number-of-vertices-to-reach-all-nodes.cpp ├── 1657.determine-if-two-strings-are-close.cpp ├── 1662_check-if-two-string-arrays-are-equivalent.go ├── 1664.ways-to-make-a-fair-array.cpp ├── 1669.merge-in-between-linked-lists.cpp ├── 1685.sum-of-absolute-differences-in-a-sorted-array.cpp ├── 1748.sum-of-unique-elements.cpp ├── 1749.maximum-absolute-sum-of-any-subarray.cpp ├── 1859.sorting-the-sentence.cs ├── 1861.rotating-the-box.cpp ├── 1894.find-the-student-that-will-replace-the-chalk.go ├── 1909.remove-one-element-to-make-the-array-strictly-increasing.cpp ├── 1913_maximum-product-difference-between-two-pairs.go ├── 1920.build-array-from-permutation.go ├── 1929.concatenation-of-array.go ├── 1946.largest-number-after-mutating-substring.go ├── 1991_find-the-middle-index-in-array.cpp ├── 2024.maximize-the-confusion-of-an-exam.cpp ├── 2095.delete-the-middle-node-of-a-linked-list.cpp ├── 2099.find-subsequence-of-length-k-with-the-largest-sum.cpp ├── 2108.find-first-palindromic-string-in-the-array.cs ├── 2130.maximum-twin-sum-of-a-linked-list.cpp ├── 2138.divide-a-string-into-groups-of-size-k.cpp ├── 2149.rearrange-array-elements-by-sign.cpp ├── 2169.count-operations-to-obtain-zero.cpp ├── 2170.minimum-operations-to-make-the-array-alternating.cpp ├── 2185.counting-words-with-a-given-prefix.go ├── 2195.append-k-integers-with-minimal-sum.go ├── 2196.create-binary-tree-from-descriptions.cpp ├── 2208.minimum-operations-to-halve-array-sum.cpp ├── 2216.minimum-deletions-to-make-array-beautiful.cpp ├── 2231.largest-number-after-digit-swaps-by-parity.cs ├── 2232.minimize-result-by-adding-parentheses-to-expression.cs ├── 2233.maximum-product-after-k-increments.cpp ├── 2235.add-two-integers.go ├── 2244.minimum-rounds-to-complete-all-tasks.cpp ├── 2260.minimum-consecutive-cards-to-pick-up.cpp ├── 2265.count-nodes-equal-to-average-of-subtree.go ├── 2269.find-the-k-beauty-of-a-number.cs ├── 2287.rearrange-characters-to-make-target-string.cpp ├── 2300.successful-pairs-of-spells-and-potions.cpp ├── 2302.count-subarrays-with-score-less-than-k.cpp ├── 2309.greatest-english-letter-in-upper-and-lower-case.cpp ├── 2315.count-asterisks.cpp ├── 2319.check-if-matrix-is-x-matrix.cpp ├── 2331.evaluate-boolean-binary-tree.go ├── 2342.max-sum-of-a-pair-with-equal-sum-of-digits.cpp ├── 2357.make-array-zero-by-subtracting-equal-amounts.go ├── 2367.number-of-arithmetic-triplets.cpp ├── 2368.reachable-nodes-with-restrictions.cpp ├── 2374.node-with-highest-edge-score.cpp ├── 2379.minimum-recolors-to-get-k-consecutive-black-blocks.cpp ├── 2380.time-needed-to-rearrange-a-binary-string.cpp ├── 2383.minimum-hours-of-training-to-win-a-competition.cpp ├── 2384.largest-palindromic-number.cpp ├── 2385.amount-of-time-for-binary-tree-to-be-infected.cpp ├── 2405.optimal-partition-of-string.cpp ├── 2441.largest-positive-integer-that-exists-with-its-negative.cpp ├── 2444.count-subarrays-with-fixed-bounds.cpp ├── 2487.remove-nodes-from-linked-list.go ├── 2586.count-the-number-of-vowel-strings-in-range.cpp ├── 2587.rearrange-array-to-maximize-prefix-score.cpp ├── 2643.row-with-maximum-ones.go ├── 2651.calculate-delayed-arrival-time.go ├── 2652.sum-multiples.go ├── 2747.count-zero-request-servers.cpp ├── BREADME.org ├── Later.org └── workspace.code-workspace └── ps ├── README.org ├── cc ├── ARREQU.go ├── FLOW001.cpp └── MAXIMUMSUBS.cpp ├── cf ├── 864a.cpp └── arc │ ├── 789 │ ├── a.cpp │ └── a.exe │ ├── 796 │ └── a.cpp │ ├── 798 │ └── a.cpp │ ├── 1335UVA.cpp │ ├── 1634A.cpp │ ├── 223339D.cpp │ ├── 326053R.cpp │ ├── 371B.cpp │ ├── 515C.cpp │ ├── 518B.cpp │ ├── 588B.cpp │ └── 651C.cpp ├── cs ├── AddBorder.cpp ├── AllLongestStrings.cpp ├── MakeArrayConsecutive2.cpp ├── SortbyHeight.go ├── adjacentElementsProduct.cpp ├── alternatingSums.cpp ├── centuryFromYear.cpp ├── checkPalindrome.cpp ├── isLucky.cpp ├── matrixElementsSum.cpp ├── reverseInParentheses.cpp └── shapeArea.cpp ├── cw ├── CanYouGetTheLoop.cpp ├── FindTheMissingLetter.go ├── HumanReadableTime.go ├── IPValidation.go ├── JadenCasingStrings.go ├── MaketheDeadfishSwim.go ├── MovingZerosToTheEnd.go ├── Multiplesof3or5.go ├── MultiplicationTable.go ├── Mumbling.go ├── Notverysecure.go ├── PrimesInNumbers.go ├── ShortestWord.go ├── SplitStrings.go ├── StopgninnipSMysdroW.go ├── SumofDigitsDigitalRoot.go ├── TwoSum.go ├── ValidParenthesese.go ├── VowelCount.go ├── WeIrDStRiNgCaSe.go ├── WhichAreIn.go ├── dont-give-me-five.go └── test.go ├── fl ├── 0022_generate-parentheses.cpp ├── 0092.reverse-linked-list-ii.go ├── 0205_isomorphic-strings.cpp ├── 0416_partition-equal-subset-sum.cpp ├── 0424_longest-repeating-character-replacement.cpp ├── 0894_all-possible-full-binary-trees.cpp ├── 0914.x-of-a-kind-in-a-deck-of-cards.go ├── 0915_partition-array-into-disjoint-intervals.cpp ├── 0947_most-stones-removed-with-same-row-or-column.cpp ├── 0984_string-without-aaa-or-bbb.cpp ├── 1038.binary-search-tree-to-greater-sum-tree.go ├── 116.populating-next-right-pointers-in-each-node.cpp ├── 1382.balance-a-binary-search-tree.go ├── 15.3sums.cpp ├── 1634B.cpp ├── 1637A.cpp ├── 1654.minimum-jumps-to-reach-home.cpp ├── 1817.finding-the-users-active-minutes.go ├── 2138.divide-a-string-into-groups-of-size-k.cpp ├── 42.trapping-rain-water.cpp ├── 438.find-all-anagrams-in-a-string.cpp ├── 587.erect-the-fence.cpp ├── 71.simplify-path.cpp ├── 91.decode-ways.cpp ├── 919.cpp ├── 93.restore-ip-addresses.cpp ├── 99.subsets-ii.cpp ├── main.go └── x.cpp ├── he └── max-difference.cpp ├── nt ├── 1704.cpp ├── 1862.cpp ├── 1882.cpp ├── 213.cpp ├── 380.cpp ├── 415.cpp ├── 663.cpp ├── 860.cpp ├── 919.cpp └── 920.cpp ├── st ├── 2022-02-14_14-11-50_screenshot.png ├── 2022-02-14_14-12-07_screenshot.png ├── 2022-02-14_14-12-16_screenshot.png ├── 2022-02-14_14-12-23_screenshot.png ├── 2022-02-14_14-12-28_screenshot.png ├── 2022-02-14_14-12-35_screenshot.png └── 2022-02-14_14-12-55_screenshot.png └── test.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | saved/nsg.org 2 | /saved/ 3 | Derviation.org 4 | Morsi.org 5 | Noted.org 6 | Word.org 7 | afghani_love_mala.org 8 | israelcold.org 9 | justsave.org 10 | list.org 11 | poetry.org 12 | problems.org 13 | todo.org 14 | /papers/ 15 | /journal/ 16 | /saved/ 17 | /ps/tempModule/.idea/.idea.tempModule.dir/.idea/workspace.xml 18 | /dummy/ 19 | /thinkgit/ 20 | /Glossary.org 21 | /journal 22 | /drft/Glossary.org 23 | /drft/Derivation.org 24 | /life.org 25 | /archive/other/ptrns/allcontent.org 26 | *.log 27 | /.idea/ 28 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule ".doom.d/doom-todo-ivy"] 2 | path = .doom.d/doom-todo-ivy 3 | url = https://github.com/jsmestad/doom-todo-ivy.git 4 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | *A mirror of my leetcode OJ solutions*. For other OJs check the [ps/](ps/) directory. 2 | 3 | Directory naming: 4 | 5 | - [hr](hr/): hackerrank 6 | - [cc](ps/cc/): [codechef](https://www.codechef.com/). 7 | - [cf](ps/cf/): [codeforces](https://codeforces.com/). 8 | - [cs](ps/cs/): [codesignal](https://codesignal.com/). 9 | - [cw](ps/cw/): [codewars](https://www.codewars.com/). 10 | - [fl](ps/fl/): failed problems. 11 | - [he](ps/he/): [hackerearth](https://www.hackerearth.com/). 12 | - [nt](ps/nt/): [lintcode](https://www.lintcode.com/). 13 | - [cg](ps/cg/): [codegolf](https://codegolf.stackexchange.com/). 14 | 15 | - [2024-01-13 Sat 21:17]: Looking here now as it has been 4 years since I 16 | started doing competitive programming, it's funny how I used so many different 17 | OJs, I think it was unreasonable. 18 | 19 | -------------------------------------------------------------------------------- /README.org: -------------------------------------------------------------------------------- 1 | #+OPTIONS: toc:nil 2 | /A mirror of my leetcode OJ solutions/. For other OJs check the [[file:ps/][ps/]] directory. 3 | 4 | Directory naming: 5 | 6 | - [[file:ps/cc/][cc]]: [[https://www.codechef.com/][codechef]]. 7 | - [[file:ps/cf/][cf]]: [[https://codeforces.com/][codeforces]]. 8 | - [[file:ps/cs/][cs]]: [[https://codesignal.com/][codesignal]]. 9 | - [[file:ps/cw/][cw]]: [[https://www.codewars.com/][codewars]]. 10 | - [[file:ps/fl/][fl]]: failed problems. 11 | - [[file:ps/he/][he]]: [[https://www.hackerearth.com/][hackerearth]]. 12 | - [[file:ps/nt/][nt]]: [[https://www.lintcode.com/][lintcode]]. 13 | - [[file:ps/cg/][cg]]: [[https://codegolf.stackexchange.com/][codegolf]]. 14 | 15 | 16 | - [2024-01-13 Sat 21:17]: Looking here now as it has been 4 years since I 17 | started doing competitive programming, it's funny how I used so many different 18 | OJs, I think it was unreasonable. 19 | -------------------------------------------------------------------------------- /hr/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | /classes 3 | /checkouts 4 | /.lein-* 5 | /.nrepl-port 6 | -------------------------------------------------------------------------------- /hr/project.clj: -------------------------------------------------------------------------------- 1 | (defproject hr "0.1.0-SNAPSHOT" 2 | :dependencies [[org.clojure/clojure "1.11.0"]] 3 | :source-paths ["."] 4 | :repl-options {:init-ns hr} 5 | :main hr) 6 | -------------------------------------------------------------------------------- /lc/0001.two-sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector twoSum(vector &nums, int target) { 4 | unordered_map indices; 5 | for (int i = 0; i < nums.size(); i++) { 6 | if (indices.find(target - nums[i]) != indices.end()) { 7 | return {indices[target - nums[i]], i}; 8 | } 9 | indices[nums[i]] = i; 10 | } 11 | return {}; 12 | } 13 | }; 14 | -------------------------------------------------------------------------------- /lc/0001.two-sum.cs: -------------------------------------------------------------------------------- 1 | public class Solution 2 | { 3 | public int[] TwoSum(int[] nums, int target) 4 | { 5 | var d = new Dictionary(); 6 | for (int i = 0; i < nums.Length; i++) 7 | { 8 | var diff = target - nums[i]; 9 | if (d.ContainsKey(diff)) 10 | { 11 | return new int[] { i, d[diff] }; 12 | } 13 | d.TryAdd(nums[i], i); 14 | } 15 | 16 | return new int[] { 0, 0 }; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /lc/0003.longest-substring-without-repeating-characters.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int lengthOfLongestSubstring(string s) { 29 | // stack st; 30 | map mp; 31 | int ans(0); 32 | int i(0), j(0); 33 | while (i <= j && j < s.size()) { 34 | while (mp[s[j]]) { 35 | mp[s[i]] = 0; 36 | i++; 37 | } 38 | mp[s[j]] = 1; 39 | ans = max(ans, j - i + 1); 40 | j++; 41 | } 42 | return ans; 43 | } 44 | }; 45 | -------------------------------------------------------------------------------- /lc/0009.palindrome-number.cs: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public bool IsPalindrome(int x) 3 | { 4 | return new string(x.ToString().Reverse().ToArray()) == x.ToString(); 5 | 6 | } 7 | 8 | } 9 | -------------------------------------------------------------------------------- /lc/0011_container-with-most-water.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import "math" 4 | 5 | func maxArea(height []int) int { 6 | res, l, r := 0, 0, len(height)-1 7 | 8 | for l < r { 9 | tres := (r - l) * int(math.Min(float64(height[l]), float64(height[r]))) 10 | res = int(math.Max(float64(tres), float64(res))) 11 | if height[r] > height[l] { 12 | l++ 13 | } else { 14 | r-- 15 | } 16 | } 17 | return res 18 | 19 | } 20 | -------------------------------------------------------------------------------- /lc/0013.roman-to-integer.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int romanToInt(string s) { 29 | unordered_map mp{ 30 | {'I', 1}, {'V', 5}, {'X', 10}, {'L', 50}, 31 | {'C', 100}, {'D', 500}, {'M', 1000}, 32 | }; 33 | int ans = 0; 34 | for (int i = 0; i < s.size(); i++) { 35 | if (mp[s[i]] < mp[s[i + 1]]) 36 | ans -= mp[s[i]]; 37 | else 38 | ans += mp[s[i]]; 39 | } 40 | return ans; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /lc/0014.longest-common-prefix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | string longestCommonPrefix(vector &str) { 29 | int n = str.size(); 30 | if (n == 0) 31 | return ""; 32 | 33 | string ans = ""; 34 | sort(begin(str), end(str)); 35 | string a = str[0]; 36 | string b = str[n - 1]; 37 | 38 | for (int i = 0; i < a.size(); i++) { 39 | if (a[i] == b[i]) { 40 | ans = ans + a[i]; 41 | } else { 42 | break; 43 | } 44 | } 45 | 46 | return ans; 47 | } 48 | }; 49 | -------------------------------------------------------------------------------- /lc/0015_3sum.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import "sort" 4 | 5 | func threeSum(nums []int) [][]int { 6 | var res [][]int 7 | if len(nums) < 3 { 8 | return res 9 | } 10 | 11 | sort.Ints(nums) 12 | 13 | for i := 0; i < len(nums)-2; i++ { 14 | if i > 0 && nums[i] == nums[i-1] { 15 | continue 16 | } 17 | 18 | left, right := i+1, len(nums)-1 19 | 20 | for left < right { 21 | target := nums[i] + nums[left] + nums[right] 22 | 23 | if target == 0 { 24 | res = append(res, []int{nums[i], nums[left], nums[right]}) 25 | left, right = left+1, right-1 26 | 27 | for left < right && nums[left] == nums[left-1] { 28 | left++ 29 | } 30 | 31 | for left < right && nums[right] == nums[right+1] { 32 | right-- 33 | } 34 | } else if target > 0 { 35 | right-- 36 | } else { 37 | left++ 38 | } 39 | } 40 | } 41 | 42 | return res 43 | } 44 | -------------------------------------------------------------------------------- /lc/0020.valid-parentheses.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | bool isValid(string s) { 6 | stack paren; 7 | for (char &c : s) { 8 | switch (c) { 9 | case '(': 10 | case '{': 11 | case '[': 12 | paren.push(c); 13 | break; 14 | case ')': 15 | if (paren.empty() || paren.top() != '(') 16 | return false; 17 | else 18 | paren.pop(); 19 | break; 20 | case '}': 21 | if (paren.empty() || paren.top() != '{') 22 | return false; 23 | else 24 | paren.pop(); 25 | break; 26 | case ']': 27 | if (paren.empty() || paren.top() != '[') 28 | return false; 29 | else 30 | paren.pop(); 31 | break; 32 | default:; // pass 33 | } 34 | } 35 | return paren.empty(); 36 | } 37 | -------------------------------------------------------------------------------- /lc/0022.generate-parentheses.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | vector generateParenthesis(int n) { 29 | vector res; 30 | addingpar(res, "", n, 0); 31 | return res; 32 | } 33 | void addingpar(vector &v, string str, int n, int m) { 34 | if (n == 0 && m == 0) { 35 | v.push_back(str); 36 | return; 37 | } 38 | if (n > 0) { 39 | addingpar(v, str + "(", n - 1, m + 1); 40 | } 41 | 42 | if (m > 0) { 43 | addingpar(v, str + ")", n, m - 1); 44 | } 45 | } 46 | }; 47 | -------------------------------------------------------------------------------- /lc/0028.find-the-index-of-the-first-occurrence-in-a-string.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int strStr(string haystack, string needle) { 29 | char f = needle[0]; 30 | int n = haystack.size(), m = needle.size(); 31 | for (int i = 0; i < n; i++) { 32 | if (haystack[i] == f) { 33 | int t(i), j(0); 34 | for (j = 0; j < m && t < n; j++, t++) { 35 | if (haystack[t] != needle[j]) 36 | break; 37 | } 38 | if (j == m - 1) 39 | return i; 40 | } 41 | } 42 | return -1; 43 | } 44 | }; 45 | -------------------------------------------------------------------------------- /lc/0028.merge-sorted-array.cpp: -------------------------------------------------------------------------------- 1 | class solution { 2 | public: 3 | void merge(vector &nums1, int m, vector &nums2, int n) { 4 | int i = m - 1, j = n - 1, k = m + n - 1; 5 | while (i >= 0 and j >= 0) { 6 | if (nums1[i] < nums2[j]) { 7 | nums1[k--] = nums2[j--]; 8 | } else { 9 | nums1[k--] = nums1[i--]; 10 | } 11 | } 12 | while (j >= 0) { 13 | nums1[k--] = nums2[j--]; 14 | } 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /lc/0040.combination-sum-ii.go: -------------------------------------------------------------------------------- 1 | func combinationSum2(candidates []int, target int) [][]int { 2 | 3 | } 4 | -------------------------------------------------------------------------------- /lc/0041.first-missing-positive.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/first-missing-positive/ 3 | * Tags: Negative Markting 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | int firstMissingPositive(vector &nums) { 32 | int n = nums.size(); 33 | for (auto &i : nums) 34 | if (i > n || 0 >= i) 35 | i = 1, nums[i - 1] *= -1; 36 | else 37 | nums[i - 1] *= -1; 38 | 39 | for (int i = 0; i < n; i++) { 40 | if (nums[i] > 0) 41 | return i + 1; 42 | } 43 | return n + 1; 44 | } 45 | }; 46 | 47 | int main() { 48 | ios_base::sync_with_stdio(false); 49 | cin.tie(NULL); 50 | } 51 | -------------------------------------------------------------------------------- /lc/0048.rotate-image.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | void rotate(vector> &matrix) { 29 | int n = (int)matrix.size(); 30 | int povit = n / 2; 31 | for (auto &m : matrix) { 32 | } 33 | } 34 | int main() { 35 | ios_base::sync_with_stdio(false); 36 | cin.tie(NULL); 37 | vector> matrix{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; 38 | cout << (int)(3 / 2); 39 | } 40 | -------------------------------------------------------------------------------- /lc/0049.group-anagrams.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/ 4 | * Tags: Array 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | int main() { 31 | ios_base::sync_with_stdio(false); 32 | cin.tie(NULL); 33 | } 34 | 35 | class Solution { 36 | public: 37 | vector> groupAnagrams(vector &strs) { 38 | map> m; 39 | for (auto const &i : strs) { 40 | auto t = i; 41 | sort(begend(t)); 42 | m[t].push_back(i); 43 | } 44 | vector> ans; 45 | for (auto const &i : m) { 46 | ans.push_back(i.second); 47 | } 48 | return ans; 49 | ; 50 | } 51 | }; 52 | -------------------------------------------------------------------------------- /lc/0049.group-anagrams.cs: -------------------------------------------------------------------------------- 1 | public class Solution 2 | { 3 | public List> GroupAnagrams(string[] strs) 4 | { 5 | Dictionary> d = new(); 6 | foreach (var s in strs) 7 | { 8 | var c = new int[26]; 9 | for (int i = 0; i < s.Length; i++) 10 | { 11 | c[s[i] - 'a']++; 12 | } 13 | if (!d.ContainsKey(c)) 14 | { 15 | d.Add(c, new List()); 16 | } 17 | d[c].Add(s); 18 | } 19 | return d.Values.ToList(); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /lc/0053.maximum-subarray.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/maximum-subarray/ 3 | * Tags: Array 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | int maxSubArray(vector &nums) { 30 | int n = nums.size(); 31 | int maxSum = INT_MIN; 32 | int currSum = 0; 33 | for (int i = 0; i <= n - 1; i++) { 34 | currSum += nums[i]; 35 | if (currSum > maxSum) { 36 | maxSum = currSum; 37 | } 38 | if (currSum < 0) { 39 | currSum = 0; 40 | } 41 | } 42 | return maxSum; 43 | } 44 | 45 | int main() { 46 | vector nums{-2, -1, -4}; 47 | maxSubArray(nums); 48 | } 49 | -------------------------------------------------------------------------------- /lc/0054.spiral-matrix.cpp: -------------------------------------------------------------------------------- 1 | vector spiralOrder(vector> &matrix) { 2 | vector> dirs{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; 3 | vector res; 4 | int nr = matrix.size(); 5 | if (nr == 0) 6 | return res; 7 | int nc = matrix[0].size(); 8 | if (nc == 0) 9 | return res; 10 | 11 | vector nSteps{nc, nr - 1}; 12 | 13 | int iDir = 0; // index of direction. 14 | int ir = 0, ic = -1; // initial position 15 | while (nSteps[iDir % 2]) { 16 | for (int i = 0; i < nSteps[iDir % 2]; ++i) { 17 | ir += dirs[iDir][0]; 18 | ic += dirs[iDir][1]; 19 | res.push_back(matrix[ir][ic]); 20 | } 21 | nSteps[iDir % 2]--; 22 | iDir = (iDir + 1) % 4; 23 | } 24 | return res; 25 | } 26 | -------------------------------------------------------------------------------- /lc/0058.length-of-last-word.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | ) 7 | 8 | func lengthOfLastWord(s string) int { 9 | check := strings.Split(s, " ") 10 | n := len(check) 11 | for i := n - 1; i >= 0; i-- { 12 | if len(check[i]) > 0 { 13 | return len(check[i]) 14 | } 15 | } 16 | return 0 17 | } 18 | -------------------------------------------------------------------------------- /lc/0062.unique-paths.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/unique-paths/ 3 | * Tags: Dyanmic Programming 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | int main() { 30 | ios_base::sync_with_stdio(false); 31 | cin.tie(NULL); 32 | } 33 | -------------------------------------------------------------------------------- /lc/0064.minimum-path-sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int minPathSum(vector> &grid) { 29 | int n = grid.size(); 30 | int m = grid[0].size(); 31 | for (int i = 1; i < m; i++) { 32 | grid[0][i] += grid[0][i - 1]; 33 | } 34 | for (int i = 1; i < n; i++) { 35 | for (int j = 0; j < m; j++) { 36 | if (j != 0) 37 | grid[i][j] += min({grid[i - 1][j], grid[i][j - 1]}); 38 | else 39 | grid[i][j] += grid[i - 1][j]; 40 | } 41 | } 42 | return grid[n - 1][m - 1]; 43 | } 44 | }; 45 | -------------------------------------------------------------------------------- /lc/0066.plus-one.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #define begend(v) ((v).begin()), ((v).end()) 22 | #define sz(v) ((int)((v).size())) 23 | using namespace std; 24 | typedef pair pi; 25 | priority_queue, greater> pq; 26 | 27 | class Solution { 28 | public: 29 | vector plusOne(vector &digits) { 30 | int i = digits.size() - 1; 31 | int r = digits[i] + 1; 32 | if (r < 10) { 33 | digits[i]++; 34 | } else { 35 | digits[i] = 0; 36 | i--; 37 | while (i >= 0) { 38 | r = digits[i] + 1; 39 | if (r < 10) { 40 | digits[i]++; 41 | break; 42 | } 43 | digits[i] = 0; 44 | i--; 45 | } 46 | if (i < 0) { 47 | digits.insert(digits.begin(), 1, 1); 48 | } 49 | } 50 | return digits; 51 | } 52 | }; 53 | -------------------------------------------------------------------------------- /lc/0077.combinations.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | int m; 28 | int e; 29 | vector> ans; 30 | void solve(int s, vector &d) { 31 | if (d.size() == e) { 32 | ans.push_back(d); 33 | return; 34 | } 35 | for (int i = s; i <= m; i++) { 36 | d.push_back(i); 37 | solve(i + 1, d); 38 | d.pop_back(); 39 | } 40 | } 41 | 42 | public: 43 | vector> combine(int n, int k) { 44 | m = n, e = k; 45 | vector d; 46 | solve(1, d); 47 | return ans; 48 | } 49 | }; 50 | -------------------------------------------------------------------------------- /lc/0078.subsets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | int n; 28 | vector> ans; 29 | void back(int s, vector &dump, vector &nums) { 30 | ans.push_back(dump); 31 | if (dump.size() == n) { 32 | return; 33 | } 34 | for (int i = s; i < n; i++) { 35 | dump.push_back(nums[i]); 36 | back(i + 1, dump, nums); 37 | dump.pop_back(); 38 | } 39 | } 40 | 41 | public: 42 | vector> subsets(vector &nums) { 43 | vector d; 44 | n = nums.size(); 45 | back(0, d, nums); 46 | return ans; 47 | } 48 | }; 49 | -------------------------------------------------------------------------------- /lc/0080.remove-duplicates-from-sorted-array-ii.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/ Tags: 4 | * Two Pointers 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | // bad solution, slow 31 | int removeDuplicates(vector &nums) { 32 | for (auto iter = nums.begin(); iter < nums.end() - 2; ++iter) { 33 | if (*iter == *(iter + 1)) 34 | while (*(iter + 1) == *(iter + 2) && (iter + 1 < nums.end()) && 35 | (iter + 2) < nums.end()) 36 | nums.erase(iter + 2); 37 | } 38 | return (int)nums.size(); 39 | } 40 | 41 | int main() { 42 | vector arr{1, 1, 1}; 43 | // arr.erase(arr.begin() + 2); 44 | cout << removeDuplicates(arr); 45 | for (auto &i : arr) { 46 | cout << i << endl; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /lc/0098.validate-binary-search-tree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | int last; 28 | bool res = 1, first = 1; 29 | void inorde(TreeNode *root) { 30 | if (!root || !res) 31 | return; 32 | inorde(root->left); 33 | if (root->val <= last && !first) { 34 | res = false; 35 | first = 0; 36 | return; 37 | } 38 | first = 0; 39 | last = root->val; 40 | inorde(root->right); 41 | } 42 | 43 | public: 44 | bool isValidBST(TreeNode *root) { 45 | auto t = root; 46 | while (t) { 47 | last = t->val; 48 | t = t->left; 49 | } 50 | inorde(root); 51 | return res; 52 | } 53 | }; 54 | -------------------------------------------------------------------------------- /lc/0104.maximum-depth-of-binary-tree.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import "math" 4 | 5 | func maxDepth(root *TreeNode) int { 6 | if root == nil { 7 | return 0 8 | } 9 | return int(math.Max(float64(maxDepth(root.Right)+1), float64(maxDepth(root.Left)+1))) 10 | } 11 | -------------------------------------------------------------------------------- /lc/0108.convert-sorted-array-to-binary-search-tree.go: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * type TreeNode struct { 4 | * Val int 5 | * Left *TreeNode 6 | * Right *TreeNode 7 | * } 8 | */ 9 | func sortedArrayToBST(nums []int) *TreeNode { 10 | return solution(&nums, 0, len(nums)-1) 11 | } 12 | 13 | func solution(arr *[]int, l, r int) (root *TreeNode) { 14 | root = new(TreeNode) 15 | if l > r { 16 | return nil 17 | } 18 | var m int = (l + r) / 2 19 | root.Val = (*arr)[m] 20 | root.Left = solution(arr, l, m-1) 21 | root.Right = solution(arr, m+1, r) 22 | return 23 | } 24 | -------------------------------------------------------------------------------- /lc/0116.populating-next-right-pointers-in-each-node.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * https://leetcode.com/problems/populating-next-right-pointers-in-each-node/ 4 | * Tags: Tree 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | class Node { 30 | public: 31 | int val; 32 | Node *left; 33 | Node *right; 34 | Node *next; 35 | 36 | Node() : val(0), left(NULL), right(NULL), next(NULL) {} 37 | 38 | Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {} 39 | 40 | Node(int _val, Node *_left, Node *_right, Node *_next) 41 | : val(_val), left(_left), right(_right), next(_next) {} 42 | }; 43 | 44 | Node *connect(Node *root) { return nullptr; } 45 | 46 | int main() { 47 | ios_base::sync_with_stdio(false); 48 | cin.tie(NULL); 49 | } 50 | -------------------------------------------------------------------------------- /lc/0121.best-time-to-buy-and-sell-stock.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxProfit(vector& prices) { 4 | int lsf = INT_MAX; 5 | int op = 0; 6 | int pist = 0; 7 | 8 | for(int i = 0; i < prices.size(); i++){ 9 | if(prices[i] < lsf){ 10 | lsf = prices[i]; 11 | } 12 | pist = prices[i] - lsf; 13 | if(op < pist){ 14 | op = pist; 15 | } 16 | } 17 | return op; 18 | } 19 | }; 20 | -------------------------------------------------------------------------------- /lc/0125.valid-palindrome.cpp: -------------------------------------------------------------------------------- 1 | #define begend(v) ((v).begin()), ((v).end()) 2 | #define sz(v) ((int)((v).size())) 3 | using namespace std; 4 | 5 | class Solution { 6 | public: 7 | /** 8 | * @param s: A string 9 | * @return: Whether the string is a valid palindrome 10 | */ 11 | bool isPalindrome(string s) { 12 | s.erase(remove_if(begend(s), 13 | [](auto const &x) -> bool { 14 | if (isdigit(x)) 15 | return false; 16 | return !isalpha(x); 17 | }), 18 | s.end()); 19 | transform(begend(s), s.begin(), ::toupper); 20 | string p = s; 21 | reverse(begend(p)); 22 | return p == s; 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /lc/0133.clone-graph.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | type Node struct { 4 | Val int 5 | Neighbors []*Node 6 | } 7 | 8 | var mp = make(map[*Node]*Node) 9 | 10 | func cloneGraph(node *Node) *Node { 11 | if node == nil { 12 | return node 13 | } 14 | if _, ok := mp[node]; !ok { 15 | mp[node] = new(Node) 16 | mp[node].Val = node.Val 17 | for _, value := range node.Neighbors { 18 | mp[node].Neighbors = append(mp[node].Neighbors, cloneGraph(value)) 19 | } 20 | } 21 | return mp[node] 22 | } 23 | -------------------------------------------------------------------------------- /lc/0136.single-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/single-number/ 3 | * Tags: Array 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | int singleNumber(vector &nums) { 32 | map m; 33 | for (const int &i : nums) { 34 | m[i]++; 35 | } 36 | auto i = min_element(m.begin(), m.end(), [](const auto &i, const auto &j) { 37 | return j.second > i.second; 38 | }); 39 | return (i)->first; 40 | } 41 | }; 42 | 43 | int main() { 44 | Solution p; 45 | vector t{1, 1, 2, 3, 2, 3, 3, 5, 5, 13, 11}; 46 | p.singleNumber(t); 47 | } 48 | -------------------------------------------------------------------------------- /lc/0141.linked-list-cycle.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | // struct ListNode { 27 | // int val; 28 | // ListNode *next; 29 | // ListNode(int x) : val(x), next(NULL) {} 30 | // }; 31 | class Solution { 32 | public: 33 | bool hasCycle(ListNode *head) { 34 | std::map v; 35 | while (head) { 36 | if (v[head]) 37 | return 1; 38 | v[head] = 1; 39 | head = head->next; 40 | } 41 | return 0; 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /lc/0142.linked-list-cycle-ii.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | struct ListNode { 30 | int val; 31 | ListNode *next; 32 | ListNode(int x) : val(x), next(NULL) {} 33 | }; 34 | class Solution { 35 | public: 36 | ListNode *detectCycle(ListNode *head) { 37 | map mp; 38 | auto hd = head; 39 | while (hd) { 40 | if (mp[hd]) 41 | return hd; 42 | mp[hd] = 1; 43 | hd = hd->next; 44 | } 45 | return nullptr; 46 | } 47 | }; 48 | 49 | int main() { 50 | ios_base::sync_with_stdio(false); 51 | cin.tie(NULL); 52 | } 53 | -------------------------------------------------------------------------------- /lc/0144.flatten-binary-tree-to-linked-list.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/flatten-binary-tree-to-linked-list/ 3 | * Tags: Linked List 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | struct TreeNode { 30 | int val; 31 | TreeNode *left; 32 | TreeNode *right; 33 | TreeNode() : val(0), left(nullptr), right(nullptr) {} 34 | TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 35 | TreeNode(int x, TreeNode *left, TreeNode *right) 36 | : val(x), left(left), right(right) {} 37 | }; 38 | class Solution { 39 | public: 40 | void flatten(TreeNode *root) {} 41 | }; 42 | 43 | int main() { 44 | ios_base::sync_with_stdio(false); 45 | cin.tie(NULL); 46 | } 47 | -------------------------------------------------------------------------------- /lc/0148.sort-list.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func sortList(head *ListNode) *ListNode { 9 | tmpnode := head 10 | lst := make([]*ListNode, 0) 11 | for tmpnode != nil { 12 | lst = append(lst, tmpnode) 13 | tmpnode = tmpnode.Next 14 | } 15 | end := len(lst) 16 | lst = *MergeSort(&lst) 17 | for i := 1; i < end; i++ { 18 | lst[i-1].Next = lst[i] 19 | } 20 | lst[end-1].Next = nil 21 | return lst[0] 22 | } 23 | 24 | func MergeSort(listNode *[]*ListNode) *[]*ListNode { 25 | if len(*listNode) < 2 { 26 | return listNode 27 | } 28 | mid := len(*listNode) / 2 29 | l := (*listNode)[:mid] 30 | r := (*listNode)[mid:] 31 | return Merge(MergeSort(&l), MergeSort(&r)) 32 | } 33 | 34 | func Merge(left, right *[]*ListNode) *[]*ListNode { 35 | na, nb, sz, j, i := len(*left), len(*right), len(*left)+len(*right), 0, 0 36 | res := make([]*ListNode, sz) 37 | for i < na && j < nb { 38 | if (*left)[i].Val > (*right)[j].Val { 39 | res = append(res, (*right)[j]) 40 | j++ 41 | } else { 42 | res = append(res, (*left)[i]) 43 | i++ 44 | } 45 | } 46 | for i < na { 47 | res = append(res, (*left)[i]) 48 | i++ 49 | } 50 | for j < nb { 51 | res = append(res, (*right)[j]) 52 | j++ 53 | } 54 | return &res 55 | } 56 | -------------------------------------------------------------------------------- /lc/0151.reverse-words-in-a-string.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Linq; 3 | class Solution 4 | { 5 | public string ReverseWords(string s) 6 | { 7 | return String.Join(" ", s.Split(" ").Reverse().Where(x => !string.IsNullOrEmpty(x))); 8 | 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /lc/0153.find-minimum-in-rotated-sorted-array.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 153. Find Minimum in Rotated Sorted Array 3 | * Tags: Binary Search 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | int findMin(vector &nums) { 32 | int n = nums.size(), l = 0, r = n - 1, m; 33 | if (n == 1) 34 | return nums[0]; 35 | while (l < r) { 36 | m = l + (r - l) / 2; 37 | if (m > 0 && nums[m] < nums[m - 1]) 38 | return nums[m]; 39 | if (nums[l] <= nums[m] && nums[m] > nums[r]) // left sorted, right not 40 | { 41 | l = m + 1; 42 | continue; 43 | } 44 | r = m - 1; 45 | } 46 | return nums[l]; 47 | } 48 | }; 49 | 50 | int main() { 51 | ios_base::sync_with_stdio(false); 52 | cin.tie(NULL); 53 | } 54 | -------------------------------------------------------------------------------- /lc/0154.find-minimum-in-rotated-sorted-array-ii.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | int findMin(vector &nums) { 32 | int n = nums.size(), l = 0, r = n - 1, m; 33 | if (n == 1) 34 | return nums[0]; 35 | while (l < r) { 36 | m = l + (r - l) / 2; 37 | if (m > 0 && nums[m] < nums[m - 1]) 38 | return nums[m]; 39 | if (nums[m] > nums[r]) // left sorted, right not 40 | { 41 | l = m + 1; 42 | continue; 43 | } else if (nums[m] < nums[l]) 44 | r = m - 1; 45 | else 46 | r--; 47 | } 48 | return nums[l]; 49 | } 50 | }; 51 | 52 | int main() { 53 | ios_base::sync_with_stdio(false); 54 | cin.tie(NULL); 55 | } 56 | -------------------------------------------------------------------------------- /lc/0162.find-peak-element.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int findPeakElement(const vector &num) { 29 | return Helper(num, 0, num.size() - 1); 30 | } 31 | int Helper(const vector &num, int low, int high) { 32 | if (low == high) 33 | return low; 34 | else { 35 | int mid1 = (low + high) / 2; 36 | int mid2 = mid1 + 1; 37 | if (num[mid1] > num[mid2]) 38 | return Helper(num, low, mid1); 39 | else 40 | return Helper(num, mid2, high); 41 | } 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /lc/0164.maximum-gap.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/maximum-gap/ 3 | * Tags: Sorting 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | class Solution { 29 | public: 30 | int maximumGap(vector &nums) { 31 | int s = sz(nums); 32 | sort(begend(nums)); 33 | if (s < 2) 34 | return 0; 35 | int max = 0, t; 36 | for (int i = 0; i < s - 1; i++) { 37 | t = abs(nums[i] - nums[i + 1]); 38 | if (t > max) 39 | max = t; 40 | } 41 | return max; 42 | } 43 | }; 44 | int main() { 45 | ios_base::sync_with_stdio(false); 46 | cin.tie(NULL); 47 | } 48 | -------------------------------------------------------------------------------- /lc/0169.majority-element.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int majorityElement(vector &nums) { 29 | map mp; 30 | int mi(-1), m(-1); 31 | for (auto &i : nums) { 32 | mp[i]++; 33 | if (mp[i] > m) { 34 | mi = i, m = mp[i]; 35 | } 36 | } 37 | return mi; 38 | } 39 | }; 40 | -------------------------------------------------------------------------------- /lc/0173.binary-search-tree-iterator.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | // type TreeNode struct { 4 | // Val int 5 | // Left *TreeNode 6 | // Right *TreeNode 7 | // } 8 | 9 | type BSTIterator struct { 10 | } 11 | 12 | var curr int 13 | var c chan int 14 | 15 | func Constructor(root *TreeNode) BSTIterator { 16 | n := BSTIterator{} 17 | c = make(chan int) 18 | go func() { 19 | defer func() { 20 | c <- -1 21 | }() 22 | trv(root, c) 23 | }() 24 | curr = <-c 25 | return n 26 | } 27 | func trv(root *TreeNode, c chan int) { 28 | if root == nil { 29 | return 30 | } 31 | trv(root.Left, c) 32 | c <- root.Val 33 | trv(root.Right, c) 34 | } 35 | 36 | func (this *BSTIterator) Next() int { 37 | tmp := curr 38 | curr = <-c 39 | return tmp 40 | } 41 | 42 | func (this *BSTIterator) HasNext() bool { 43 | return curr != -1 44 | } 45 | 46 | /** 47 | * Your BSTIterator object will be instantiated and called as such: 48 | * obj := Constructor(root); 49 | * param_1 := obj.Next(); 50 | * param_2 := obj.HasNext(); 51 | */ 52 | -------------------------------------------------------------------------------- /lc/0179.largest-number.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import ( 4 | "sort" 5 | "strconv" 6 | "strings" 7 | ) 8 | 9 | func largestNumber(nums []int) string { 10 | ans := strings.Builder{} 11 | csh := map[int]int{} 12 | getAs := func(n int) int { 13 | if val, ok := csh[n]; ok { 14 | return val 15 | } 16 | l := n 17 | for n > 0 { 18 | l = n 19 | n /= 10 20 | } 21 | csh[n] = l 22 | return l 23 | } 24 | sorty := func(i, j int) bool { 25 | fi, fj := getAs(nums[i]), getAs(nums[j]) 26 | if fi == fj && nums[i] != nums[j] { 27 | si, sj := strconv.Itoa(nums[i]), strconv.Itoa(nums[j]) 28 | fzi := strings.IndexRune(si, '0') 29 | if fzi != -1 { 30 | fi, _ = strconv.Atoi(si[:fzi]) 31 | } else { 32 | return false 33 | } 34 | fzj := strings.IndexRune(sj, '0') 35 | if fzj != -1 { 36 | fj, _ = strconv.Atoi(sj[:fzj]) 37 | } else { 38 | return true 39 | } 40 | } 41 | if fi == fj { 42 | return nums[i] < nums[j] 43 | } 44 | return fi < fj 45 | } 46 | sort.Slice(nums, sorty) 47 | n := len(nums) - 1 48 | for ; n >= 0; n-- { 49 | ans.WriteString(strconv.Itoa(nums[n])) 50 | } 51 | return ans.String() 52 | } 53 | -------------------------------------------------------------------------------- /lc/0189.rotate-array.cpp: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Problem: https://leetcode.com/problems/rotate-array/ 4 | * Tags: Two Pointers 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | void _rotate(vector &nums, int k) { 31 | vector temp; 32 | k = k > nums.size() ? k % nums.size() : k; 33 | temp.assign(nums.end() - k, nums.end()); 34 | temp.insert(temp.end(), nums.begin(), nums.end() - k); 35 | nums = temp; 36 | for (auto &i : nums) { 37 | cout << i << " "; 38 | } 39 | } 40 | 41 | int main() { 42 | vector t{1, 2, 3, 4, 5, 6, 7}; 43 | int k = 3; 44 | _rotate(t, 3); 45 | } 46 | -------------------------------------------------------------------------------- /lc/0206.reverse-linked-list.go: -------------------------------------------------------------------------------- 1 | 2 | /** 3 | * Definition for singly-linked list. 4 | * type ListNode struct { 5 | * Val int 6 | * Next *ListNode 7 | * } 8 | */ 9 | 10 | func reverseList(head *ListNode) *ListNode { 11 | if head == nil || head.Next == nil { 12 | return head 13 | } 14 | node := reverseList(head.Next) 15 | head.Next.Next = head 16 | head.Next = nil 17 | return node 18 | } 19 | -------------------------------------------------------------------------------- /lc/0209.minimum-size-subarray-sum.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/minimum-size-subarray-sum/ 3 | * Tags: Sliding Window 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | int minSubArrayLen(int s, vector &nums) { 32 | int l = 0, r = 0, n = nums.size(), sum = 0, len = INT_MAX; 33 | while (r < n) { 34 | sum += nums[r++]; 35 | while (sum >= s) { 36 | len = min(len, r - l); 37 | sum -= nums[l++]; 38 | } 39 | } 40 | return len == INT_MAX ? 0 : len; 41 | } 42 | }; 43 | 44 | int main() { 45 | ios_base::sync_with_stdio(false); 46 | cin.tie(NULL); 47 | } 48 | -------------------------------------------------------------------------------- /lc/0210.course-schedule-ii.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func findOrder(numCourses int, prerequisites [][]int) []int { 4 | adj := make([][]int, numCourses) 5 | dgs := make([]int, numCourses) 6 | ans := []int{} 7 | flg := 0 8 | q := []int{} 9 | for _, value := range prerequisites { 10 | adj[value[1]] = append(adj[value[1]], value[0]) 11 | dgs[value[0]]++ 12 | } 13 | for key, value := range dgs { 14 | if value == 0 { 15 | q = append(q, key) 16 | } 17 | } 18 | for len(q) != 0 { 19 | flg++ 20 | cur := q[0] 21 | q = q[1:] 22 | ans = append(ans, cur) 23 | for _, value := range adj[cur] { 24 | dgs[value]-- 25 | if dgs[value] == 0 { 26 | q = append(q, value) 27 | } 28 | } 29 | } 30 | if flg != numCourses { 31 | return []int{} 32 | } 33 | return ans 34 | } 35 | -------------------------------------------------------------------------------- /lc/0215.kth-largest-element-in-an-array.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/kth-largest-element-in-an-array/ 3 | * Tags: Array 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | int findKthLargest(vector &nums, int k) { 32 | priority_queue, greater> minHeap; 33 | for (auto &c : nums) { 34 | minHeap.push(c); 35 | if (minHeap.size() > k) 36 | minHeap.pop(); 37 | } 38 | return minHeap.top(); 39 | } 40 | }; 41 | 42 | int main() { 43 | ios_base::sync_with_stdio(false); 44 | cin.tie(NULL); 45 | } 46 | -------------------------------------------------------------------------------- /lc/0216.combination-sum-iii.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | int sum; 28 | int m; 29 | vector> ans; 30 | void back(vector &d, int s, int c) { 31 | if (d.size() > m) 32 | return; 33 | if (c == sum && d.size() == m) { 34 | ans.push_back(d); 35 | return; 36 | } 37 | for (int i = s; i <= 9; i++) { 38 | d.push_back(i); 39 | back(d, i + 1, c + i); 40 | d.pop_back(); 41 | } 42 | } 43 | 44 | public: 45 | vector> combinationSum3(int k, int n) { 46 | sum = n, m = k; 47 | vector d; 48 | back(d, 1, 0); 49 | return ans; 50 | } 51 | }; 52 | -------------------------------------------------------------------------------- /lc/0217.contains-duplicate.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/contains-duplicate/ 3 | * Tags: Array 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | bool containsDuplicate(vector &nums) { 30 | unordered_map hashMap; 31 | for (auto iter = nums.begin(); iter != nums.end(); ++iter) { 32 | if (hashMap[*(iter)]++) 33 | return false; 34 | } 35 | return true; 36 | } 37 | 38 | int main() { 39 | ios_base::sync_with_stdio(false); 40 | cin.tie(NULL); 41 | } 42 | -------------------------------------------------------------------------------- /lc/0217.contains-duplicate.cs: -------------------------------------------------------------------------------- 1 | public class Solution 2 | { 3 | public bool ContainsDuplicate(int[] nums) 4 | { 5 | var d = new Dictionary(); 6 | foreach (int i in nums) 7 | { 8 | var o = false; 9 | d.TryGetValue(i, out o); 10 | if (o) 11 | return o; 12 | d.Add(i, true); 13 | } 14 | return false; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /lc/0226.invert-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | // struct TreeNode { 27 | // int val; 28 | // TreeNode *left; 29 | // TreeNode *right; 30 | // TreeNode() : val(0), left(nullptr), right(nullptr) {} 31 | // TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 32 | // TreeNode(int x, TreeNode *left, TreeNode *right) 33 | // : val(x), left(left), right(right) {} 34 | // }; 35 | class Solution { 36 | 37 | public: 38 | TreeNode *invertTree(TreeNode *root) { 39 | if (!root) 40 | return root; 41 | auto right = invertTree(root->right); 42 | auto left = invertTree(root->left); 43 | root->left = right; 44 | root->right = left; 45 | return root; 46 | } 47 | }; 48 | -------------------------------------------------------------------------------- /lc/0231_power-of-two.go: -------------------------------------------------------------------------------- 1 | func isPowerOfTwo(n int) bool { 2 | if n == 0 { 3 | return false 4 | } 5 | return n&(n-1) == 0 6 | } 7 | -------------------------------------------------------------------------------- /lc/0237.delete-node-in-a-linked-list.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | func deleteNode(node *ListNode) { 4 | prev := node 5 | node = node.Next 6 | for { 7 | prev.Val = node.Val 8 | node = node.Next 9 | if node == nil { 10 | prev.Next = nil 11 | break 12 | } 13 | prev = prev.Next 14 | } 15 | prev.Next = nil 16 | 17 | } 18 | -------------------------------------------------------------------------------- /lc/0239_sliding-window-maximum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | vector maxSlidingWindow(vector &nums, int k) { 29 | vector ans; 30 | map mp; 31 | int n = nums.size(); 32 | for (int i = k - 1; i >= 0; i--) { 33 | mp[nums[i]]++; 34 | } 35 | ans.push_back(mp.rbegin()->first); 36 | for (int i = k; i < n; i++) { 37 | mp[nums[i - k]]--; 38 | if (mp[nums[i - k]] <= 0) { 39 | auto it = mp.find(nums[i - k]); 40 | if (it != mp.end()) 41 | mp.erase(it); 42 | } 43 | mp[nums[i]]++; 44 | ans.push_back(mp.rbegin()->first); 45 | } 46 | return ans; 47 | } 48 | }; 49 | -------------------------------------------------------------------------------- /lc/0240.search-a-2d-matrix-ii.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/search-a-2d-matrix-ii/ 3 | * Tags: Binary Search 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | bool searchMatrix(vector> &matrix, int target) { 32 | int z = matrix.size(); 33 | for (int i = 0; i < z; i++) { 34 | if (binary_search(begend(matrix[i]), target)) 35 | return true; 36 | } 37 | return false; 38 | } 39 | }; 40 | 41 | int main() { 42 | ios_base::sync_with_stdio(false); 43 | cin.tie(NULL); 44 | } 45 | -------------------------------------------------------------------------------- /lc/0242.valid-anagram.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | bool isAnagram(string s, string t) { 29 | sort(begend(s)), sort(begend(t)); 30 | if (s == t) 31 | return true; 32 | return false; 33 | } 34 | }; 35 | -------------------------------------------------------------------------------- /lc/0242.valid-anagram.cs: -------------------------------------------------------------------------------- 1 | public class Solution 2 | { 3 | public bool IsAnagram(string s, string t) 4 | { 5 | if (s.Length != t.Length) 6 | return false; 7 | var d = new Dictionary(); 8 | 9 | for (int i = 0; i < s.Length; i++) 10 | { 11 | d.TryAdd(s[i], 0); 12 | d.TryAdd(t[i], 0); 13 | d[s[i]]++; 14 | d[t[i]]--; 15 | } 16 | foreach ((_, int i) in d) 17 | { 18 | if (i != 0) 19 | { 20 | return false; 21 | } 22 | } 23 | return true; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /lc/0257.binary-tree-paths.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | /** 4 | * Definition for a binary tree node. 5 | * struct TreeNode { 6 | * int val; 7 | * TreeNode *left; 8 | * TreeNode *right; 9 | * TreeNode() : val(0), left(nullptr), right(nullptr) {} 10 | * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 11 | * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), 12 | * right(right) {} 13 | * }; 14 | */ 15 | class Solution { 16 | public: 17 | void binaryTreePaths(vector &result, TreeNode *root, string t) { 18 | if (!root->left && !root->right) { 19 | result.push_back(t); 20 | return; 21 | } 22 | 23 | if (root->left) 24 | binaryTreePaths(result, root->left, 25 | t + "->" + to_string(root->left->val)); 26 | if (root->right) 27 | binaryTreePaths(result, root->right, 28 | t + "->" + to_string(root->right->val)); 29 | } 30 | 31 | vector binaryTreePaths(TreeNode *root) { 32 | vector result; 33 | if (!root) 34 | return result; 35 | 36 | binaryTreePaths(result, root, to_string(root->val)); 37 | return result; 38 | } 39 | }; 40 | -------------------------------------------------------------------------------- /lc/0274.h-index.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int hIndex(vector &cit) { 29 | sort(cit.begin(), cit.end()); 30 | int n = cit.size(), count = 0; 31 | for (int i = n - 1; i >= 0; i--) { 32 | if (n - i <= cit[i]) 33 | count++; 34 | } 35 | return count; 36 | } 37 | }; 38 | -------------------------------------------------------------------------------- /lc/0278.first-bad-version.cpp: -------------------------------------------------------------------------------- 1 | // The API isBadVersion is defined for you. 2 | // bool isBadVersion(int version); 3 | 4 | #include 5 | bool isBadVersion(int version); 6 | 7 | class Solution { 8 | public: 9 | int firstBadVersion(int n) { 10 | int starti = 1, startn = n; 11 | int m = -1; 12 | if (n == 1) 13 | return 1; 14 | while (starti <= startn) { 15 | m = starti + (startn - starti) / 2; 16 | bool isM = isBadVersion(m); 17 | if ((m == 1 && isM) || (isM && m == n)) { 18 | return m; 19 | } 20 | bool beforeM = isBadVersion(m - 1); 21 | if (isM && !beforeM) { 22 | return m; 23 | } 24 | if (isM && beforeM) { 25 | startn = m; 26 | continue; 27 | } 28 | starti = m + 1; 29 | } 30 | return m; 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /lc/0283.move-zeroes.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | void moveZeroes(vector &nums) { 29 | int i(0), n(nums.size()); 30 | while (i < n) { 31 | if (nums[i] != 0) { 32 | int t = i; 33 | int j = t - 1; 34 | while (j >= 0 && nums[j] == 0) { 35 | swap(nums[t], nums[j]); 36 | t--; 37 | j--; 38 | } 39 | } 40 | i++; 41 | } 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /lc/0287.find-the-duplicate-number.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/find-the-duplicate-number/ 3 | * Tags: Hashtable 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | int findDuplicate(vector &nums) { 29 | map e; 30 | for (auto &i : nums) { 31 | if (e[i]) 32 | return i; 33 | e[i] = true; 34 | } 35 | return 1; 36 | } 37 | int main() { 38 | ios_base::sync_with_stdio(false); 39 | cin.tie(NULL); 40 | } 41 | -------------------------------------------------------------------------------- /lc/0290.word-pattern.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import "strings" 4 | 5 | func wordPattern(pattern string, s string) bool { 6 | mp := map[rune]string{} 7 | rmp := map[string]rune{} 8 | 9 | lst := strings.Split(s, " ") 10 | 11 | if len(lst) != len(pattern) { 12 | return false 13 | } 14 | 15 | var i int 16 | for _, value := range lst { 17 | 18 | if v, ok := rmp[value]; ok && rune(pattern[i]) != v { 19 | return false 20 | } 21 | 22 | r := rune(pattern[i]) 23 | v, ok := mp[r] 24 | if ok && value != v { 25 | return false 26 | } 27 | mp[r] = value 28 | 29 | rmp[value] = r 30 | 31 | i++ 32 | } 33 | return true 34 | } 35 | -------------------------------------------------------------------------------- /lc/0299.bulls-and-cows.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | string getHint(string secret, string guess) { 29 | map mp; 30 | int c(0), b(0), n(guess.size()); 31 | for (auto &i : secret) { 32 | mp[i]++; 33 | } 34 | for (int i = 0; i < n; i++) { 35 | if (mp[guess[i]] && guess[i] == secret[i]) { 36 | mp[guess[i]]--; 37 | b++; 38 | } 39 | } 40 | 41 | for (int i = 0; i < n; i++) { 42 | if (mp[guess[i]] && guess[i] != secret[i]) { 43 | mp[guess[i]]--; 44 | c++; 45 | } 46 | } 47 | return to_string(b) + "A" + to_string(c) + "B"; 48 | } 49 | }; 50 | -------------------------------------------------------------------------------- /lc/0315.count-of-smaller-numbers-after-self.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | vector countSmaller(vector &nums) { 29 | vector ans(nums.size()); 30 | multiset mp; 31 | int n(nums.size()); 32 | int j(n - 1); 33 | for (int i = n - 1; i >= 0; i--, j--) { 34 | mp.insert(nums[i]); 35 | int k = distance(mp.begin(), mp.lower_bound(nums[i])); 36 | ans[j] = k; 37 | } 38 | return ans; 39 | } 40 | }; 41 | 42 | // int main() { 43 | // vector x{1, 2, 3, 3, 5}; 44 | // cout << (lower_bound(begend(x), 2) - begin(x)); 45 | // return 0; 46 | // } 47 | -------------------------------------------------------------------------------- /lc/0322.coin-change.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | unordered_map mp; 28 | 29 | public: 30 | int coinChange(vector &coins, int amount) { 31 | if (!amount) 32 | return 0; 33 | if (amount < 0) 34 | return -1; 35 | if (mp.count(amount)) { 36 | return mp[amount]; 37 | } 38 | int ans = -1; 39 | for (auto &i : coins) { 40 | int pans = coinChange(coins, amount - i); 41 | if (pans == -1) 42 | continue; 43 | int cand = pans + 1; 44 | if (ans == -1 || cand < ans) 45 | ans = cand; 46 | } 47 | mp[amount] = ans; 48 | return ans; 49 | } 50 | }; 51 | -------------------------------------------------------------------------------- /lc/0326.power-of-three.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/power-of-three/ 3 | * Tags: Math 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | class Solution { 31 | public: 32 | bool isPowerOfThree(int n) { 33 | if (n <= 0) 34 | return false; 35 | int d = int(log2(n) / log2(3)); 36 | return pow(3, d) == n; 37 | } 38 | }; 39 | 40 | int main() { 41 | ios_base::sync_with_stdio(false); 42 | cin.tie(NULL); 43 | int i = 10; 44 | auto k = 14.9; 45 | i = (int)k; 46 | std::cout << i << std::endl; 47 | } 48 | -------------------------------------------------------------------------------- /lc/0327.count-of-range-sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int countRangeSum(vector &nums, int lower, int upper) { 29 | int l(0), n(nums.size()), sum(0), r(0); 30 | while (l < r && r < n) { 31 | sum += nums[l]; 32 | } 33 | } 34 | }; 35 | r 36 | -------------------------------------------------------------------------------- /lc/0330.patching-array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int minPatches(vector &nums, int n) { 29 | long long res(0), i(0), rng(0), ln(nums.size()); 30 | while (rng < n) { 31 | if (i < ln && nums[i] <= rng + 1) { 32 | rng += nums[i]; 33 | i++; 34 | } else { 35 | res++; 36 | rng += rng + 1; 37 | } 38 | } 39 | return res; 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /lc/0334.increasing-triplet-subsequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | bool increasingTriplet(vector &nums) { 29 | int small = INT_MAX, max(INT_MAX); 30 | for (auto &i : nums) { 31 | if (i <= small) { 32 | small = i; 33 | } else if (i <= max) 34 | max = i; 35 | else 36 | return 1; 37 | } 38 | return 0; 39 | } 40 | }; 41 | -------------------------------------------------------------------------------- /lc/0347.top-k-frequent-elements.cs: -------------------------------------------------------------------------------- 1 | public class Solution 2 | { 3 | public int[] TopKFrequent(int[] nums, int k) { } 4 | } 5 | -------------------------------------------------------------------------------- /lc/0347.top-k-frequent-elements.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | ) 7 | 8 | func main() { 9 | m := map[string]int{"zz": 221, "eq": 11} 10 | for key, value := range m { 11 | fmt.Println(key, value) 12 | } 13 | } 14 | 15 | func topKFrequent(nums []int, k int) []int { 16 | mmm := map[int]int{} 17 | type dummy struct { 18 | value int 19 | key int 20 | } 21 | m := []dummy{} 22 | ans := make([]int, k) 23 | for _, value := range nums { 24 | mmm[value]++ 25 | } 26 | for key, value := range mmm { 27 | m = append(m, dummy{value, key}) 28 | } 29 | sort.Slice(m, func(i, j int) bool { return m[i].value < m[j].value }) 30 | for i := 0; i < k; i++ { 31 | ans[i] = m[i].key 32 | } 33 | return ans 34 | } 35 | -------------------------------------------------------------------------------- /lc/0349.intersection-of-two-arrays.cs: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public int[] Intersection(int[] nums1, int[] nums2) { 3 | return nums1.Where(x => nums2.Any(s => s == x)).Distinct().ToArray(); 4 | 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /lc/0350.intersection-of-two-arrays-ii.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector intersect(vector &nums1, vector &nums2) { 4 | sort(nums1.begin(), nums1.end()); 5 | sort(nums2.begin(), nums2.end()); 6 | nums1.erase(set_intersection(nums1.begin(), nums1.end(), nums2.begin(), 7 | nums2.end(), nums1.begin()), 8 | nums1.end()); 9 | return nums1; 10 | } 11 | }; 12 | -------------------------------------------------------------------------------- /lc/0373.find-k-pairs-with-smallest-sums.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | func kSmallestPairs(nums1 []int, nums2 []int, k int) [][]int { 4 | ans := [][]int{} 5 | for _, value := range nums1 { 6 | for _, value2 := range nums2 { 7 | ans = append(ans, []int{value, value2}) 8 | k-- 9 | if k == 0 { 10 | break 11 | } 12 | } 13 | if k == 0 { 14 | break 15 | } 16 | } 17 | return ans 18 | } 19 | -------------------------------------------------------------------------------- /lc/0378.kth-smallest-element-in-a-sorted-matrix.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #define begend(v) ((v).begin()), ((v).end()) 23 | #define sz(v) ((int)((v).size())) 24 | using namespace std; 25 | 26 | class Solution { 27 | public: 28 | int kthSmallest(vector> &matrix, int k) { 29 | priority_queue, greater> pq; 30 | for (auto &i : matrix) { 31 | for (auto &b : i) { 32 | pq.push(b); 33 | } 34 | } 35 | for (int i = 0; i < k - 1; i++) { 36 | pq.pop(); 37 | } 38 | return pq.top(); 39 | } 40 | }; 41 | -------------------------------------------------------------------------------- /lc/0387.first-unique-character-in-a-string.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public 3 | int firstUniqChar(String s) { 4 | HashMap count = new HashMap(); 5 | int n = s.length(); 6 | // build hash map : character and how often it appears 7 | for (int i = 0; i < n; i++) { 8 | char c = s.charAt(i); 9 | count.put(c, count.getOrDefault(c, 0) + 1); 10 | } 11 | 12 | // find the index 13 | for (int i = 0; i < n; i++) { 14 | if (count.get(s.charAt(i)) == 1) 15 | return i; 16 | } 17 | return -1; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /lc/0397.integer-replacement.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/integer-replacement/ 3 | * Tags: Dynamic Programming 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | int minI(long long int n, int ans = 0) { 32 | if (n == 1) 33 | return ans; 34 | if (n % 2 == 0) 35 | return minI(n / 2, ans + 1); 36 | else 37 | return min(minI(n + 1, ans + 1), minI(n - 1, ans + 1)); 38 | } 39 | 40 | int integerReplacement(int n) { return minI(n); } 41 | }; 42 | 43 | int main() { 44 | ios_base::sync_with_stdio(false); 45 | cin.tie(NULL); 46 | } 47 | -------------------------------------------------------------------------------- /lc/0404.sum-of-left-leaves.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func sumOfLeftLeaves(root *TreeNode) int { 10 | return solve(root, false) 11 | } 12 | 13 | func solve(root *TreeNode, left bool) int { 14 | if root == nil { 15 | return 0 16 | } 17 | if root.Left == nil && root.Right == nil && left { 18 | return root.Val 19 | } 20 | return solve(root.Left, true) + solve(root.Right, false) 21 | } 22 | -------------------------------------------------------------------------------- /lc/0412.fizz-buzz.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import "strconv" 4 | 5 | func fizzBuzz(n int) []string { 6 | arr := make([]string, n) 7 | for key, _ := range arr { 8 | tk := key + 1 9 | switch { 10 | case tk%3 == 0 && tk%5 == 0: 11 | arr[key] = "FizzBuzz" 12 | case tk%3 == 0: 13 | arr[key] = "Fizz" 14 | case tk%5 == 0: 15 | arr[key] = "Buzz" 16 | default: 17 | arr[key] = strconv.Itoa(tk) 18 | } 19 | } 20 | return arr 21 | } 22 | -------------------------------------------------------------------------------- /lc/0424_longest-repeating-character-replacement.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | func characterReplacement(s string, k int) int { 4 | ml, mc, l, r, f := 0, 0, 0, 0, map[byte]int{} 5 | 6 | for ; r < len(s); r++ { 7 | f[s[r]]++ 8 | if f[s[r]] > mc { 9 | mc = f[s[r]] 10 | } 11 | for r-l+1-mc > k { 12 | f[s[l]]-- 13 | l++ 14 | } 15 | if r-l+1 > ml { 16 | ml = r - l + 1 17 | } 18 | } 19 | return ml 20 | } 21 | -------------------------------------------------------------------------------- /lc/0441.arranging-coins.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int arrangeCoins(int n) { 29 | int base = 1; 30 | while (n >= base) { 31 | n -= base; 32 | base++; 33 | } 34 | return base - 1; 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /lc/0448.find-all-numbers-disappeared-in-an-array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | vector findDisappearedNumbers(vector &nums) { 29 | unordered_map m; 30 | for (auto &i : nums) { 31 | m[i] = 1; 32 | } 33 | vector ans; 34 | for (int i = 1; i <= nums.size(); i++) { 35 | if (!m[i]) { 36 | ans.push_back(i); 37 | } 38 | } 39 | return ans; 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /lc/0503.next-greater-element-ii.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | vector nextGreaterElements(vector &nums) { 29 | int n = nums.size(), m = nums[n - 1]; 30 | vector ans(n, -1); 31 | stack s; 32 | for (int i = 0; i < n * 2; i++) { 33 | while (s.size() && nums[i % n] > nums[s.top() % n]) { 34 | ans[s.top() % n] = nums[i % n]; 35 | s.pop(); 36 | } 37 | s.push(i % n); 38 | } 39 | return ans; 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /lc/0509.fibonacci-number.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | func fib(n int) int { 4 | if n == 0 { 5 | return 0 6 | } 7 | if n == 1 { 8 | return 1 9 | } 10 | return fib(n-1) + fib(n-2) 11 | } 12 | -------------------------------------------------------------------------------- /lc/0520.detect-capital.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import ( 4 | "strings" 5 | "unicode" 6 | ) 7 | 8 | func detectCapitalUse(word string) bool { 9 | up, down := strings.ToUpper(word), strings.ToLower(word) 10 | if word == up || word == down { 11 | return true 12 | } 13 | ts := string(unicode.ToUpper(rune(down[0]))) + down[1:] 14 | return ts == word 15 | } 16 | -------------------------------------------------------------------------------- /lc/0547.number-of-provinces.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/number-of-provinces/ 3 | * Tags: Graph 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | void dfs(vector> &g, vector &v, int index = 0) { 30 | v[index] = 1; 31 | for (int i = 0; i < g.size(); i++) { 32 | if (!v[g[index][i]]) 33 | dfs(g, v, i); 34 | } 35 | } 36 | 37 | int findCircleNum(vector> &isConnected) { 38 | int ans = 1; 39 | vector v(isConnected.size()); 40 | dfs(isConnected, v); 41 | for (int i = 0; i < v.size(); i++) { 42 | if (!v[i]) 43 | ans++, dfs(isConnected, v, i); 44 | } 45 | return ans; 46 | } 47 | 48 | int main() { 49 | ios_base::sync_with_stdio(false); 50 | cin.tie(NULL); 51 | } 52 | -------------------------------------------------------------------------------- /lc/0557.reverse-words-in-a-string-iii.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import "strings" 4 | 5 | func Reverse(s string) string { 6 | runes := []rune(s) 7 | for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 { 8 | runes[i], runes[j] = runes[j], runes[i] 9 | } 10 | return string(runes) 11 | } 12 | 13 | func reverseWords(s string) string { 14 | var ans strings.Builder 15 | words := strings.Split(s, " ") 16 | for key, _ := range words { 17 | if !strings.ContainsRune(words[key], ' ') { 18 | words[key] = Reverse(words[key]) 19 | } 20 | ans.WriteString(words[key]) 21 | ans.WriteRune(' ') 22 | } 23 | return ans.String()[:ans.Len()-1] 24 | } 25 | -------------------------------------------------------------------------------- /lc/0560.subarray-sum-equals-k.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int subarraySum(vector &nums, int k) { 29 | if (nums.size() == 1) { 30 | return nums[0] == k; 31 | } 32 | int ans(0), sum(0); 33 | map mp; 34 | mp[0] = 1; 35 | for (auto &i : nums) { 36 | sum += i; 37 | if (mp[sum - k]) 38 | ans += mp[sum - k]; 39 | mp[sum]++; 40 | } 41 | return ans; 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /lc/0565.array-nesting.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int arrayNesting(vector &nums) { 29 | if (!nums.size()) 30 | return 0; 31 | map mp; 32 | int ans(1), last(nums[0]); 33 | mp[last] = 1; 34 | while (1) { 35 | if (mp[nums[last]]) 36 | break; 37 | mp[nums[last]] = 1; 38 | last = nums[last]; 39 | ans++; 40 | } 41 | return ans; 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /lc/0605.can-place-flowers.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | bool canPlaceFlowers(vector &flowerbed, int n) { 29 | int z(0); 30 | for (int i = 0; i < flowerbed.size(); i++) { 31 | bool b = i > 0 ? flowerbed[i - 1] : 0; 32 | bool a = i <= n - 1 ? flowerbed[i + 1] : 0; 33 | 34 | if ((!b && !a) && !flowerbed[i]) { 35 | z++; 36 | flowerbed[i] = 1; 37 | } 38 | } 39 | cout << z << endl; 40 | 41 | for (auto i : flowerbed) { 42 | cout << i << endl; 43 | } 44 | return z >= n; 45 | } 46 | }; 47 | -------------------------------------------------------------------------------- /lc/0617.merge-two-binary-trees.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func mergeTrees(root1 *TreeNode, root2 *TreeNode) *TreeNode { 10 | if root1 == nil { 11 | return root2 12 | } 13 | if root2 == nil { 14 | return root1 15 | } 16 | root1.Val += root2.Val 17 | root1.Left = mergeTrees(root1.Left, root2.Left) 18 | root1.Right = mergeTrees(root1.Right, root2.Right) 19 | return root1 20 | } 21 | -------------------------------------------------------------------------------- /lc/0628.maximum-product-of-three-numbers.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/maximum-product-of-three-numbers/ 3 | * Tags: Math 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | int maximumproduct(vector &nums) { 31 | sort(begend(nums), greater<>()); 32 | int n = nums.size(); 33 | int x = nums[0] * nums[1] * nums[2]; 34 | return max(x, nums[0] * nums[n - 1] * nums[n - 2]); 35 | } 36 | 37 | int main() { 38 | ios_base::sync_with_stdio(false); 39 | vector i{-100, -98, -1, 2, 3, 4}; 40 | cout << maximumproduct(i); 41 | cin.tie(NULL); 42 | } 43 | -------------------------------------------------------------------------------- /lc/0637.average-of-levels-in-binary-tree.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | vector averageOfLevels(TreeNode *root) { 29 | vector ans; 30 | queue q; 31 | q.push(root); 32 | 33 | while (!q.empty()) { 34 | int n = q.size(); 35 | long long sum(0), count(0); 36 | while (n--) { 37 | auto v = q.front(); 38 | q.pop(); 39 | count++; 40 | sum += v->val; 41 | if (v->left) 42 | q.push(v->left); 43 | if (v->right) 44 | q.push(v->right); 45 | } 46 | ans.push_back((double)sum / count); 47 | } 48 | return ans; 49 | } 50 | }; 51 | -------------------------------------------------------------------------------- /lc/0650.2-keys-keyboard.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/lc/0650.2-keys-keyboard.cpp -------------------------------------------------------------------------------- /lc/0665.non-decreasing-array.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/non-decreasing-array/ 3 | * Tags: Array 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | bool checkPossibility(vector &nums) { 30 | int n = sz(nums); 31 | if (n == 1) 32 | return 1; 33 | int df = 0; 34 | int mf = 0; 35 | int mx = INT_MIN; 36 | for (int i = 1; i < n; i++) { 37 | if (nums[i] < nums[i - 1]) { 38 | df++; 39 | mx = nums[i - 1]; 40 | } 41 | if (mx > nums[i]) 42 | mf++; 43 | } 44 | return df == 1 && mf == 1; 45 | } 46 | 47 | int main() { 48 | ios_base::sync_with_stdio(false); 49 | cin.tie(NULL); 50 | vector i{1, 2, 3, 4}; 51 | cout << i[12233] << endl; 52 | cout << "WQ"; 53 | } 54 | -------------------------------------------------------------------------------- /lc/0680.valid-palindrome-ii.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | bool validPalindrome(string s) { 29 | int lo = 0, hi = s.size() - 1; 30 | return validPalindrome(s, lo, hi, 0); 31 | } 32 | 33 | bool validPalindrome(string &s, int lo, int hi, int count) { 34 | if (count > 1) 35 | return false; 36 | while (lo < hi) { 37 | if (s[lo] == s[hi]) { 38 | lo++; 39 | hi--; 40 | } else { 41 | return validPalindrome(s, lo + 1, hi, count + 1) || 42 | validPalindrome(s, lo, hi - 1, count + 1); 43 | } 44 | } 45 | return true; 46 | } 47 | }; 48 | -------------------------------------------------------------------------------- /lc/0692.top-k-frequent-words.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import ( 4 | "container/heap" 5 | ) 6 | 7 | func topKFrequent(words []string, k int) []string { 8 | h := heap 9 | } 10 | -------------------------------------------------------------------------------- /lc/0713.subarray-product-less-than-k.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/subarray-product-less-than-k/solution/ 3 | * Tags: Sliding Window 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | int numSubarrayProductLessThanK(vector &nums, int k) { 30 | 31 | int result = 0, n = nums.size(), sum = 0; 32 | for (int l = 0, r = 0; r < n; r++) { 33 | sum *= nums[r]; 34 | while (l <= r && !(sum < k)) { 35 | sum /= nums[l++]; 36 | } 37 | if (sum < k) 38 | result += r - l + 1; 39 | } 40 | return result; 41 | } 42 | 43 | int main() { 44 | ios_base::sync_with_stdio(false); 45 | cin.tie(NULL); 46 | } 47 | -------------------------------------------------------------------------------- /lc/0739.daily-temperatures.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | vector dailyTemperatures(vector &temperatures) { 29 | int n = temperatures.size(); 30 | vector ans(n, 0); 31 | stack sk; 32 | for (int i = n - 1; i >= 0; i--) { 33 | while (!sk.empty() && temperatures[sk.top()] <= temperatures[i]) { 34 | sk.pop(); 35 | } 36 | if (!sk.empty()) { 37 | ans[i] = sk.top() - i; 38 | } 39 | sk.push(i); 40 | } 41 | return ans; 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /lc/0763.partition-labels.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | vector partitionLabels(string s) { 29 | vector ans; 30 | map unique; 31 | map count; 32 | int zeros(0), size = 0; 33 | for (auto &i : s) 34 | count[i]++; 35 | 36 | for (int i = 0; i < s.size(); i++) { 37 | unique[s[i]] = 1, size++, count[s[i]]--; 38 | if (!count[s[i]]) 39 | zeros++; 40 | if (zeros == unique.size()) 41 | zeros = 0, unique.clear(), ans.push_back(size), size = 0; 42 | } 43 | 44 | return ans; 45 | } 46 | }; 47 | -------------------------------------------------------------------------------- /lc/0771.jewels-and-stones.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import "strings" 4 | 5 | func numJewelsInStones(jewels string, stones string) int { 6 | var ans int 7 | for _, value := range stones { 8 | if strings.ContainsRune(jewels, value) { 9 | ans++ 10 | } 11 | } 12 | return ans 13 | } 14 | -------------------------------------------------------------------------------- /lc/0781.rabbits-in-forest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int numRabbits(vector &answers) { 29 | int ans(0); 30 | unordered_map va; 31 | for (auto &i : answers) { 32 | if (!i) { 33 | ans++; 34 | continue; 35 | } 36 | if (!va[i]) { 37 | ans += i + 1; 38 | continue; 39 | } 40 | va[i]++; 41 | if (va[i] == i) { 42 | va[i] = 0; 43 | } 44 | } 45 | return ans; 46 | } 47 | }; 48 | -------------------------------------------------------------------------------- /lc/0797.all-paths-from-source-to-target.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/all-paths-from-source-to-target/ 3 | * Tags: DFS 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | vector> ans; 30 | int n, target; 31 | void solve(vector> graphs, vector way = {}, int index = 0) { 32 | way.push_back(index); 33 | if (index == target) 34 | ans.push_back(way); 35 | else { 36 | for (int node : graphs[index]) { 37 | solve(graphs, way, node); 38 | } 39 | } 40 | } 41 | 42 | vector> allPathsSourceTarget(vector> &graph) { 43 | 44 | return ans; 45 | } 46 | int main() { 47 | ios_base::sync_with_stdio(false); 48 | cin.tie(NULL); 49 | } 50 | -------------------------------------------------------------------------------- /lc/0811.subdomain-visit-count.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import ( 4 | "fmt" 5 | "strconv" 6 | "strings" 7 | "unicode" 8 | ) 9 | 10 | func subdomainVisits(cpdomains []string) []string { 11 | ans := []string{} 12 | fend := func(s int) (i int) { 13 | for _, c := range cpdomains[s] { 14 | if !unicode.IsDigit(c) { 15 | break 16 | } 17 | i++ 18 | } 19 | return i - 1 20 | } 21 | mp := map[string]int{} 22 | for i, _ := range cpdomains { 23 | end := fend(i) 24 | n, _ := strconv.Atoi(cpdomains[i][:end+1]) 25 | d := strings.Count(cpdomains[i], ".") 26 | mp[cpdomains[i][end+2:]] += n 27 | if d == 1 { 28 | mp[cpdomains[i][strings.Index(cpdomains[i], ".")+1:]] += n 29 | } else { 30 | dt := strings.Index(cpdomains[i], ".") 31 | mp[cpdomains[i][dt+1:]] += n 32 | dt2 := strings.Index(cpdomains[i][dt+1:], ".") 33 | mp[cpdomains[i][dt+1:][dt2+1:]] += n 34 | } 35 | } 36 | for key, value := range mp { 37 | ans = append(ans, fmt.Sprintf("%d %s", value, key)) 38 | 39 | } 40 | return ans 41 | } 42 | -------------------------------------------------------------------------------- /lc/0841.keys-and-rooms.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/keys-and-rooms/ 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | void DFS(vector> &graph, vector &v, int i) { 29 | v[i] = 1; 30 | for (auto &index : graph[i]) { 31 | if (!v[index]) 32 | DFS(graph, v, index); 33 | } 34 | } 35 | 36 | bool canVisitAllRooms(vector> &rooms) { 37 | vector visited(rooms.size()); 38 | DFS(rooms, visited, 0); 39 | return (find(begend(visited), false) == end(visited)); 40 | } 41 | 42 | int main() { 43 | ios_base::sync_with_stdio(false); 44 | cin.tie(NULL); 45 | } 46 | -------------------------------------------------------------------------------- /lc/0848.shifting-letters.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | string shiftingLetters(string s, vector &shifts) { 29 | long shift = 0; 30 | for (int i = s.size() - 1; i >= 0; i--) { 31 | s[i] = ((s[i] - 'a') + (shift + shifts[i]) % 26) % 26 + 'a'; 32 | shift += shifts[i]; 33 | } 34 | return s; 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /lc/0901.online-stock-span.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/online-stock-span/ 3 | * Tags: Stack 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | int main() { 30 | ios_base::sync_with_stdio(false); 31 | cin.tie(NULL); 32 | string i; 33 | } 34 | -------------------------------------------------------------------------------- /lc/0904.fruit-into-baskets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #define begend(v) ((v).begin()), ((v).end()) 20 | #define sz(v) ((int)((v).size())) 21 | using namespace std; 22 | typedef pair pi; 23 | priority_queue, greater> pq; 24 | 25 | class Solution { 26 | public: 27 | int totalFruit(vector &tree) { 28 | 29 | int n = tree.size(); 30 | unordered_map hm; 31 | 32 | int i = 0, j = 0, res = INT_MIN; 33 | for (i = 0; i < n; i++) { 34 | hm[tree[i]]++; 35 | 36 | while (j < n && hm.size() > 2) { 37 | hm[tree[j]]--; 38 | if (hm[tree[j]] == 0) 39 | hm.erase(tree[j]); 40 | j++; 41 | } 42 | res = max(res, i - j + 1); 43 | } 44 | 45 | return res == INT_MIN ? (hm.size() > 0 ? n : 0) : res; 46 | } 47 | }; 48 | -------------------------------------------------------------------------------- /lc/0912.sort-an-array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | int part(vector &arr, int s, int e) { 28 | int p = arr[e]; 29 | int i = s - 1; 30 | for (int j = s; j <= e - 1; j++) { 31 | if (p > arr[j]) { 32 | i++; 33 | swap(arr[j], arr[i]); 34 | } 35 | } 36 | swap(arr[i + 1], arr[e]); 37 | return i + 1; 38 | } 39 | void srt(vector &arr, int s, int e) { 40 | if (s < e) { 41 | int p = part(arr, s, e); 42 | srt(arr, s, p - 1); 43 | srt(arr, p + 1, e); 44 | } 45 | } 46 | 47 | public: 48 | vector sortArray(vector &nums) { 49 | srt(nums, 0, nums.size() - 1); 50 | return nums; 51 | } 52 | }; 53 | -------------------------------------------------------------------------------- /lc/0912.sort-an-array.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func part(arr []int, low, high int) ([]int, int) { 4 | pivout, i := arr[high], low 5 | for j := low; j < high; j++ { 6 | if arr[j] < pivout { 7 | arr[i], arr[j] = arr[j], arr[i] 8 | i++ 9 | } 10 | } 11 | arr[i], arr[high] = arr[high], arr[i] 12 | return arr, i 13 | } 14 | 15 | func q(arr []int, l, h int) []int { 16 | if l < h { 17 | arr, p := part(arr, l, h) 18 | arr = q(arr, l, p-1) 19 | arr = q(arr, p+1, h) 20 | } 21 | return arr 22 | } 23 | 24 | func sortArray(nums []int) []int { 25 | return q(nums, 0, len(nums)-1) 26 | } 27 | -------------------------------------------------------------------------------- /lc/0915.partition-array-into-disjoint-intervals.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int partitionDisjoint(int[] a) { 3 | int localMax = a[0], partitionIdx = 0, max = localMax; 4 | for (int i = 1; i < a.length; i++) 5 | if (localMax > a[i]) { 6 | localMax = max; 7 | partitionIdx = i; 8 | } else max = Math.max(max, a[i]); 9 | return partitionIdx + 1; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /lc/0931.minimum-falling-path-sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int minFallingPathSum(vector> &matrix) { 29 | for (int i = 1; i < matrix.size(); i++) { 30 | for (int j = 0; j < matrix.size(); j++) { 31 | matrix[i][j] += 32 | min({matrix[i - 1][max(j - 1, 0)], matrix[i - 1][j], 33 | matrix[i - 1][min((int)matrix.size() - 1, j + 1)]}); 34 | } 35 | } 36 | return *min_element(begend(matrix[matrix.size() - 1])); 37 | } 38 | }; 39 | -------------------------------------------------------------------------------- /lc/0944.delete-columns-to-make-sorted.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int minDeletionSize(vector &strs) { 29 | int n = strs.size(), m = strs[0].size(), ans = 0; 30 | vector d; 31 | for (int j = 0; j < m; j++) { 32 | for (int i = 1; i < n; i++) { 33 | if (strs[i][j] < strs[i - 1][j]) { 34 | ans++; 35 | break; 36 | } 37 | } 38 | } 39 | return ans; 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /lc/0978.longest-turbulent-subarray.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | // 9,4,2,10,7,8,8,1,9 27 | // 0 1 2 3 4 5 6 7 8 28 | 29 | class Solution { 30 | public: 31 | int maxTurbulenceSize(vector &arr) { 32 | int n = arr.size(); 33 | int ans(0), l(0), r(1); 34 | while (r < n - 1) { 35 | while (r < n - 1 && (arr[r - 1] > arr[r] < arr[r + 1] || 36 | arr[r - 1] arr[r + 1])) 37 | r++; 38 | while (l < r && arr[l] == arr[l + 1]) 39 | l++; 40 | ans = (r - l + 1) > ans ? (r - l + 1) : ans; 41 | l = r; 42 | r++; 43 | } 44 | return ans; 45 | } 46 | }; 47 | -------------------------------------------------------------------------------- /lc/0983.minimum-cost-for-tickets.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/lc/0983.minimum-cost-for-tickets.cpp -------------------------------------------------------------------------------- /lc/1004.max-consecutive-ones-iii.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int longestOnes(vector &nums, int k) { 29 | int n = nums.size(), j(0), ans(-1), c(0); 30 | bool z = 1; 31 | for (int i = 0; i < n; i++) { 32 | if (!nums[i]) 33 | c++; 34 | else 35 | z = 0; 36 | while (c > k && j < n) { 37 | if (!nums[j]) 38 | c--; 39 | j++; 40 | } 41 | ans = i - j + 1 > ans ? i - j + 1 : ans; 42 | } 43 | return ans == -1 ? nums.size() : ans; 44 | } 45 | }; 46 | -------------------------------------------------------------------------------- /lc/1108.defanging-an-ip-address.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import "strings" 4 | 5 | func defangIPaddr(address string) string { 6 | sl := strings.Split(address, ".") 7 | b := strings.Builder{} 8 | for _, value := range sl { 9 | b.WriteString(value) 10 | b.WriteString("[.]") 11 | } 12 | return b.String()[:len(b.String())-3] 13 | } 14 | -------------------------------------------------------------------------------- /lc/1189.maximum-number-of-balloons.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int maxNumberOfBalloons(string text) { 29 | map mp; 30 | string b = "balloon"; 31 | int ans(0); 32 | for (auto &i : text) { 33 | mp[i]++; 34 | } 35 | while (1) { 36 | for (auto &i : b) { 37 | if (mp[i] <= 0) { 38 | return ans; 39 | } 40 | mp[i]--; 41 | } 42 | ans++; 43 | } 44 | return ans; 45 | } 46 | }; 47 | -------------------------------------------------------------------------------- /lc/1315.sum-of-nodes-with-even-valued-grandparent.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import "math" 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | func sumEvenGrandparent(root *TreeNode) int { 12 | if root == nil { 13 | return 0 14 | } 15 | var s int 16 | if root.Val%2 == 0 { 17 | if root.Left != nil { 18 | 19 | if root.Left.Left != nil { 20 | s += root.Left.Left.Val 21 | } 22 | 23 | if root.Left.Right != nil { 24 | s += root.Left.Right.Val 25 | } 26 | 27 | } 28 | if root.Right != nil { 29 | if root.Right.Left != nil { 30 | s += root.Right.Left.Val 31 | } 32 | 33 | if root.Right.Right != nil { 34 | s += root.Right.Right.Val 35 | } 36 | 37 | } 38 | 39 | } 40 | s += sumEvenGrandparent(root.Left) + sumEvenGrandparent(root.Right) 41 | return s 42 | } 43 | -------------------------------------------------------------------------------- /lc/1333.filter-restaurants-by-vegan-friendly-price-and-distance.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | ) 7 | 8 | func filterRestaurants(restaurants [][]int, veganFriendly int, maxPrice int, maxDistance int) []int { 9 | ans := []int{} 10 | for key, value := range restaurants { 11 | if (veganFriendly == 1 && value[2] != veganFriendly) || value[4] > maxDistance || value[3] > maxPrice { 12 | restaurants[key][1] = -1 13 | } 14 | } 15 | 16 | // fmt.Println(restaurants) 17 | sort.Slice(restaurants, func(i, j int) bool { 18 | if restaurants[i][1] == restaurants[j][1] { 19 | return restaurants[i][0] > restaurants[j][0] 20 | } 21 | 22 | return restaurants[i][1] > restaurants[j][1] 23 | }) 24 | for _, value := range restaurants { 25 | if value[1] == -1 { 26 | break 27 | } 28 | ans = append(ans, value[0]) 29 | } 30 | return ans 31 | } 32 | -------------------------------------------------------------------------------- /lc/1358.number-of-substrings-containing-all-three-characters.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int numberOfSubstrings(string s) { 29 | int ans(0), n(s.size()), t(0); 30 | unordered_map mp; 31 | for (int i = 0, j = 0; i < n; i++) { 32 | mp[s[i]]++; 33 | while (j < n && mp['a'] && mp['b'] && mp['c']) { 34 | t++; 35 | mp[s[j]]--; 36 | j++; 37 | } 38 | ans += t; 39 | } 40 | return ans; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /lc/1360_number-of-days-between-two-dates.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import ( 4 | "math" 5 | "time" 6 | ) 7 | 8 | func daysBetweenDates(date1 string, date2 string) int { 9 | l := "2006-01-02" 10 | s, _ := time.Parse(l, date1) 11 | e, _ := time.Parse(l, date2) 12 | return int(math.Abs(float64(e.Sub(s).Hours() / 24))) 13 | } 14 | -------------------------------------------------------------------------------- /lc/1361.validate-binary-tree-nodes.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | bool vldiate(vector &visited, int i, vector &left, 31 | vector right) { 32 | if (i == -1) 33 | return true; 34 | if (visited[i]) 35 | return false; 36 | visited[i] = true; 37 | return vldiate(visited, left[i], left, right) && 38 | vldiate(visited, right[i], left, right); 39 | } 40 | 41 | public: 42 | bool validateBinaryTreeNodes(int n, vector &leftChild, 43 | vector &rightChild) { 44 | vector visited(n, false); 45 | return vldiate(visited, 0, leftChild, rightChild); 46 | } 47 | }; 48 | -------------------------------------------------------------------------------- /lc/1405.longest-happy-string.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import ( 4 | "sort" 5 | "strings" 6 | ) 7 | 8 | func longestDiverseString(a int, b int, c int) string { 9 | ans := strings.Builder{} 10 | lst := make([]struct { 11 | int 12 | rune 13 | }, 3) 14 | lst[0].rune, lst[0].int = 'a', a 15 | lst[1].rune, lst[1].int = 'b', b 16 | lst[2].rune, lst[2].int = 'c', c 17 | 18 | toadd := 2 19 | added := lst[toadd] 20 | added.int = 0 21 | for { 22 | if toadd < 0 { 23 | return ans.String() 24 | } 25 | 26 | if added.int == 2 { 27 | if toadd >= 1 && lst[toadd-1].int > 0 { 28 | lst[toadd-1].int-- 29 | ans.WriteRune(lst[(toadd - 1)].rune) 30 | added.int = 0 31 | } else if toadd >= 2 && lst[toadd-2].int > 0 { 32 | lst[(toadd-2)].int-- 33 | ans.WriteRune(lst[toadd-2].rune) 34 | added.int = 0 35 | } else { 36 | return ans.String() 37 | } 38 | continue 39 | } 40 | if lst[toadd].int == 0 { 41 | toadd-- 42 | if toadd >= 0 { 43 | added = lst[toadd] 44 | if ans.String()[ans.Len()-1] == byte(added.rune) { 45 | added.int = 1 46 | } else { 47 | added.int = 0 48 | } 49 | } 50 | continue 51 | } 52 | ans.WriteRune(lst[toadd].rune) 53 | added.int++ 54 | lst[toadd].int-- 55 | 56 | } 57 | return ans.String() 58 | } 59 | -------------------------------------------------------------------------------- /lc/1447.simplified-fractions.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import "strconv" 4 | 5 | func simplifiedFractions(n int) []string { 6 | var de, ne, nn float64 = 1, 2, float64(n) 7 | var ans []string 8 | mp := map[float64]bool{} 9 | for ne <= nn { 10 | if de >= ne { 11 | de, ne = 1, ne+1 12 | continue 13 | } 14 | if !mp[(de / ne)] { 15 | mp[(de / ne)] = true 16 | ans = append(ans, trns(de, ne)) 17 | } 18 | de++ 19 | } 20 | return ans 21 | } 22 | 23 | func trns(d, n float64) string { 24 | return strconv.Itoa(int(d)) + "/" + strconv.Itoa(int(n)) 25 | } 26 | -------------------------------------------------------------------------------- /lc/1480.running-sum-of-1d-array.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func runningSum(nums []int) []int { 8 | var t, n = 0, len(nums) 9 | ans := make([]int, n) 10 | for i := 0; i < n; i++ { 11 | t += nums[i] 12 | ans[i] = t 13 | } 14 | return ans 15 | } 16 | -------------------------------------------------------------------------------- /lc/1523.count-odd-numbers-in-an-interval-range.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * https://leetcode.com/problems/count-odd-numbers-in-an-interval-range/ Tags: 4 | * Numbers 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | class Solution { 30 | public: 31 | int countOdds(int low, int high) { return (high + 1) / 2 - low / 2; } 32 | }; 33 | int main() { 34 | ios_base::sync_with_stdio(false); 35 | cin.tie(NULL); 36 | } 37 | -------------------------------------------------------------------------------- /lc/1557.minimum-number-of-vertices-to-reach-all-nodes.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * https://leetcode.com/problems/minimum-number-of-vertices-to-reach-all-nodes/ 4 | * Tags: Graphs 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | vector findSmallestSetOfVertices(int n, vector> &edges) { 31 | vector res, in(n); 32 | for (auto edge : edges) 33 | in[edge[1]]++; 34 | for (int i = 0; i != n; ++i) 35 | if (in[i] == 0) 36 | res.push_back(i); 37 | return res; 38 | } 39 | 40 | int main() { 41 | ios_base::sync_with_stdio(false); 42 | cin.tie(NULL); 43 | } 44 | -------------------------------------------------------------------------------- /lc/1662_check-if-two-string-arrays-are-equivalent.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func arrayStringsAreEqual(word1 []string, word2 []string) bool { 4 | var s1, s2 string 5 | for _, v := range word2 { 6 | s2 += v 7 | } 8 | 9 | for _, v := range word1 { 10 | s1 += v 11 | } 12 | return s1 == s2 13 | } 14 | -------------------------------------------------------------------------------- /lc/1685.sum-of-absolute-differences-in-a-sorted-array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | vector getSumAbsoluteDifferences(vector &nums) { 29 | vector ans; 30 | int p(0); 31 | for (auto &i : nums) 32 | p += i; 33 | int n = nums.size(); 34 | int prv = 0; 35 | int ns(p), ps(0), nns(n), nps(0); 36 | for (int i = 0; i < n; i++) { 37 | ns -= nums[i]; 38 | nns--; 39 | 40 | int j = abs(ns - (nums[i] * nns)) + abs(ps - (nums[i] * nps)); 41 | ans.push_back(j); 42 | ps += nums[i]; 43 | nps++; 44 | } 45 | return ans; 46 | } 47 | }; 48 | -------------------------------------------------------------------------------- /lc/1748.sum-of-unique-elements.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int sumOfUnique(vector &nums) { 29 | unordered_map mp; 30 | for (auto &i : nums) { 31 | mp[i]++; 32 | } 33 | int ans(0); 34 | for (auto &i : mp) { 35 | if (i.second == 1) 36 | ans += i.first; 37 | } 38 | return ans; 39 | } 40 | }; 41 | -------------------------------------------------------------------------------- /lc/1859.sorting-the-sentence.cs: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public string SortSentence(string s) { 3 | var ss = s.Split(' ').OrderBy(x => x[^1]).Select(x => x.Replace(x[^1].ToString(), string.Empty)); 4 | return string.Join(" ", ss.ToArray()); 5 | 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /lc/1894.find-the-student-that-will-replace-the-chalk.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func chalkReplacer(chalk []int, k int) int { 4 | var sum, cs, lk int64 5 | var res int 6 | var rk int64 = int64(k) 7 | for _, v := range chalk { 8 | sum += int64(v) 9 | } 10 | lk = rk % sum 11 | for i, v := range chalk { 12 | cs += int64(v) 13 | if cs > lk { 14 | res = i 15 | break 16 | } 17 | } 18 | return res 19 | 20 | } 21 | -------------------------------------------------------------------------------- /lc/1913_maximum-product-difference-between-two-pairs.go: -------------------------------------------------------------------------------- 1 | // package lc 2 | 3 | import "sort" 4 | 5 | func maxProductDifference(nums []int) int { 6 | n := len(nums) 7 | sort.Ints(nums) 8 | return nums[n-1]*nums[n-2] - nums[0]*nums[1] 9 | } 10 | -------------------------------------------------------------------------------- /lc/1920.build-array-from-permutation.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | fmt.Println("12", "14", "51") 9 | 10 | } 11 | 12 | func buildArray(nums []int) []int { 13 | ans := make([]int, len(nums)) 14 | for i := 0; i < len(nums); i++ { 15 | ans[i] = nums[nums[i]] 16 | } 17 | return ans 18 | } 19 | -------------------------------------------------------------------------------- /lc/1929.concatenation-of-array.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func getConcatenation(nums []int) []int { 8 | return append(nums, nums...) 9 | 10 | } 11 | -------------------------------------------------------------------------------- /lc/1946.largest-number-after-mutating-substring.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func maximumNumber(num string, change []int) string { 4 | runes, cont := []rune(num), false 5 | for i, v := range runes { 6 | c := int(v - '0') 7 | if c < change[c] { 8 | runes[i] = rune(change[c] + '0') 9 | cont = true 10 | } else if c == change[c] && cont { 11 | cont = true 12 | } else if cont { 13 | break 14 | } 15 | } 16 | return string(runes) 17 | } 18 | -------------------------------------------------------------------------------- /lc/1991_find-the-middle-index-in-array.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int findMiddleIndex(vector &nums) { 29 | int sum1(0), sum2(0), n(nums.size()); 30 | for (auto &i : nums) { 31 | sum1 += i; 32 | } 33 | for (int i = 0; i < n; i++) { 34 | sum1 -= nums[i]; 35 | if (sum1 == sum2) { 36 | return i; 37 | } 38 | sum2 += nums[i]; 39 | } 40 | return -1; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /lc/2099.find-subsequence-of-length-k-with-the-largest-sum.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | vector maxSubsequence(vector &nums, int k) { 32 | int p1 = 0, p2 = k, n = nums.size(); 33 | map mp; 34 | for (; p2 < n; p2 += k) { 35 | int sum = 0, t = p1; 36 | while (p1 <= p2) { 37 | sum += nums[p1], p1++; 38 | } 39 | mp[t] = sum; 40 | } 41 | auto m = max_element(begend(mp))->first; 42 | return vector(nums.begin() + m, nums.begin() + m + k); 43 | } 44 | }; 45 | 46 | int main() { 47 | ios_base::sync_with_stdio(false); 48 | cin.tie(NULL); 49 | } 50 | -------------------------------------------------------------------------------- /lc/2108.find-first-palindromic-string-in-the-array.cs: -------------------------------------------------------------------------------- 1 | public class Solution 2 | 3 | { 4 | public string FirstPalindrome(string[] words) 5 | { 6 | va r i = words.FirstOrDefault(x => new string(x.Reverse().ToArray()) == x); 7 | if (i is null) return ""; 8 | return i; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /lc/2169.count-operations-to-obtain-zero.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * https://leetcode.com/contest/weekly-contest-280/problems/count-operations-to-obtain-zero/ 4 | * Tags: Numbers 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | int main() { 31 | ios_base::sync_with_stdio(false); 32 | cin.tie(NULL); 33 | int num1 = 10, num2 = 10; 34 | int op = 0; 35 | while (num1 != 0 && num2 != 0) { 36 | if (num1 >= num2) { 37 | num1 -= num2; 38 | op++; 39 | } else { 40 | num2 -= num1; 41 | op++; 42 | } 43 | } 44 | cout << op << endl; 45 | return op; 46 | } 47 | -------------------------------------------------------------------------------- /lc/2170.minimum-operations-to-make-the-array-alternating.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/lc/2170.minimum-operations-to-make-the-array-alternating.cpp -------------------------------------------------------------------------------- /lc/2185.counting-words-with-a-given-prefix.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import "strings" 4 | 5 | func prefixCount(words []string, pref string) int { 6 | var ans int 7 | for _, w := range words { 8 | if strings.HasPrefix(w, pref) { 9 | ans++; 10 | } 11 | } 12 | return ans 13 | } 14 | -------------------------------------------------------------------------------- /lc/2195.append-k-integers-with-minimal-sum.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func minimalKSum(nums []int, k int) int64 { 4 | sum := int64((k * (k + 1)) / 2) 5 | 6 | for _, value := range nums { 7 | if value <= k { 8 | sum -= int64(value) 9 | sum += int64(k + 1) 10 | k = k + 1 11 | } 12 | } 13 | return sum 14 | } 15 | -------------------------------------------------------------------------------- /lc/2216.minimum-deletions-to-make-array-beautiful.cpp: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | * Problem: 4 | * https://leetcode.com/problems/minimum-deletions-to-make-array-beautiful/ 5 | * Tags: Greedy 6 | */ 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #define begend(v) ((v).begin()), ((v).end()) 28 | #define sz(v) ((int)((v).size())) 29 | using namespace std; 30 | 31 | class Solution { 32 | public: 33 | int minDeletion(vector &nums) { 34 | int shift = 0; 35 | for (int i = 0; i < nums.size() - 1; i++) { 36 | if ((i + shift) % 2 == 0) { 37 | if (nums[i] == nums[i + 1]) { 38 | shift++; 39 | } 40 | } 41 | } 42 | if ((nums.size() - shift) % 2 == 1) { 43 | shift++; 44 | } 45 | return shift; 46 | } 47 | }; 48 | int main() { 49 | vector l{1, 1, 1}; 50 | cout << (l[2] == l[3]); 51 | } 52 | -------------------------------------------------------------------------------- /lc/2231.largest-number-after-digit-swaps-by-parity.cs: -------------------------------------------------------------------------------- 1 | public class Solution 2 | { 3 | private static int swaping(string n) 4 | { 5 | var odd = n.Where(x => int.Parse(x.ToString()) % 2 != 0).Select(x => 6 | int.Parse(x.ToString())).OrderBy(x => x).ToList(); var even = n.Where(x => 7 | int.Parse(x.ToString()) % 2 == 0).Select(x => int.Parse(x.ToString())).OrderBy(x => 8 | x).ToList(); 9 | var r = new StringBuilder(); 10 | foreach (var c in n) 11 | { 12 | if (int.Parse(c.ToString()) % 2 == 0) 13 | { 14 | int i = even.Count - 1; 15 | r.Append(even[i]); 16 | even.RemoveAt(i); 17 | } 18 | else 19 | { 20 | int i = odd.Count - 1; 21 | r.Append(odd[i]); 22 | odd.RemoveAt(i); 23 | } 24 | } 25 | return int.Parse(r.ToString()); 26 | } 27 | public int LargestInteger(int num) 28 | { 29 | var s = num.ToString(); 30 | return swaping(s); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /lc/2232.minimize-result-by-adding-parentheses-to-expression.cs: -------------------------------------------------------------------------------- 1 | public class Solution 2 | 3 | { 4 | 5 | public string MinimizeResult(string expression) 6 | { 7 | var map = new Dictionary(); 8 | string[] exps = expression.Split("+"); 9 | 10 | 11 | for (int i = 0; i < exps[0].Length; i++) 12 | { 13 | int aAdd = int.Parse(exps[0].Substring(i)); 14 | string aMultStr = exps[0].Substring(0, i) 15 | ; 16 | int aMult = aMultStr.Length == 0 ? 1 : int.Parse(aMultStr); 17 | 18 | for (int j = 1; j <= exps[1].Length; j++) 19 | { 20 | int bAdd = int.Parse(exps[1].Substring(0, j)); 21 | string bMultStr = exps[1].Substring(j); 22 | int bMult = bMultStr.Length == 0 ? 1 : int.Parse(bMultStr); 23 | 24 | string key = aMultStr + "(" + aAdd + "+" + bAdd + ")" + bMultStr; 25 | map[key] = aAdd + bAdd; 26 | map[key] *= aMult; 27 | map[key] *= bMult; 28 | } 29 | } 30 | 31 | return map.MinBy(r => r.Value).Key; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /lc/2233.maximum-product-after-k-increments.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/maximum-product-after-k-increments/ 3 | * Tags: array 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #define begend(v) ((v).begin()), ((v).end()) 28 | #define sz(v) ((int)((v).size())) 29 | using namespace std; 30 | 31 | int maximumProduct(vector &nums, int k) { 32 | int mod = pow(10, 9) + 7; 33 | 34 | while (k) { 35 | int m = min_element(begend(nums)) - nums.begin(); 36 | nums[m]++; 37 | k--; 38 | } 39 | long long r = 1; 40 | for (auto &rk : nums) { 41 | r = (r * rk) % mod; 42 | } 43 | return r; 44 | } 45 | int main() { 46 | vector t = {6, 3, 3, 2}; 47 | cout << maximumProduct(t, 2); 48 | } 49 | -------------------------------------------------------------------------------- /lc/2235.add-two-integers.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | fmt.Print("hi..") 9 | } 10 | 11 | func sum(num1 int, num2 int) int { 12 | return num1 + num2 13 | } 14 | -------------------------------------------------------------------------------- /lc/2244.minimum-rounds-to-complete-all-tasks.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int minimumRounds(vector &tasks) { 29 | int ans(0); 30 | unordered_map c; 31 | for (auto &ii : tasks) { 32 | c[ii]++; 33 | } 34 | 35 | for (auto cc : c) { 36 | if (cc.second == 1) 37 | return -1; 38 | else if (cc.second % 3 == 0) { 39 | ans += cc.second / 3; 40 | } else { 41 | ans += cc.second / 3 + 1; 42 | } 43 | } 44 | return ans; 45 | } 46 | }; 47 | -------------------------------------------------------------------------------- /lc/2260.minimum-consecutive-cards-to-pick-up.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/minimum-consecutive-cards-to-pick-up/ 3 | * Tags: Sliding Window 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | int minimumCardPickup(vector &cards) { 29 | map mp; 30 | int min = INT_MAX, n = cards.size(); 31 | for (int l = 0, r = 0; r < cards.size(); r++) { 32 | if (mp.count(cards[r])) { 33 | int rs = r - mp[cards[r]] + 1; 34 | min = min > rs ? rs : min; 35 | } 36 | mp[cards[r]] = r; 37 | } 38 | return min == INT_MAX ? -1 : min; 39 | } 40 | int main() { 41 | vector r = {1, 0, 5, 3}; 42 | cout << minimumCardPickup(r); 43 | } 44 | -------------------------------------------------------------------------------- /lc/2265.count-nodes-equal-to-average-of-subtree.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | var ans int 10 | 11 | func solve(root *TreeNode) (sum, cnt int) { 12 | if root == nil { 13 | return 14 | } 15 | lsum, lcnt := solve(root.Left) 16 | rsum, rcnt := solve(root.Right) 17 | sum = lsum + rsum + root.Val 18 | cnt = lcnt + rcnt + 1 19 | if root.Val == sum/cnt { 20 | ans++ 21 | } 22 | return 23 | 24 | } 25 | 26 | func averageOfSubtree(root *TreeNode) int { 27 | ans = 0 28 | solve(root) 29 | return ans 30 | } 31 | -------------------------------------------------------------------------------- /lc/2269.find-the-k-beauty-of-a-number.cs: -------------------------------------------------------------------------------- 1 | public class Solution { 2 | public int DivisorSubstrings(int num, int k) { 3 | 4 | int count = 0, i = 0; 5 | string numText = num.ToString(); 6 | 7 | while(i + k <= numText.Length) 8 | { 9 | int divisor = int.Parse(numText.Substring(i, k)); 10 | 11 | if(divisor > 0 && num % divisor == 0) 12 | count++; 13 | 14 | i++; 15 | } 16 | 17 | return count; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /lc/2287.rearrange-characters-to-make-target-string.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | using namespace std; 20 | #include 21 | #define begend(v) ((v).begin()), ((v).end()) 22 | #define sz(v) ((int)((v).size())) 23 | using namespace std; 24 | 25 | int main() { 26 | ios_base::sync_with_stdio(false); 27 | cin.tie(NULL); 28 | } 29 | 30 | int rearrangeCharacters(string s, string target) { 31 | map mfr, dfr; 32 | int ins = INT_MAX; 33 | if (!s.length()) 34 | return 0; 35 | for (auto &i : s) { 36 | mfr[i]++; 37 | } 38 | for (auto &i : target) { 39 | dfr[i]++; 40 | } 41 | for (auto &i : target) { 42 | ins = min(ins, (mfr[i] - dfr[i] < 0 ? 0 : mfr[i] - dfr[i])); 43 | } 44 | return ins; 45 | } 46 | -------------------------------------------------------------------------------- /lc/2302.count-subarrays-with-score-less-than-k.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * https://leetcode.com/problems/count-subarrays-with-score-less-than-k/ Tags: 4 | * Array, Slinding Window 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | long long countSubarrays(vector &nums, long long k) { 30 | long long result = 0, n = nums.size(), sum = 0; 31 | for (int l = 0, r = 0; r < n; r++) { 32 | sum += nums[r]; 33 | auto vk = sum * (r - l + 1); 34 | while (l <= r && !(vk < k)) { 35 | sum -= nums[l++]; 36 | vk = sum * (r - l + 1); 37 | } 38 | if (vk < k) 39 | result += r - l + 1; 40 | } 41 | return result; 42 | } 43 | 44 | int main() { 45 | ios_base::sync_with_stdio(false); 46 | cin.tie(NULL); 47 | } 48 | -------------------------------------------------------------------------------- /lc/2309.greatest-english-letter-in-upper-and-lower-case.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * https://leetcode.com/contest/weekly-contest-298/problems/greatest-english-letter-in-upper-and-lower-case/ 4 | * Tags: Strings 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | #define begend(v) ((v).begin()), ((v).end()) 29 | #define sz(v) ((int)((v).size())) 30 | using namespace std; 31 | 32 | string greatestLetter(string s) { 33 | string p = "", r = ""; 34 | map lr, up; 35 | for (auto &k : s) { 36 | if (islower(k)) 37 | lr[k] = true; 38 | else 39 | up[k] = true; 40 | if (lr[tolower(k)] && up[toupper(k)]) 41 | p += toupper(k); 42 | } 43 | sort(begend(p)); 44 | if (p.size() == 0) 45 | return ""; 46 | r += p[p.size() - 1]; 47 | return r; 48 | } 49 | 50 | int main() { cout << greatestLetter("arRAzFif"); } 51 | -------------------------------------------------------------------------------- /lc/2315.count-asterisks.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://leetcode.com/problems/count-asterisks/ 3 | * Tags: String 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | int countAsterisks(string s) { 30 | int rs; 31 | bool f; 32 | for (auto &i : s) { 33 | if (i == '|') 34 | f = !f; 35 | if (!f && i == '*') 36 | rs++; 37 | } 38 | return rs; 39 | } 40 | 41 | int main() { 42 | ios_base::sync_with_stdio(false); 43 | cin.tie(NULL); 44 | } 45 | -------------------------------------------------------------------------------- /lc/2319.check-if-matrix-is-x-matrix.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | bool checkXMatrix(vector> &grid) { 29 | int ni = grid.size(), nj = grid[0].size(); 30 | for (int i = 0; i < ni; i++) { 31 | for (int j = 0; j < nj; j++) { 32 | if ((i + j == ni - 1 || i == j)) { 33 | if (grid[i][j] == 0) 34 | return false; 35 | } else if (grid[i][j] != 0) { // not dig 36 | return false; 37 | } 38 | } 39 | } 40 | return true; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /lc/2331.evaluate-boolean-binary-tree.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func evaluateTree(root *TreeNode) bool { 10 | if root == nil { 11 | return true 12 | } 13 | if root.Val == 0 { 14 | return false 15 | } else if root.Val == 1 { 16 | return true 17 | } 18 | 19 | var l bool 20 | var r bool 21 | if root.Left != nil { 22 | switch root.Left.Val { 23 | case 0: 24 | l = false 25 | case 1: 26 | l = true 27 | default: 28 | l = evaluateTree(root.Left) 29 | } 30 | } 31 | 32 | if root.Right != nil { 33 | switch root.Right.Val { 34 | case 0: 35 | r = false 36 | case 1: 37 | r = true 38 | default: 39 | r = evaluateTree(root.Right) 40 | } 41 | } 42 | 43 | if root.Val == 2 { 44 | return r || l 45 | } 46 | return r && l 47 | 48 | } 49 | -------------------------------------------------------------------------------- /lc/2357.make-array-zero-by-subtracting-equal-amounts.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func minimumOperations(nums []int) int { 4 | mp := map[int]int{} 5 | for _, v := range nums { 6 | if v != 0 { 7 | mp[v] = 1 8 | } 9 | } 10 | return len(mp) 11 | } 12 | -------------------------------------------------------------------------------- /lc/2367.number-of-arithmetic-triplets.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int arithmeticTriplets(vector &nums, int diff) { 4 | 5 | int cnt = 0; 6 | 7 | unordered_map mp; 8 | 9 | // Mark every elem presence in map. 10 | for (int i = 0; i < nums.size(); i++) 11 | mp[nums[i]] = true; 12 | 13 | // For every element say 'elm' check if there exist both numbers, (elm + 14 | // diff) and (elm - diff) inside map. If yes then increment cnt 15 | for (int i = 0; i < nums.size(); i++) { 16 | if (mp[nums[i] - diff] && mp[nums[i] + diff]) 17 | cnt++; 18 | } 19 | 20 | // Happy return :) 21 | return cnt; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /lc/2368.reachable-nodes-with-restrictions.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | map visited; 26 | class Solution { 27 | private: 28 | void dfs(vector> &edg, int &cnt) {} 29 | 30 | public: 31 | int reachableNodes(int n, vector> &edges, 32 | vector &restricted) { 33 | int ans = 0; 34 | for (auto &i : restricted) { 35 | visited[i] = 1; 36 | } 37 | for (auto &i : edges) { 38 | } 39 | return ans; 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /lc/2374.node-with-highest-edge-score.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int edgeScore(vector &edges) { 29 | map mp; 30 | int ans = 0, inedx = 0; 31 | for (int i = 0; i < edges.size(); i++) { 32 | mp[edges[i]] += i; 33 | } 34 | for (auto &i : mp) { 35 | if (i.second > ans) { 36 | ans = i.second; 37 | inedx = i.first; 38 | } 39 | } 40 | return inedx; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /lc/2379.minimum-recolors-to-get-k-consecutive-black-blocks.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int minimumRecolors(string blocks, int k) { 29 | int ans = 0, n = blocks.size(); 30 | for (int i = 0; i < k && i < n; i++) { 31 | if (blocks[i] == 'W') 32 | ans++; 33 | } 34 | int kans = ans; 35 | for (int i = k; i < n; i++) { 36 | if (blocks[i] == 'W') 37 | kans++; 38 | if (blocks[i - k] == 'W') 39 | kans--; 40 | ans = kans < ans ? kans : ans; 41 | } 42 | return ans > 0 ? ans : 0; 43 | } 44 | }; 45 | -------------------------------------------------------------------------------- /lc/2380.time-needed-to-rearrange-a-binary-string.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int sol(string &s, int pos) { 29 | int ans = 0, n = s.size(); 30 | if (pos >= n) 31 | return ans; 32 | for (int i = pos; pos < n; i++) { 33 | if (s[i] == '1') 34 | ans++; 35 | else { 36 | ans += sol(s, i + 1); 37 | } 38 | } 39 | return ans; 40 | } 41 | int secondsToRemoveOccurrences(string s) { 42 | int ans = 0; 43 | for (int i = 0; i < s.size(); i++) { 44 | if (s[i] == '0') { 45 | ans += sol(s, i + 1); 46 | break; 47 | } 48 | } 49 | return ans; 50 | } 51 | }; 52 | -------------------------------------------------------------------------------- /lc/2383.minimum-hours-of-training-to-win-a-competition.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | class Solution { 30 | public: 31 | int minNumberOfHours(int initialEnergy, int initialExperience, 32 | vector &energy, vector &experience) { 33 | int toadd = 0, n = energy.size(), enr = initialEnergy, 34 | exp = initialExperience; 35 | for (int i = 0; i < n; i++) { 36 | while (!(energy[i] < enr)) { 37 | toadd++; 38 | enr++; 39 | } 40 | enr -= energy[i]; 41 | 42 | while (!(experience[i] < exp)) { 43 | toadd++; 44 | exp++; 45 | } 46 | exp += experience[i]; 47 | } 48 | return toadd; 49 | } 50 | }; 51 | -------------------------------------------------------------------------------- /lc/2405.optimal-partition-of-string.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int partitionString(string s) { 29 | int n = s.size(), ans(0), start(0); 30 | map count; 31 | for (int i = 0; i < n; i++) { 32 | count[s[i]]++; 33 | if (count[s[i]] > 1) { 34 | ans++; 35 | count.clear(); 36 | count[s[i]]++; 37 | } 38 | } 39 | return ans + 1; 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /lc/2441.largest-positive-integer-that-exists-with-its-negative.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int findMaxK(vector &nums) { 29 | map mp; 30 | for (auto &i : nums) { 31 | mp[i] = 1; 32 | } 33 | sort(begend(nums), greater()); 34 | for (auto &i : nums) { 35 | if (mp[i * -1]) 36 | return i; 37 | } 38 | return -1; 39 | } 40 | }; 41 | -------------------------------------------------------------------------------- /lc/2487.remove-nodes-from-linked-list.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func removeNodes(head *ListNode) *ListNode { 9 | tmp := head.Next 10 | var stack []*ListNode 11 | stack = append(stack, head) 12 | for tmp != nil { 13 | for len(stack) != 0 && tmp.Val > stack[len(stack)-1].Val { 14 | stack = stack[0 : len(stack)-1] 15 | } 16 | stack = append(stack, tmp) 17 | tmp = tmp.Next 18 | } 19 | for i := 0; i < len(stack)-1; i++ { 20 | stack[i].Next = stack[i+1] 21 | } 22 | stack[len(stack)-1].Next = nil 23 | return stack[0] 24 | } 25 | -------------------------------------------------------------------------------- /lc/2586.count-the-number-of-vowel-strings-in-range.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int vowelStrings(vector &words, int left, int right) { 4 | int ans(0); 5 | for (int i = left; i <= right; i++) { 6 | char c = words[i][0]; 7 | char ce = words[i][words[i].size() - 1]; 8 | if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') 9 | if (ce == 'a' || ce == 'e' || ce == 'i' || ce == 'o' || ce == 'u') { 10 | 11 | ans++; 12 | } 13 | } 14 | return ans; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /lc/2587.rearrange-array-to-maximize-prefix-score.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxScore(vector &nums) { 4 | sort(nums.begin(), nums.end(), greater<>()); 5 | long long m = 0; 6 | long long p = 0; 7 | for (int i = 0; i < nums.size(); i++) { 8 | p += nums[i]; 9 | if (p > 0) 10 | m++; 11 | } 12 | 13 | return m; 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /lc/2643.row-with-maximum-ones.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func rowAndMaximumOnes(mat [][]int) []int { 4 | ans := []int{0, 0} 5 | mp := map[int]int{} 6 | for i, v := range mat { 7 | for _, vv := range v { 8 | if vv == 1 { 9 | mp[i]++ 10 | } 11 | } 12 | } 13 | var max int = 0 14 | for key, value := range mp { 15 | if value > max { 16 | max = value 17 | ans[0] = key 18 | ans[1] = value 19 | } 20 | } 21 | return ans 22 | } 23 | -------------------------------------------------------------------------------- /lc/2651.calculate-delayed-arrival-time.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func findDelayedArrivalTime(arrivalTime int, delayedTime int) int { 4 | return (arrivalTime + delayedTime) % 24 5 | } 6 | -------------------------------------------------------------------------------- /lc/2652.sum-multiples.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | func sumOfMultiples(n int) int { 4 | var ans int 5 | for i := 1; i <= n; i++ { 6 | if i%3 == 0 || i%5 == 0 || i%7 == 0 { 7 | ans += i 8 | } 9 | } 10 | return ans 11 | } 12 | -------------------------------------------------------------------------------- /lc/2747.count-zero-request-servers.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/lc/2747.count-zero-request-servers.cpp -------------------------------------------------------------------------------- /lc/workspace.code-workspace: -------------------------------------------------------------------------------- 1 | { 2 | "folders": [ 3 | { 4 | "path": "." 5 | } 6 | ], 7 | "settings": {} 8 | } -------------------------------------------------------------------------------- /ps/README.org: -------------------------------------------------------------------------------- 1 | #+title: OJs Solutions 2 | 3 | Naming is a little missy, I've a hard dependency on it in my git system, so it is not going 4 | to change soon. However: 5 | 6 | + ~cc/~ Codechef (purged and deprecated) 7 | + ~cc/~ Codeforces (purged and deprecated) 8 | + ~cs/~ Codesignal (inactive) 9 | + ~he/~ Hackerearth (purged and deprecated) 10 | + ~nt/~ Lintcode (inactive) 11 | + ~fl/~ Failed problems. (active, as long as am I) 12 | + ~Map/~, ~qwr~, ~tempModule~, ~...~. Dumps, I don't remember why they are here. 13 | -------------------------------------------------------------------------------- /ps/cc/ARREQU.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | var t int 9 | fmt.Scan(&t) 10 | for t > 0 { 11 | var n int 12 | var mx int 13 | var mp = make(map[int]int) 14 | fmt.Scan(&n) 15 | for n > 0 { 16 | var tmp int 17 | fmt.Scan(tmp) 18 | mp[tmp]++ 19 | n-- 20 | if mp[tmp] > mx { 21 | mx = mp[tmp] 22 | } 23 | } 24 | if mx <= len(mp)+1 { 25 | fmt.Println("Yes") 26 | } else { 27 | fmt.Println("No") 28 | } 29 | t-- 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /ps/cc/FLOW001.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | int main() { 30 | int t; 31 | cin >> t; 32 | int a, b; 33 | while (t--) { 34 | int sum = 0; 35 | cin >> a >> b; 36 | sum = a + b; 37 | cout << sum << "\n"; 38 | } 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /ps/cc/MAXIMUMSUBS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://www.codechef.com/submit/MAXIMUMSUBS 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | int main() { 31 | int t; 32 | cin >> t; 33 | int m; 34 | while (t) { 35 | cin >> m; 36 | std::cout << m * 2 << std::endl; 37 | t--; 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /ps/cf/864a.cpp: -------------------------------------------------------------------------------- 1 | #include "864a.h" 2 | -------------------------------------------------------------------------------- /ps/cf/arc/1634A.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/cf/arc/1634A.cpp -------------------------------------------------------------------------------- /ps/cf/arc/223339D.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | typedef long long ll; 26 | 27 | void solver(int n) { 28 | if (n < 0) 29 | n = -1 * n; 30 | if (n / 10 > 0) 31 | solver(n / 10); 32 | cout << n % 10 << " "; 33 | } 34 | 35 | void solve() { 36 | int n; 37 | cin >> n; 38 | solver(n); 39 | cout << endl; 40 | } 41 | 42 | int main() { 43 | int t; 44 | cin >> t; 45 | while (t) 46 | solve(), t--; 47 | } 48 | -------------------------------------------------------------------------------- /ps/cf/arc/326053R.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | typedef long long ll; 26 | 27 | void solve() { 28 | int n; 29 | cin >> n; 30 | map mp; 31 | for (int i = 0; i < n; i++) { 32 | int t; 33 | cin >> t; 34 | mp[t]++; 35 | } 36 | for (int i = 0; i < n; i++) { 37 | int t; 38 | cin >> t; 39 | mp[t]--; 40 | } 41 | for (auto &i : mp) 42 | if (i.second) { 43 | cout << "no"; 44 | return; 45 | } 46 | 47 | cout << "yes"; 48 | } 49 | int main() { 50 | // int t; 51 | // cin >> t; 52 | // while (t) 53 | solve(); 54 | } 55 | -------------------------------------------------------------------------------- /ps/cf/arc/515C.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | map> mp{ 26 | {'2', {2}}, {'3', {3}}, {'4', {3, 2, 2}}, {'5', {5}}, 27 | {'6', {5, 3}}, {'7', {7}}, {'8', {7, 2, 2, 2}}, {'9', {7, 3, 3, 2}}}; 28 | void solve() { 29 | int n; 30 | cin >> n; 31 | string a; 32 | cin >> a; 33 | vector ans; 34 | for (int i = 0; i < n; i++) { 35 | if (a[i] != '0' && a[i] != '1') 36 | ans.insert(ans.end(), begend(mp[a[i]])); 37 | } 38 | sort(begend(ans), greater()); 39 | for (auto &i : ans) { 40 | cout << i; 41 | } 42 | cout << endl; 43 | } 44 | 45 | int main() { 46 | // int t; 47 | // cin >> t; 48 | // while (t) 49 | solve(); 50 | } 51 | -------------------------------------------------------------------------------- /ps/cf/arc/518B.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | typedef long long ll; 26 | 27 | void solve() { 28 | string s; 29 | string t; 30 | int y(0), wp(0); 31 | cin >> s >> t; 32 | map mp; 33 | for (auto &i : t) { 34 | mp[i]++; 35 | } 36 | for (auto &i : s) { 37 | if (mp[i]) { 38 | mp[i]--; 39 | y++; 40 | continue; 41 | } 42 | wp++; 43 | } 44 | cout << y << " " << wp; 45 | } 46 | int main() { 47 | // int t; 48 | // cin >> t; 49 | // while (t) 50 | solve(); 51 | } 52 | 53 | /* 54 | ** 55 | 56 | caba 57 | yay 58 | yay 59 | yay 60 | 61 | ACBA 62 | 63 | ** 64 | */ 65 | -------------------------------------------------------------------------------- /ps/cf/arc/789/a.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/cf/arc/789/a.exe -------------------------------------------------------------------------------- /ps/cf/arc/796/a.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | int main() { 30 | ios_base::sync_with_stdio(false); 31 | cin.tie(NULL); 32 | } 33 | -------------------------------------------------------------------------------- /ps/cs/AddBorder.cpp: -------------------------------------------------------------------------------- 1 | vector solution(vector picture) { 2 | int ln(picture[0].size()); 3 | string row = string(ln + 2, '*'); 4 | picture.insert(picture.begin(), row); 5 | picture.push_back(row); 6 | int n = picture.size(); 7 | for (int i = 1 ; i < n-1; i++) { 8 | picture[i] = "*" + picture[i] + "*"; 9 | } 10 | return picture; 11 | } 12 | -------------------------------------------------------------------------------- /ps/cs/AllLongestStrings.cpp: -------------------------------------------------------------------------------- 1 | vector solution(vector inputArray) { 2 | int m(0), n(inputArray.size()); 3 | vector ans; 4 | for (auto &s : inputArray) { 5 | if (s.length() > m) { 6 | m = s.length(); 7 | ans.clear(); 8 | ans.push_back(s); 9 | } else if (s.length() == m) { 10 | ans.push_back(s); 11 | } 12 | } 13 | return ans; 14 | } 15 | -------------------------------------------------------------------------------- /ps/cs/MakeArrayConsecutive2.cpp: -------------------------------------------------------------------------------- 1 | int solution(vector statues) { 2 | int n(0), sz(statues.size()); 3 | sort(begin(statues), end(statues)); 4 | int s = statues[0]; 5 | for (int i = 0; i < sz; i++) { 6 | while (statues[i] != s) { 7 | s++, n++; 8 | } 9 | s++; 10 | } 11 | return n; 12 | } 13 | // 2, 3, 6, 8 14 | -------------------------------------------------------------------------------- /ps/cs/SortbyHeight.go: -------------------------------------------------------------------------------- 1 | import "sort" 2 | 3 | func solution(a []int) []int { 4 | arr := make([]int, len(a)) 5 | copy(arr, a) 6 | sort.Ints(arr) 7 | var i int 8 | 9 | for k, v := range arr { 10 | if v != -1 { 11 | i = k 12 | break 13 | } 14 | } 15 | 16 | for k, v := range a { 17 | if v == -1 { 18 | continue 19 | } 20 | a[k] = arr[i] 21 | i++ 22 | } 23 | 24 | return a 25 | } 26 | -------------------------------------------------------------------------------- /ps/cs/adjacentElementsProduct.cpp: -------------------------------------------------------------------------------- 1 | int solution(vector inputArray) { 2 | int n = inputArray.size(), ans(INT_MIN); 3 | for (int i = 0; i < n - 1; i++) { 4 | if ((inputArray[i] * inputArray[i + 2]) > ans) 5 | ans = inputArray[i] * inputArray[i + 1]; 6 | } 7 | return ans; 8 | } 9 | -------------------------------------------------------------------------------- /ps/cs/alternatingSums.cpp: -------------------------------------------------------------------------------- 1 | vector solution(vector a) { 2 | int t1(0), t2(0), n(a.size()); 3 | for (int i = 0; i < n; i++) { 4 | if (i % 2 == 0) 5 | t2 += a[i]; 6 | else 7 | t1 += a[i]; 8 | } 9 | return vector{t2, t1}; 10 | } 11 | -------------------------------------------------------------------------------- /ps/cs/centuryFromYear.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | int solution(int year) { 27 | int t = year % 100; 28 | if (!t) 29 | return year / 100; 30 | else 31 | return (t / 100) + 1 32 | } 33 | -------------------------------------------------------------------------------- /ps/cs/checkPalindrome.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | bool solution(string inputString) { 26 | auto tmp = inputString; 27 | reverse(inputString.begin(), inputString.end()); 28 | return tmp == inputString; 29 | } 30 | -------------------------------------------------------------------------------- /ps/cs/isLucky.cpp: -------------------------------------------------------------------------------- 1 | bool solution(int n) { 2 | int c(0), t = n, l(0), r(0), i(0); 3 | 4 | while (t != 0) { 5 | t /= 10; 6 | c++; 7 | } 8 | 9 | bool s; 10 | while (n != 0) { 11 | i++; 12 | int j = n % 10; 13 | n /= 10; 14 | if (i > c / 2) { 15 | l += j; 16 | } else { 17 | r += j; 18 | } 19 | } 20 | 21 | return l == r; 22 | } 23 | -------------------------------------------------------------------------------- /ps/cs/matrixElementsSum.cpp: -------------------------------------------------------------------------------- 1 | int solution(vector> matrix) { 2 | // exclude rooms 3 | int n(matrix.size()), m(matrix[0].size()), sm(0); 4 | for (int i = 0; i < n; i++) { 5 | for (int j = 0; j < m; j++) { 6 | if (matrix[i][j] == 0) { 7 | for (int k = i; k < n; k++) { 8 | matrix[k][j] = 0; 9 | } 10 | } 11 | sm += matrix[i][j]; 12 | } 13 | } 14 | return sm; 15 | } 16 | -------------------------------------------------------------------------------- /ps/cs/reverseInParentheses.cpp: -------------------------------------------------------------------------------- 1 | int solve(string &s, int p) { 2 | int n = s.size(), i; 3 | for (i = p; i < n; i++) { 4 | if (s[i] == '(') { 5 | i = solve(s, i + 1); 6 | continue; 7 | } 8 | if (s[i] == ')') { 9 | reverse(s.begin() + p, s.begin() + i); 10 | break; 11 | } 12 | } 13 | return i; 14 | } 15 | string solution(string inputString) { 16 | int n = inputString.size(); 17 | for (int i = 0; i < n; i++) { 18 | if (inputString[i] == '(') { 19 | i = solve(inputString, i + 1); 20 | } 21 | } 22 | inputString.erase(remove(inputString.begin(), inputString.end(), '('), 23 | inputString.end()); 24 | inputString.erase(remove(inputString.begin(), inputString.end(), ')'), 25 | inputString.end()); 26 | return inputString; 27 | } 28 | -------------------------------------------------------------------------------- /ps/cs/shapeArea.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int solution(int n) { 3 | if (n == 1) 4 | return 1; 5 | return pow(n, 2) + pow(n - 1, 2); 6 | } 7 | -------------------------------------------------------------------------------- /ps/cw/CanYouGetTheLoop.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | struct Node { 27 | Node *getNext(); 28 | }; 29 | int getLoopSize(Node *startNode) { 30 | 31 | int i = 0; 32 | map visited; 33 | while (startNode) { 34 | if (!visited.count(startNode)) 35 | visited[startNode] = i, ++i, startNode = startNode->getNext(); 36 | else { 37 | return i - visited[startNode]; 38 | } 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /ps/cw/FindTheMissingLetter.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "strings" 5 | "unicode" 6 | ) 7 | 8 | func FindMissingLetter(chars []rune) rune { 9 | 10 | alpha := "abcdefghijklmnopqrstuvwxyz" 11 | if unicode.IsUpper(chars[0]) { 12 | alpha = strings.ToUpper(alpha) 13 | } 14 | start := strings.IndexRune(alpha, chars[0]) 15 | end := strings.IndexRune(alpha, chars[len(chars)-1]) 16 | searchalpha := alpha[start : end+1] 17 | searchstring := string(chars) 18 | for _, value := range searchalpha { 19 | if !strings.ContainsRune(searchstring, value) { 20 | return value 21 | } 22 | } 23 | return 'a' 24 | } 25 | -------------------------------------------------------------------------------- /ps/cw/HumanReadableTime.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import "strconv" 4 | 5 | func HumanReadableTime(seconds int) string { 6 | hours, minutes := 0, 0 7 | for seconds >= 3600 { 8 | hours = seconds / 3600 9 | seconds = seconds % 3600 10 | } 11 | for seconds >= 60 { 12 | minutes = seconds / 60 13 | seconds = seconds % 60 14 | } 15 | 16 | shours, sminutes, sseconds := "00", "00", "00" 17 | if hours <= 9 { 18 | shours = strconv.Itoa(hours) 19 | } else { 20 | shours = strconv.Itoa(hours) 21 | } 22 | 23 | if minutes <= 9 { 24 | sminutes = "0" + strconv.Itoa(minutes) 25 | } else { 26 | sminutes = strconv.Itoa(minutes) 27 | } 28 | 29 | if seconds <= 9 { 30 | sseconds = "0" + strconv.Itoa(seconds) 31 | } else { 32 | sseconds = strconv.Itoa(seconds) 33 | } 34 | 35 | return shours + ":" + sminutes + ":" + sseconds 36 | 37 | } 38 | -------------------------------------------------------------------------------- /ps/cw/IPValidation.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "strconv" 5 | "strings" 6 | ) 7 | 8 | func Is_valid_ip(ip string) bool { 9 | sgs := strings.Split(ip, ".") 10 | if len(sgs) != 4 { 11 | return false 12 | } 13 | for _, value := range sgs { 14 | intg, err := strconv.Atoi(value) 15 | if (value[0] == '0' && len(value) > 1) || err != nil || intg > 255 || intg < 0 { 16 | return false 17 | } 18 | } 19 | return true 20 | } 21 | -------------------------------------------------------------------------------- /ps/cw/JadenCasingStrings.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import "unicode" 4 | 5 | func ToJadenCase(str string) string { 6 | s := []rune(str) 7 | for i, c := range s { 8 | if c == ' ' { 9 | s[i+1] = unicode.ToUpper(s[i+1]) 10 | } 11 | } 12 | s[0] = unicode.ToUpper(s[0]) 13 | return string(s) 14 | } 15 | -------------------------------------------------------------------------------- /ps/cw/MaketheDeadfishSwim.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | func Parse(data string) []int { 4 | ans, v := []int{}, 0 5 | 6 | for _, value := range data { 7 | switch value { 8 | case 'i': 9 | v++ 10 | case 'd': 11 | v-- 12 | case 's': 13 | v *= v 14 | case 'o': 15 | ans = append(ans, v) 16 | } 17 | } 18 | return ans 19 | } 20 | -------------------------------------------------------------------------------- /ps/cw/MovingZerosToTheEnd.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | func MoveZeros(arr []int) []int { 4 | index := 0 5 | for _, value := range arr { 6 | if value != 0 { 7 | arr[index] = value 8 | index++ 9 | } 10 | 11 | } 12 | for i := index; i < len(arr); i++ { 13 | arr[i] = 0 14 | } 15 | return arr 16 | } 17 | -------------------------------------------------------------------------------- /ps/cw/Multiplesof3or5.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | func Multiple3And5(number int) int { 4 | var ans int 5 | for i := 1; i < number; i++ { 6 | if i%3 == 0 || i%5 == 0 { 7 | ans += i 8 | } 9 | } 10 | return ans 11 | } 12 | -------------------------------------------------------------------------------- /ps/cw/MultiplicationTable.go: -------------------------------------------------------------------------------- 1 | package kate 2 | 3 | // import ( 4 | // "fmt" 5 | // ) 6 | 7 | func MultiplicationTable(size int) [][]int { 8 | s := make([][]int, size) 9 | for k1 := range s { 10 | s[k1] = make([]int, size) 11 | 12 | } 13 | for k1, value := range s { 14 | s[k1] = make([]int, size) 15 | for k2 := range value { 16 | s[k1][k2] = (k1 + 1) * (k2 + 1) 17 | } 18 | } 19 | return s 20 | } 21 | -------------------------------------------------------------------------------- /ps/cw/Mumbling.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "strings" 5 | "unicode" 6 | ) 7 | 8 | func Accum(s string) string { 9 | var str strings.Builder 10 | for i, c := range s { 11 | u, l := unicode.ToUpper(c), unicode.ToLower(c) 12 | str.WriteRune(u) 13 | i-- 14 | for i+1 > 0 { 15 | str.WriteRune(l) 16 | i-- 17 | } 18 | str.WriteRune('-') 19 | } 20 | return str.String()[:str.Len()-1] 21 | } 22 | -------------------------------------------------------------------------------- /ps/cw/Notverysecure.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | func alphanumeric(str string) bool { 4 | if len(str) == 0 { 5 | return false 6 | } 7 | for _, value := range str { 8 | if (value < 'a' || value > 'z') && (value < '0' || value > '9') && (value < 'A' || 9 | value > 'Z') { 10 | return false 11 | } 12 | } 13 | return true 14 | } 15 | -------------------------------------------------------------------------------- /ps/cw/PrimesInNumbers.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | -------------------------------------------------------------------------------- /ps/cw/ShortestWord.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "math" 5 | "strings" 6 | ) 7 | 8 | func FindShort(s string) int { 9 | var rs int = math.MaxInt 10 | slz := strings.Fields(s) 11 | for _, value := range slz { 12 | if len(value) < rs { 13 | rs = len(value) 14 | } 15 | } 16 | return rs 17 | } 18 | -------------------------------------------------------------------------------- /ps/cw/SplitStrings.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | func Solution(str string) []string { 4 | var res []string 5 | if len(str)%2 != 0 { 6 | str += "_" 7 | } 8 | for i := 0; i < len(str); i += 2 { 9 | res = append(res, str[i:i+2]) 10 | } 11 | return res 12 | } 13 | -------------------------------------------------------------------------------- /ps/cw/StopgninnipSMysdroW.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "strings" 5 | ) 6 | 7 | func SpinWords(str string) string { 8 | slz := strings.Fields(str) 9 | rvrs := func(in string) string { 10 | rn := []rune(in) 11 | for i, j := 0, len(rn)-1; i < j; i, j = i+1, j-1 { 12 | rn[i], rn[j] = rn[j], rn[i] 13 | } 14 | return string(rn) 15 | } 16 | for i, s := range slz { 17 | if len(s) >= 5 { 18 | slz[i] = rvrs(slz[i]) 19 | } 20 | } 21 | return strings.Join(slz, " ") 22 | } 23 | -------------------------------------------------------------------------------- /ps/cw/SumofDigitsDigitalRoot.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import "fmt" 4 | 5 | // func DigitalRoot(n int) int { 6 | // } 7 | 8 | func slv(n int, ans *int) int { 9 | if n <= 0 { 10 | return 0 11 | } 12 | return slv(n/10, ans) 13 | } 14 | 15 | func main() { 16 | 17 | var i, ans int = 12, 0 18 | fmt.Print(slv(i, &ans)) 19 | 20 | } 21 | -------------------------------------------------------------------------------- /ps/cw/TwoSum.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | func TwoSum(numbers []int, target int) [2]int { 4 | m := map[int]int{} 5 | for key, value := range numbers { 6 | _, err := m[target-value] 7 | if err { 8 | return [2]int{key, m[target-value]} 9 | } 10 | m[value] = key 11 | } 12 | return [2]int{} 13 | } 14 | -------------------------------------------------------------------------------- /ps/cw/ValidParenthesese.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | func ValidParentheses(parens string) bool { 4 | stack := []rune{} 5 | for _, value := range parens { 6 | if value == '(' { 7 | stack = append(stack, '(') 8 | } else { 9 | n := len(stack) 10 | if n > 0 && stack[n-1] == '(' { 11 | stack = stack[:n-1] 12 | } else { 13 | return false 14 | } 15 | } 16 | } 17 | 18 | return true 19 | } 20 | -------------------------------------------------------------------------------- /ps/cw/VowelCount.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | func GetCount(str string) (count int) { 4 | for _, c := range str { 5 | switch c { 6 | case 'a', 'e', 'i', 'o', 'u': 7 | count++ 8 | } 9 | } 10 | return count 11 | } 12 | -------------------------------------------------------------------------------- /ps/cw/WeIrDStRiNgCaSe.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "strings" 5 | "unicode" 6 | ) 7 | 8 | func toWeirdCase(str string) string { 9 | str = strings.ToLower(str) 10 | strs := strings.Split(str, " ") 11 | bldr := strings.Builder{} 12 | for k, value := range strs { 13 | rnvalue := []rune(value) 14 | for key, othervalue := range rnvalue { 15 | if key%2 == 0 { 16 | rnvalue[key] = unicode.ToUpper(othervalue) 17 | } 18 | } 19 | bldr.WriteString(string(rnvalue)) 20 | if k != len(strs)-1 { 21 | bldr.WriteRune(' ') 22 | } 23 | } 24 | return bldr.String() 25 | } 26 | -------------------------------------------------------------------------------- /ps/cw/WhichAreIn.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | "strings" 7 | ) 8 | 9 | func InArray(array1 []string, array2 []string) []string { 10 | a3 := strings.Join(array2, "") 11 | ans := []string{} 12 | mp := map[string]bool{} 13 | for _, value := range array1 { 14 | if strings.Contains(a3, value) && mp[value] == false { 15 | ans = append(ans, value) 16 | } 17 | } 18 | sort.Strings(ans) 19 | return ans 20 | } 21 | 22 | func main() { 23 | var a1 = []string{"live", "arp", "strong"} 24 | var a2 = []string{"lively", "alive", "harp", "sharp", "armstrong"} 25 | strings. 26 | fmt.Println(InArray(a1, a2)) 27 | } 28 | -------------------------------------------------------------------------------- /ps/cw/dont-give-me-five.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "fmt" 5 | "math" 6 | ) 7 | 8 | func DontGiveMeFive(start int, end int) int { 9 | return int(math.Round(float64(start/5)) - math.Round(float64(end/5))) 10 | } 11 | -------------------------------------------------------------------------------- /ps/cw/test.go: -------------------------------------------------------------------------------- 1 | package kata 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | s := []int{1, 2, 3, 4} 9 | 10 | for _, value := range s { 11 | value++ 12 | } 13 | 14 | for _, value := range s { 15 | fmt.Print(value) 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /ps/fl/0092.reverse-linked-list-ii.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | func reverseBetween(head *ListNode, left int, right int) *ListNode { 9 | // reach pre and first 10 | curr := head 11 | var pre, last, tmp *ListNode 12 | 13 | i := 1 14 | for ; i <= left && curr != nil; i++ { 15 | pre = curr 16 | curr = curr.Next 17 | } 18 | println(curr.Val) 19 | start := curr.Next 20 | prev := curr 21 | do(start) 22 | do(prev) 23 | do(pre) 24 | do(last) 25 | do(tmp) 26 | 27 | pre.Next = last 28 | curr.Next = tmp 29 | return head 30 | } 31 | 32 | func do(interface{}) {} 33 | 34 | // for ; i <= right && start != nil; i++ { 35 | // last = start 36 | // tmp = last.Next 37 | // start.Next = prev 38 | // prev = last 39 | // start = last.Next 40 | // } 41 | -------------------------------------------------------------------------------- /ps/fl/0205_isomorphic-strings.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | bool isIsomorphic(string s, string t) { 29 | map m1, m2; 30 | int n = s.size(); 31 | for (int i = 0; i < n; i++) { 32 | m1[s[i]]++; 33 | m2[t[i]]++; 34 | } 35 | 36 | for (int i = 0; i < n; i++) { 37 | if (m1[s[i]] != m2[t[i]]) 38 | return false; 39 | } 40 | return true; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /ps/fl/0416_partition-equal-subset-sum.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | bool canPartition(vector &nums) { 29 | sort(begend(nums)); 30 | int n = nums.size(), sum(0); 31 | for (int i = 0; i < n; i++) 32 | sum += nums[i]; 33 | int sum2(0); 34 | for (int i = 0; i < n; i++) { 35 | sum2 += nums[i]; 36 | sum -= nums[i]; 37 | if (sum2 == sum) 38 | return 1; 39 | } 40 | 41 | return false; 42 | } 43 | }; 44 | -------------------------------------------------------------------------------- /ps/fl/0424_longest-repeating-character-replacement.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int characterReplacement(string s, int k) { 29 | map mp; 30 | int n(s.size()), j(0), sum(0), res(-1); 31 | for (int i = 0; i < n; i++) { 32 | mp[s[i]]++, sum++; 33 | while (j < n && mp.size() > 1) { 34 | mp[s[j]]--, sum--; 35 | if (mp[s[j]] == 0) { 36 | mp.erase(s[j]); 37 | j++; 38 | } 39 | } 40 | res = max(res, sum); 41 | } 42 | return res; 43 | } 44 | }; 45 | -------------------------------------------------------------------------------- /ps/fl/0914.x-of-a-kind-in-a-deck-of-cards.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func hasGroupsSizeX(deck []int) bool { 6 | mp := map[int]int{} 7 | for _, v := range deck { 8 | mp[v]++ 9 | } 10 | mv := mp[deck[0]] 11 | if len(mp) == 1 { 12 | return false 13 | } 14 | for _, v := range mp { 15 | if v != mv && !(v%2 == 0 || mv%2 == 0) { 16 | return false 17 | } 18 | } 19 | return true 20 | } 21 | 22 | func main() { 23 | fmt.Println(hasGroupsSizeX([]int{1, 1, 2, 2, 2, 2})) 24 | } 25 | -------------------------------------------------------------------------------- /ps/fl/0915_partition-array-into-disjoint-intervals.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | int partitionDisjoint(vector &nums) { 29 | int n = nums.size(), ans(0), maxleft(0), maxright(0), rp(0); 30 | for (int i = 0; i < n; i++) { 31 | if (nums[i] > maxleft) 32 | maxleft = nums[i]; 33 | } 34 | 35 | return ans; 36 | } 37 | }; 38 | -------------------------------------------------------------------------------- /ps/fl/0984_string-without-aaa-or-bbb.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | class Solution { 27 | public: 28 | string strWithout3a3b(int a, int b) { 29 | string ans; 30 | while (a > 0 || b > 0) { 31 | bool wa = 0; 32 | int l = ans.length(); 33 | if (l >= 2 && ans[l - 2] == ans[l - 1]) { 34 | if (ans[l - 1] == 'a') 35 | wa = 0; 36 | else 37 | wa = 1; 38 | } 39 | if (wa) { 40 | ans += 'a'; 41 | a--; 42 | } else { 43 | ans += 'b'; 44 | b--; 45 | } 46 | } 47 | return ans; 48 | } 49 | }; 50 | -------------------------------------------------------------------------------- /ps/fl/1038.binary-search-tree-to-greater-sum-tree.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func bstToGst(root *TreeNode) *TreeNode { 10 | solve(root) 11 | return root 12 | } 13 | 14 | func solve(root *TreeNode) int { 15 | if root == nil { 16 | return 0 17 | } 18 | root.Val = solve(root.Right) + root.Val + solve(root.Left) 19 | return root.Val 20 | } 21 | -------------------------------------------------------------------------------- /ps/fl/116.populating-next-right-pointers-in-each-node.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int main() { 3 | std::cout << "Hmm"; 4 | } 5 | -------------------------------------------------------------------------------- /ps/fl/1382.balance-a-binary-search-tree.go: -------------------------------------------------------------------------------- 1 | package lc 2 | 3 | import "math" 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | func hight(treeNode *TreeNode) int { 12 | if treeNode == nil { 13 | return 0 14 | } 15 | lh := hight(treeNode.Left) 16 | rh := hight(treeNode.Right) 17 | return int(math.Max(float64(lh), float64(rh))) + 1 18 | } 19 | 20 | func balanceBST(root *TreeNode) *TreeNode { 21 | 22 | df := func(root *TreeNode) (bf int) { 23 | return hight(root.Left) - hight(root.Right) 24 | } 25 | 26 | return root 27 | } 28 | -------------------------------------------------------------------------------- /ps/fl/1637A.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://codeforces.com/contest/1637/problem/0 3 | * Tags: Array 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | void sol() { 30 | int n; 31 | cin >> n; 32 | vector q(n); 33 | for (int i = 0; i < n; i++) { 34 | cin >> q[i]; 35 | } 36 | int no = 1; 37 | for (int i = 1; i < q.size(); i++) { 38 | auto tempq = q; 39 | sort(tempq.begin(), tempq.begin() + i); 40 | sort(tempq.begin() + i, tempq.end()); 41 | 42 | if (!is_sorted(begend(tempq))) { 43 | cout << "YES" << endl; 44 | no = 0; 45 | break; 46 | } 47 | } 48 | if (no) 49 | cout << "NO"; 50 | } 51 | 52 | int main() { 53 | int n; 54 | cin >> n; 55 | while (n) { 56 | sol(); 57 | n--; 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /ps/fl/1817.finding-the-users-active-minutes.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // import ( 4 | // "fmt" 5 | // ) 6 | func findingUsersActiveMinutes(logs [][]int, k int) []int { 7 | 8 | return []int{} 9 | } 10 | -------------------------------------------------------------------------------- /ps/fl/2138.divide-a-string-into-groups-of-size-k.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: divide-a-string-into-groups-of-size-k 3 | * Tags: Strings 4 | */ 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #define begend(v) ((v).begin()), ((v).end()) 25 | #define sz(v) ((int)((v).size())) 26 | using namespace std; 27 | 28 | class Solution { 29 | public: 30 | vector divideString(string s, int k, char fill) {} 31 | }; 32 | 33 | int main() { 34 | ios_base::sync_with_stdio(false); 35 | cin.tie(NULL); 36 | } 37 | -------------------------------------------------------------------------------- /ps/fl/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | sre := []int{1, 2, 3, 4, 5, 6, 7, 8} 9 | ra := sre[1:8] 10 | fmt.Print(ra) 11 | } 12 | -------------------------------------------------------------------------------- /ps/he/max-difference.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #define begend(v) ((v).begin()), ((v).end()) 21 | #define sz(v) ((int)((v).size())) 22 | using namespace std; 23 | typedef pair pi; 24 | priority_queue, greater> pq; 25 | 26 | int main() { 27 | int t; 28 | cin >> t; 29 | while (t) { 30 | t--; 31 | int n; 32 | cin >> n; 33 | if (!n) { 34 | cout << 0 << endl; 35 | continue; 36 | } 37 | vector arr; 38 | while (n) { 39 | n--; 40 | int tmp; 41 | cin >> tmp; 42 | arr.push_back(tmp); 43 | } 44 | sort(begend(arr)); 45 | if (arr.size() <= 3) 46 | cout << arr[arr.size() - 1] - arr[0] << endl; 47 | else 48 | cout << arr[arr.size() - 1] - arr[0] + arr[arr.size() - 2] - arr[1] 49 | << endl; 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /ps/nt/1862.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: 3 | * https://www.lintcode.com/problem/1862/?_from=problem_tag&fromId=undefined 4 | * Tags: DFS 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | class Solution { 31 | public: 32 | /** 33 | * @param father: the father of every node 34 | * @param time: the time from father[i] to node i 35 | * @return: time to flower tree 36 | */ 37 | int timeToFlowerTree(vector &father, vector &time) { return 0; } 38 | }; 39 | 40 | int main() { 41 | ios_base::sync_with_stdio(false); 42 | cin.tie(NULL); 43 | } 44 | -------------------------------------------------------------------------------- /ps/nt/380.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://www.lintcode.com/problem/380/ 3 | * Tags: 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #define begend(v) ((v).begin()), ((v).end()) 26 | #define sz(v) ((int)((v).size())) 27 | using namespace std; 28 | 29 | struct ListNode { 30 | int val; 31 | ListNode *next; 32 | ListNode(int x) : val(x), next(NULL) {} 33 | }; 34 | class Solution { 35 | public: 36 | ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { 37 | unordered_map m; 38 | auto hA = headA; 39 | while (hA) { 40 | m[hA] = 1; 41 | hA = hA->next; 42 | } 43 | while (headB) { 44 | if (m[headB]) 45 | return headB; 46 | headB = headB->next; 47 | } 48 | return nullptr; 49 | } 50 | }; 51 | -------------------------------------------------------------------------------- /ps/nt/415.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Problem: https://www.lintcode.com/problem/415/ 3 | * Tags: Array 4 | */ 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #define begend(v) ((v).begin()), ((v).end()) 27 | #define sz(v) ((int)((v).size())) 28 | using namespace std; 29 | 30 | class Solution { 31 | public: 32 | /** 33 | * @param s: A string 34 | * @return: Whether the string is a valid palindrome 35 | */ 36 | bool isPalindrome(string s) { 37 | s.erase(remove_if(begend(s), 38 | [](auto const &x) -> bool { 39 | if (isdigit(x)) 40 | return false; 41 | return !isalpha(x); 42 | }), 43 | s.end()); 44 | transform(begend(s), s.begin(), ::toupper); 45 | string p = s; 46 | reverse(begend(p)); 47 | return p == s; 48 | } 49 | }; 50 | -------------------------------------------------------------------------------- /ps/nt/919.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/nt/919.cpp -------------------------------------------------------------------------------- /ps/st/2022-02-14_14-11-50_screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/st/2022-02-14_14-11-50_screenshot.png -------------------------------------------------------------------------------- /ps/st/2022-02-14_14-12-07_screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/st/2022-02-14_14-12-07_screenshot.png -------------------------------------------------------------------------------- /ps/st/2022-02-14_14-12-16_screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/st/2022-02-14_14-12-16_screenshot.png -------------------------------------------------------------------------------- /ps/st/2022-02-14_14-12-23_screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/st/2022-02-14_14-12-23_screenshot.png -------------------------------------------------------------------------------- /ps/st/2022-02-14_14-12-28_screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/st/2022-02-14_14-12-28_screenshot.png -------------------------------------------------------------------------------- /ps/st/2022-02-14_14-12-35_screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/st/2022-02-14_14-12-35_screenshot.png -------------------------------------------------------------------------------- /ps/st/2022-02-14_14-12-55_screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/larrasket/ps/eb1ac2221e6c7fb9622aafe859c63e219f32faf7/ps/st/2022-02-14_14-12-55_screenshot.png -------------------------------------------------------------------------------- /ps/test.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | using namespace std; 8 | 9 | void rr(); 10 | void r(); 11 | int main() { r(); } 12 | 13 | void rr() { 14 | vector e{1, 2, 3, 4, 5}; 15 | for (auto &i : e) { 16 | i = -1; 17 | } 18 | 19 | for (auto &i : e) { 20 | std::cout << i << std::endl; 21 | } 22 | } 23 | 24 | void r() { 25 | try { 26 | int nage = 15; 27 | if (nage >= 18) { 28 | std::cout << "Access granted - you are old enough."; 29 | } else { 30 | throw("fuck"); 31 | } 32 | } catch (string) { 33 | std::cout << "Access denied - You must be at least 18 years old.\n"; 34 | std::cout << "Age is: " << -1; 35 | } 36 | } 37 | --------------------------------------------------------------------------------