├── 0001-two-sum ├── 0001-two-sum.js ├── NOTES.md └── README.md ├── 0004-median-of-two-sorted-arrays ├── 0004-median-of-two-sorted-arrays.js ├── NOTES.md └── README.md ├── 0005-longest-palindromic-substring ├── 0005-longest-palindromic-substring.js ├── NOTES.md └── README.md ├── 0013-roman-to-integer ├── 0013-roman-to-integer.js ├── NOTES.md └── README.md ├── 0020-valid-parentheses ├── 0020-valid-parentheses.js ├── 0020-valid-parentheses.py ├── NOTES.md └── README.md ├── 0026-remove-duplicates-from-sorted-array ├── 0026-remove-duplicates-from-sorted-array.js ├── NOTES.md └── README.md ├── 0027-remove-element ├── 0027-remove-element.js ├── NOTES.md └── README.md ├── 0028-find-the-index-of-the-first-occurrence-in-a-string ├── 0028-find-the-index-of-the-first-occurrence-in-a-string.js ├── NOTES.md └── README.md ├── 0035-search-insert-position ├── 0035-search-insert-position.js ├── NOTES.md └── README.md ├── 0058-length-of-last-word ├── 0058-length-of-last-word.js ├── NOTES.md └── README.md ├── 0071-simplify-path ├── 0071-simplify-path.js ├── NOTES.md └── README.md ├── 0073-set-matrix-zeroes ├── 0073-set-matrix-zeroes.js ├── NOTES.md └── README.md ├── 0074-search-a-2d-matrix ├── 0074-search-a-2d-matrix.js ├── NOTES.md └── README.md ├── 0094-binary-tree-inorder-traversal ├── 0094-binary-tree-inorder-traversal.js ├── NOTES.md └── README.md ├── 0118-pascals-triangle ├── 0118-pascals-triangle.js ├── NOTES.md └── README.md ├── 0121-best-time-to-buy-and-sell-stock ├── 0121-best-time-to-buy-and-sell-stock.py ├── NOTES.md └── README.md ├── 0136-single-number ├── 0136-single-number.js ├── NOTES.md └── README.md ├── 0144-binary-tree-preorder-traversal ├── 0144-binary-tree-preorder-traversal.js ├── NOTES.md └── README.md ├── 0145-binary-tree-postorder-traversal ├── 0145-binary-tree-postorder-traversal.js ├── NOTES.md └── README.md ├── 0162-find-peak-element ├── 0162-find-peak-element.js ├── NOTES.md └── README.md ├── 0169-majority-element ├── 0169-majority-element.js ├── NOTES.md └── README.md ├── 0175-combine-two-tables ├── 0175-combine-two-tables.sql ├── NOTES.md └── README.md ├── 0182-duplicate-emails ├── 0182-duplicate-emails.sql ├── NOTES.md └── README.md ├── 0183-customers-who-never-order ├── 0183-customers-who-never-order.sql └── README.md ├── 0184-department-highest-salary ├── 0184-department-highest-salary.sql ├── NOTES.md └── README.md ├── 0197-rising-temperature ├── 0197-rising-temperature.sql ├── NOTES.md └── README.md ├── 0202-happy-number ├── 0202-happy-number.js ├── NOTES.md └── README.md ├── 0205-isomorphic-strings ├── 0205-isomorphic-strings.js ├── NOTES.md └── README.md ├── 0209-minimum-size-subarray-sum ├── 0209-minimum-size-subarray-sum.js ├── NOTES.md └── README.md ├── 0217-contains-duplicate ├── 0217-contains-duplicate.js ├── NOTES.md └── README.md ├── 0228-summary-ranges ├── 0228-summary-ranges.js ├── NOTES.md └── README.md ├── 0258-add-digits ├── 0258-add-digits.js ├── NOTES.md └── README.md ├── 0290-word-pattern ├── 0290-word-pattern.js ├── NOTES.md └── README.md ├── 0303-range-sum-query-immutable ├── 0303-range-sum-query-immutable.js ├── NOTES.md └── README.md ├── 0344-reverse-string ├── 0344-reverse-string.js ├── NOTES.md └── README.md ├── 0345-reverse-vowels-of-a-string ├── 0345-reverse-vowels-of-a-string.js ├── NOTES.md └── README.md ├── 0347-top-k-frequent-elements ├── 0347-top-k-frequent-elements.js └── NOTES.md ├── 0349-intersection-of-two-arrays ├── 0349-intersection-of-two-arrays.js ├── NOTES.md └── README.md ├── 0442-find-all-duplicates-in-an-array ├── 0442-find-all-duplicates-in-an-array.js ├── NOTES.md └── README.md ├── 0448-find-all-numbers-disappeared-in-an-array ├── 0448-find-all-numbers-disappeared-in-an-array.js ├── NOTES.md └── README.md ├── 0451-sort-characters-by-frequency ├── 0451-sort-characters-by-frequency.js ├── NOTES.md └── README.md ├── 0496-next-greater-element-i ├── 0496-next-greater-element-i.js ├── NOTES.md └── README.md ├── 0511-game-play-analysis-i ├── 0511-game-play-analysis-i.sql ├── NOTES.md └── README.md ├── 0530-minimum-absolute-difference-in-bst ├── 0530-minimum-absolute-difference-in-bst.js ├── NOTES.md └── README.md ├── 0532-k-diff-pairs-in-an-array ├── 0532-k-diff-pairs-in-an-array.js ├── NOTES.md └── README.md ├── 0535-encode-and-decode-tinyurl ├── 0535-encode-and-decode-tinyurl.js ├── NOTES.md └── README.md ├── 0557-reverse-words-in-a-string-iii ├── 0557-reverse-words-in-a-string-iii.js ├── NOTES.md └── README.md ├── 0595-big-countries ├── 0595-big-countries.sql ├── NOTES.md └── README.md ├── 0596-classes-more-than-5-students ├── 0596-classes-more-than-5-students.sql ├── NOTES.md └── README.md ├── 0605-can-place-flowers ├── 0605-can-place-flowers.js ├── NOTES.md └── README.md ├── 0619-biggest-single-number ├── 0619-biggest-single-number.sql ├── NOTES.md └── README.md ├── 0620-not-boring-movies ├── 0620-not-boring-movies.sql ├── NOTES.md └── README.md ├── 0627-swap-salary ├── 0627-swap-salary.sql ├── NOTES.md └── README.md ├── 0682-baseball-game ├── 0682-baseball-game.js ├── NOTES.md └── README.md ├── 0692-top-k-frequent-words ├── 0692-top-k-frequent-words.js ├── NOTES.md └── README.md ├── 0705-design-hashset ├── 0705-design-hashset.js ├── NOTES.md └── README.md ├── 0706-design-hashmap ├── 0706-design-hashmap.js ├── NOTES.md └── README.md ├── 0724-find-pivot-index ├── 0724-find-pivot-index.js ├── NOTES.md └── README.md ├── 0783-minimum-distance-between-bst-nodes ├── 0783-minimum-distance-between-bst-nodes.js ├── NOTES.md └── README.md ├── 0791-custom-sort-string ├── 0791-custom-sort-string.js ├── NOTES.md └── README.md ├── 0804-unique-morse-code-words ├── 0804-unique-morse-code-words.js └── README.md ├── 0832-flipping-an-image ├── 0832-flipping-an-image.js ├── NOTES.md └── README.md ├── 0844-backspace-string-compare ├── 0844-backspace-string-compare.js ├── NOTES.md └── README.md ├── 0852-peak-index-in-a-mountain-array ├── 0852-peak-index-in-a-mountain-array.js ├── NOTES.md └── README.md ├── 0867-transpose-matrix ├── 0867-transpose-matrix.js ├── NOTES.md └── README.md ├── 0874-backspace-string-compare ├── 0874-backspace-string-compare.js └── README.md ├── 0905-sort-array-by-parity ├── 0905-sort-array-by-parity.js ├── NOTES.md └── README.md ├── 0929-unique-email-addresses ├── 0929-unique-email-addresses.js ├── NOTES.md └── README.md ├── 0961-n-repeated-element-in-size-2n-array ├── 0961-n-repeated-element-in-size-2n-array.js ├── NOTES.md └── README.md ├── 0977-squares-of-a-sorted-array ├── 0977-squares-of-a-sorted-array.js ├── NOTES.md └── README.md ├── 0985-sum-of-even-numbers-after-queries ├── 0985-sum-of-even-numbers-after-queries.js ├── NOTES.md └── README.md ├── 0989-add-to-array-form-of-integer ├── 0989-add-to-array-form-of-integer.py ├── NOTES.md └── README.md ├── 1047-remove-all-adjacent-duplicates-in-string ├── 1047-remove-all-adjacent-duplicates-in-string.js ├── NOTES.md └── README.md ├── 1050-actors-and-directors-who-cooperated-at-least-three-times ├── 1050-actors-and-directors-who-cooperated-at-least-three-times.sql ├── NOTES.md └── README.md ├── 1051-height-checker ├── 1051-height-checker.js ├── NOTES.md └── README.md ├── 1068-product-sales-analysis-i ├── 1068-product-sales-analysis-i.sql ├── NOTES.md └── README.md ├── 1075-project-employees-i ├── 1075-project-employees-i.sql ├── NOTES.md └── README.md ├── 1108-defanging-an-ip-address ├── 1108-defanging-an-ip-address.js ├── NOTES.md └── README.md ├── 1122-relative-sort-array ├── 1122-relative-sort-array.js ├── NOTES.md └── README.md ├── 1128-remove-all-adjacent-duplicates-in-string ├── 1128-remove-all-adjacent-duplicates-in-string.js └── README.md ├── 1136-actors-and-directors-who-cooperated-at-least-three-times ├── 1136-actors-and-directors-who-cooperated-at-least-three-times.sql └── README.md ├── 1158-market-analysis-i ├── 1158-market-analysis-i.sql ├── NOTES.md └── README.md ├── 1268-market-analysis-i ├── 1268-market-analysis-i.sql └── README.md ├── 1282-group-the-people-given-the-group-size-they-belong-to ├── 1282-group-the-people-given-the-group-size-they-belong-to.js ├── NOTES.md └── README.md ├── 1323-maximum-69-number ├── 1323-maximum-69-number.js ├── NOTES.md └── README.md ├── 1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold ├── 1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold.js ├── NOTES.md └── README.md ├── 1351-count-negative-numbers-in-a-sorted-matrix ├── 1351-count-negative-numbers-in-a-sorted-matrix.js ├── NOTES.md └── README.md ├── 1357-apply-discount-every-n-orders ├── 1357-apply-discount-every-n-orders.js ├── NOTES.md └── README.md ├── 1365-how-many-numbers-are-smaller-than-the-current-number ├── 1365-how-many-numbers-are-smaller-than-the-current-number.js ├── NOTES.md └── README.md ├── 1381-design-a-stack-with-increment-operation ├── 1381-design-a-stack-with-increment-operation.js ├── NOTES.md └── README.md ├── 1393-capital-gain-loss ├── 1393-capital-gain-loss.sql ├── NOTES.md └── README.md ├── 1394-find-lucky-integer-in-an-array ├── 1394-find-lucky-integer-in-an-array.js ├── NOTES.md └── README.md ├── 1407-top-travellers ├── 1407-top-travellers.sql ├── NOTES.md └── README.md ├── 1436-destination-city ├── 1436-destination-city.js ├── NOTES.md └── README.md ├── 1484-group-sold-products-by-the-date ├── 1484-group-sold-products-by-the-date.sql ├── NOTES.md └── README.md ├── 1496-path-crossing ├── 1496-path-crossing.js ├── NOTES.md └── README.md ├── 1502-can-make-arithmetic-progression-from-sequence ├── 1502-can-make-arithmetic-progression-from-sequence.js ├── NOTES.md └── README.md ├── 1512-number-of-good-pairs ├── 1512-number-of-good-pairs.js ├── NOTES.md └── README.md ├── 1528-shuffle-string ├── 1528-shuffle-string.js └── NOTES.md ├── 1541-top-travellers ├── 1541-top-travellers.sql └── README.md ├── 1572-matrix-diagonal-sum ├── 1572-matrix-diagonal-sum.js ├── NOTES.md └── README.md ├── 1587-bank-account-summary-ii ├── 1587-bank-account-summary-ii.sql ├── NOTES.md └── README.md ├── 1588-sum-of-all-odd-length-subarrays ├── 1588-sum-of-all-odd-length-subarrays.js ├── NOTES.md └── README.md ├── 1598-crawler-log-folder ├── 1598-crawler-log-folder.js ├── 1598-crawler-log-folder.py ├── NOTES.md └── README.md ├── 1603-design-parking-system ├── 1603-design-parking-system.js ├── NOTES.md └── README.md ├── 1603-running-sum-of-1d-array ├── 1603-running-sum-of-1d-array.js └── README.md ├── 1614-maximum-nesting-depth-of-the-parentheses ├── 1614-maximum-nesting-depth-of-the-parentheses.js ├── NOTES.md └── README.md ├── 1624-largest-substring-between-two-equal-characters ├── 1624-largest-substring-between-two-equal-characters.js ├── NOTES.md └── README.md ├── 1625-group-sold-products-by-the-date ├── 1625-group-sold-products-by-the-date.sql └── README.md ├── 1630-arithmetic-subarrays ├── 1630-arithmetic-subarrays.js ├── NOTES.md └── README.md ├── 1633-percentage-of-users-attended-a-contest ├── 1633-percentage-of-users-attended-a-contest.sql ├── NOTES.md └── README.md ├── 1636-sort-array-by-increasing-frequency ├── 1636-sort-array-by-increasing-frequency.js ├── NOTES.md └── README.md ├── 1672-richest-customer-wealth ├── 1672-richest-customer-wealth.js ├── NOTES.md └── README.md ├── 1683-invalid-tweets ├── 1683-invalid-tweets.sql ├── NOTES.md └── README.md ├── 1693-daily-leads-and-partners ├── 1693-daily-leads-and-partners.sql ├── NOTES.md └── README.md ├── 1700-number-of-students-unable-to-eat-lunch ├── 1700-number-of-students-unable-to-eat-lunch.js ├── NOTES.md └── README.md ├── 1729-find-followers-count ├── 1729-find-followers-count.sql ├── NOTES.md └── README.md ├── 1732-find-the-highest-altitude ├── 1732-find-the-highest-altitude.js ├── NOTES.md └── README.md ├── 1737-maximum-nesting-depth-of-the-parentheses ├── 1737-maximum-nesting-depth-of-the-parentheses.js └── README.md ├── 1748-sum-of-unique-elements ├── 1748-sum-of-unique-elements.js ├── NOTES.md └── README.md ├── 1768-merge-strings-alternately ├── 1768-merge-strings-alternately.js ├── NOTES.md └── README.md ├── 1773-count-items-matching-a-rule ├── 1773-count-items-matching-a-rule.js ├── NOTES.md └── README.md ├── 1816-truncate-sentence ├── 1816-truncate-sentence.js ├── NOTES.md └── README.md ├── 1817-finding-the-users-active-minutes ├── 1817-finding-the-users-active-minutes.js ├── NOTES.md └── README.md ├── 1865-finding-pairs-with-a-certain-sum ├── 1865-finding-pairs-with-a-certain-sum.js ├── NOTES.md └── README.md ├── 1873-calculate-special-bonus ├── 1873-calculate-special-bonus.sql └── README.md ├── 1876-substrings-of-size-three-with-distinct-characters ├── 1876-substrings-of-size-three-with-distinct-characters.js ├── NOTES.md └── README.md ├── 1877-find-followers-count ├── 1877-find-followers-count.sql └── README.md ├── 1903-largest-odd-number-in-string ├── 1903-largest-odd-number-in-string.js ├── NOTES.md └── README.md ├── 1920-build-array-from-permutation ├── 1920-build-array-from-permutation.js ├── NOTES.md └── README.md ├── 1929-concatenation-of-array ├── 1929-concatenation-of-array.js ├── NOTES.md └── README.md ├── 1965-employees-with-missing-information ├── 1965-employees-with-missing-information.sql ├── NOTES.md └── README.md ├── 1984-minimum-difference-between-highest-and-lowest-of-k-scores ├── 1984-minimum-difference-between-highest-and-lowest-of-k-scores.py ├── NOTES.md └── README.md ├── 1991-find-the-middle-index-in-array ├── 1991-find-the-middle-index-in-array.js ├── NOTES.md └── README.md ├── 2006-count-number-of-pairs-with-absolute-difference-k ├── 2006-count-number-of-pairs-with-absolute-difference-k.js ├── NOTES.md └── README.md ├── 2070-most-beautiful-item-for-each-query ├── 2070-most-beautiful-item-for-each-query.js ├── NOTES.md └── README.md ├── 2079-watering-plants ├── 2079-watering-plants.js ├── NOTES.md └── README.md ├── 2089-find-target-indices-after-sorting-array ├── 2089-find-target-indices-after-sorting-array.js ├── NOTES.md └── README.md ├── 2090-k-radius-subarray-averages ├── 2090-k-radius-subarray-averages.js ├── NOTES.md └── README.md ├── 2125-number-of-laser-beams-in-a-bank ├── 2125-number-of-laser-beams-in-a-bank.js ├── NOTES.md └── README.md ├── 2154-keep-multiplying-found-values-by-two ├── 2154-keep-multiplying-found-values-by-two.js ├── NOTES.md └── README.md ├── 2215-find-the-difference-of-two-arrays ├── 2215-find-the-difference-of-two-arrays.js ├── NOTES.md └── README.md ├── 2243-calculate-digit-sum-of-a-string ├── 2243-calculate-digit-sum-of-a-string.js ├── NOTES.md └── README.md ├── 2270-number-of-ways-to-split-array ├── 2270-number-of-ways-to-split-array.js ├── NOTES.md └── README.md ├── 2284-sender-with-largest-word-count ├── 2284-sender-with-largest-word-count.js ├── NOTES.md └── README.md ├── 2352-equal-row-and-column-pairs ├── 2352-equal-row-and-column-pairs.js ├── NOTES.md └── README.md ├── 2356-number-of-unique-subjects-taught-by-each-teacher ├── 2356-number-of-unique-subjects-taught-by-each-teacher.sql ├── NOTES.md └── README.md ├── 2373-largest-local-values-in-a-matrix ├── 2373-largest-local-values-in-a-matrix.js ├── NOTES.md └── README.md ├── 2389-longest-subsequence-with-limited-sum ├── 2389-longest-subsequence-with-limited-sum.js ├── NOTES.md └── README.md ├── 2390-removing-stars-from-a-string ├── 2390-removing-stars-from-a-string.js ├── NOTES.md └── README.md ├── 2391-minimum-amount-of-time-to-collect-garbage ├── 2391-minimum-amount-of-time-to-collect-garbage.js ├── NOTES.md └── README.md ├── 2404-most-frequent-even-element ├── 2404-most-frequent-even-element.js ├── NOTES.md └── README.md ├── 2418-sort-the-people ├── 2418-sort-the-people.js ├── NOTES.md └── README.md ├── 2428-maximum-sum-of-an-hourglass ├── 2428-maximum-sum-of-an-hourglass.js ├── NOTES.md └── README.md ├── 2455-average-value-of-even-numbers-that-are-divisible-by-three ├── 2455-average-value-of-even-numbers-that-are-divisible-by-three.js ├── NOTES.md └── README.md ├── 2460-apply-operations-to-an-array ├── 2460-apply-operations-to-an-array.js ├── NOTES.md └── README.md ├── 2465-number-of-distinct-averages ├── 2465-number-of-distinct-averages.js ├── NOTES.md └── README.md ├── 2470-removing-stars-from-a-string ├── 2470-removing-stars-from-a-string.js └── README.md ├── 2500-delete-greatest-value-in-each-row ├── 2500-delete-greatest-value-in-each-row.js ├── NOTES.md └── README.md ├── 2535-difference-between-element-sum-and-digit-sum-of-an-array ├── 2535-difference-between-element-sum-and-digit-sum-of-an-array.js ├── NOTES.md └── README.md ├── 2545-sort-the-students-by-their-kth-score ├── 2545-sort-the-students-by-their-kth-score.js ├── NOTES.md └── README.md ├── 2554-maximum-number-of-integers-to-choose-from-a-range-i ├── 2554-maximum-number-of-integers-to-choose-from-a-range-i.js ├── NOTES.md └── README.md ├── 2562-find-the-array-concatenation-value ├── 2562-find-the-array-concatenation-value.js ├── NOTES.md └── README.md ├── 2574-left-and-right-sum-differences ├── 2574-left-and-right-sum-differences.js ├── NOTES.md └── README.md ├── 2586-count-the-number-of-vowel-strings-in-range ├── 2586-count-the-number-of-vowel-strings-in-range.js ├── NOTES.md └── README.md ├── 2610-convert-an-array-into-a-2d-array-with-conditions ├── 2610-convert-an-array-into-a-2d-array-with-conditions.js ├── NOTES.md └── README.md ├── 2620-counter ├── 2620-counter.js ├── NOTES.md └── README.md ├── 2626-array-reduce-transformation ├── 2626-array-reduce-transformation.js ├── NOTES.md └── README.md ├── 2629-function-composition ├── 2629-function-composition.js ├── NOTES.md └── README.md ├── 2634-filter-elements-from-array ├── 2634-filter-elements-from-array.js ├── NOTES.md └── README.md ├── 2635-apply-transform-over-each-element-in-array ├── 2635-apply-transform-over-each-element-in-array.js ├── NOTES.md └── README.md ├── 2640-find-the-score-of-all-prefixes-of-an-array ├── 2640-find-the-score-of-all-prefixes-of-an-array.js ├── NOTES.md └── README.md ├── 2648-generate-fibonacci-sequence ├── 2648-generate-fibonacci-sequence.js ├── NOTES.md └── README.md ├── 2652-sum-multiples ├── 2652-sum-multiples.js ├── NOTES.md └── README.md ├── 2656-maximum-sum-with-exactly-k-elements ├── 2656-maximum-sum-with-exactly-k-elements.js ├── NOTES.md └── README.md ├── 2657-find-the-prefix-common-array-of-two-arrays ├── 2657-find-the-prefix-common-array-of-two-arrays.js ├── NOTES.md └── README.md ├── 2665-counter-ii ├── 2665-counter-ii.js ├── NOTES.md └── README.md ├── 2667-create-hello-world-function ├── 2667-create-hello-world-function.js ├── NOTES.md └── README.md ├── 2670-find-the-distinct-difference-array ├── 2670-find-the-distinct-difference-array.js ├── NOTES.md └── README.md ├── 2677-chunk-array ├── 2677-chunk-array.js ├── NOTES.md └── README.md ├── 2678-number-of-senior-citizens ├── 2678-number-of-senior-citizens.js ├── NOTES.md └── README.md ├── 2729-check-if-the-number-is-fascinating ├── 2729-check-if-the-number-is-fascinating.js ├── NOTES.md └── README.md ├── 2732-counter ├── 2732-counter.js └── README.md ├── 2785-sort-vowels-in-a-string ├── 2785-sort-vowels-in-a-string.js ├── NOTES.md └── README.md ├── 2809-create-hello-world-function ├── 2809-create-hello-world-function.js └── README.md ├── 2870-minimum-number-of-operations-to-make-array-empty ├── 2870-minimum-number-of-operations-to-make-array-empty.py ├── NOTES.md └── README.md └── README.md /0001-two-sum/0001-two-sum.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} target 4 | * @return {number[]} 5 | */ 6 | var twoSum = function(nums, target) { 7 | let map = new Map() 8 | 9 | for (let i = 0; i < nums.length; i++) { 10 | let cur = target-nums[i] 11 | if(map.has(cur)){ 12 | return [map.get(cur), i] 13 | } 14 | 15 | map.set(nums[i], i) 16 | 17 | } 18 | }; -------------------------------------------------------------------------------- /0001-two-sum/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0004-median-of-two-sorted-arrays/0004-median-of-two-sorted-arrays.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums1 3 | * @param {number[]} nums2 4 | * @return {number} 5 | */ 6 | var findMedianSortedArrays = function(nums1, nums2) { 7 | let merged = [...nums1, ...nums2].sort((a, b) => a - b); 8 | merged.sort((a, b) => a-b) 9 | let total = merged.length 10 | 11 | if(total % 2 === 0){ 12 | let mid = total / 2; 13 | return med = (merged[mid] + merged[mid-1]) / 2 14 | } else { 15 | return merged[Math.floor(total/2)] 16 | } 17 | }; -------------------------------------------------------------------------------- /0004-median-of-two-sorted-arrays/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0004-median-of-two-sorted-arrays/README.md: -------------------------------------------------------------------------------- 1 |

4. Median of Two Sorted Arrays

Hard

Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.

2 | 3 |

The overall run time complexity should be O(log (m+n)).

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: nums1 = [1,3], nums2 = [2]
 9 | Output: 2.00000
10 | Explanation: merged array = [1,2,3] and median is 2.
11 |
12 | 13 |

Example 2:

14 | 15 | 
Input: nums1 = [1,2], nums2 = [3,4]
16 | Output: 2.50000
17 | Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 | 31 |
-------------------------------------------------------------------------------- /0005-longest-palindromic-substring/0005-longest-palindromic-substring.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var longestPalindrome = function(s) { 6 | let maxLength = 0; 7 | let start = 0; 8 | 9 | const expandAroundCenter = (left, right) => { 10 | while (left >= 0 && right < s.length && s[left] === s[right]) { 11 | const currentLength = right - left + 1; 12 | if (currentLength > maxLength) { 13 | maxLength = currentLength; 14 | start = left; 15 | } 16 | left--; 17 | right++; 18 | } 19 | }; 20 | 21 | for (let i = 0; i < s.length; i++) { 22 | expandAroundCenter(i, i); // Untuk panjang palindrome ganjil 23 | expandAroundCenter(i, i + 1); // Untuk panjang palindrome genap 24 | } 25 | 26 | return s.slice(start, start + maxLength); 27 | }; -------------------------------------------------------------------------------- /0005-longest-palindromic-substring/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0005-longest-palindromic-substring/README.md: -------------------------------------------------------------------------------- 1 |

5. Longest Palindromic Substring

Medium

Given a string s, return the longest palindromic substring in s.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
Input: s = "babad"
 7 | Output: "bab"
 8 | Explanation: "aba" is also a valid answer.
 9 |
10 | 11 |

Example 2:

12 | 13 | 
Input: s = "cbbd"
14 | Output: "bb"
15 |
16 | 17 |

 

18 |

Constraints:

19 | 20 | 24 |
-------------------------------------------------------------------------------- /0013-roman-to-integer/0013-roman-to-integer.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var romanToInt = function(s) { 6 | const sym = { 7 | 'I': 1, 8 | 'V': 5, 9 | 'X': 10, 10 | 'L': 50, 11 | 'C': 100, 12 | 'D': 500, 13 | 'M': 1000 14 | } 15 | 16 | let result = 0; 17 | 18 | for (let i = 0; i < s.length; i++) { 19 | const cur = sym[s[i]]; 20 | const next = sym[s[i + 1]]; 21 | 22 | if (cur < next) { 23 | result += next - cur; 24 | i++; 25 | } else { 26 | result += cur; 27 | } 28 | } 29 | 30 | return result; 31 | }; -------------------------------------------------------------------------------- /0013-roman-to-integer/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0020-valid-parentheses/0020-valid-parentheses.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(item) { 7 | this.stack.push(item); 8 | } 9 | 10 | pop() { 11 | return this.stack.pop(); 12 | } 13 | 14 | peek() { 15 | return this.stack[this.stack.length - 1]; 16 | } 17 | 18 | isEmpty() { 19 | return this.stack.length === 0; 20 | } 21 | } 22 | 23 | var isValid = function(s) { 24 | if (s.length % 2 !== 0) return false; 25 | 26 | const stack = new Stack(); 27 | const map = { 28 | '(': ')', 29 | '{': '}', 30 | '[': ']', 31 | }; 32 | 33 | s.split("").forEach((c) => { 34 | if (map[c]) { 35 | stack.push(c); 36 | } else { 37 | if (stack.isEmpty() || map[stack.peek()] !== c) { 38 | stack.push(c); 39 | } else { 40 | stack.pop(); 41 | } 42 | } 43 | }); 44 | 45 | return stack.isEmpty(); 46 | }; 47 | 48 | 49 | // 50 | -------------------------------------------------------------------------------- /0020-valid-parentheses/0020-valid-parentheses.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isValid(self, s: str) -> bool: 3 | stack = [] 4 | 5 | for char in s: 6 | if char in ["(", "{", "["]: 7 | stack.append(char) 8 | elif char == ")" and stack and stack[-1] == "(": 9 | stack.pop() 10 | elif char == "}" and stack and stack[-1] == "{": 11 | stack.pop() 12 | elif char == "]" and stack and stack[-1] == "[": 13 | stack.pop() 14 | else: 15 | return False 16 | 17 | return not stack 18 | -------------------------------------------------------------------------------- /0020-valid-parentheses/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0020-valid-parentheses/README.md: -------------------------------------------------------------------------------- 1 |

20. Valid Parentheses

Easy

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

2 | 3 |

An input string is valid if:

4 | 5 |
    6 |
  1. Open brackets must be closed by the same type of brackets.
    2. 7 |
  2. Open brackets must be closed in the correct order.
    3. 8 |
  3. Every close bracket has a corresponding open bracket of the same type.
    4. 9 |
10 | 11 |

 

12 |

Example 1:

13 | 14 | 
Input: s = "()"
15 | Output: true
16 |
17 | 18 |

Example 2:

19 | 20 | 
Input: s = "()[]{}"
21 | Output: true
22 |
23 | 24 |

Example 3:

25 | 26 | 
Input: s = "(]"
27 | Output: false
28 |
29 | 30 |

 

31 |

Constraints:

32 | 33 | 37 |
-------------------------------------------------------------------------------- /0026-remove-duplicates-from-sorted-array/0026-remove-duplicates-from-sorted-array.js: -------------------------------------------------------------------------------- 1 | var removeDuplicates = function(nums) { 2 | if (nums.length === 0) return 0; // Memeriksa apakah array kosong 3 | 4 | let res = 1; 5 | let i = 0; 6 | 7 | while (i < nums.length - 1) { 8 | if (nums[i] !== nums[i + 1]) { 9 | nums[res] = nums[i + 1]; 10 | res++; 11 | } 12 | i++; 13 | } 14 | 15 | return res; 16 | }; 17 | 18 | -------------------------------------------------------------------------------- /0026-remove-duplicates-from-sorted-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0027-remove-element/0027-remove-element.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} val 4 | * @return {number} 5 | */ 6 | var removeElement = function(nums, val) { 7 | let res = 0; 8 | for(let i = 0; i < nums.length; i++){ 9 | if(nums[i] != val){ 10 | nums[res] = nums[i]; 11 | res++ 12 | } 13 | } 14 | 15 | return res 16 | }; -------------------------------------------------------------------------------- /0027-remove-element/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0028-find-the-index-of-the-first-occurrence-in-a-string/0028-find-the-index-of-the-first-occurrence-in-a-string.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} haystack 3 | * @param {string} needle 4 | * @return {number} 5 | */ 6 | var strStr = function(haystack, needle) { 7 | if (needle === "") { 8 | return 0; 9 | } 10 | 11 | for (let i = 0; i <= haystack.length - needle.length; i++) { 12 | let found = true; 13 | for (let j = 0; j < needle.length; j++) { 14 | if (haystack[i + j] !== needle[j]) { 15 | found = false; 16 | break; 17 | } 18 | } 19 | if (found) { 20 | return i; 21 | } 22 | } 23 | 24 | return -1; 25 | }; -------------------------------------------------------------------------------- /0028-find-the-index-of-the-first-occurrence-in-a-string/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0028-find-the-index-of-the-first-occurrence-in-a-string/README.md: -------------------------------------------------------------------------------- 1 |

28. Find the Index of the First Occurrence in a String

Easy

Given two strings needle and haystack, return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
Input: haystack = "sadbutsad", needle = "sad"
 7 | Output: 0
 8 | Explanation: "sad" occurs at index 0 and 6.
 9 | The first occurrence is at index 0, so we return 0.
10 |
11 | 12 |

Example 2:

13 | 14 | 
Input: haystack = "leetcode", needle = "leeto"
15 | Output: -1
16 | Explanation: "leeto" did not occur in "leetcode", so we return -1.
17 |
18 | 19 |

 

20 |

Constraints:

21 | 22 | 26 |
-------------------------------------------------------------------------------- /0035-search-insert-position/0035-search-insert-position.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} target 4 | * @return {number} 5 | */ 6 | var searchInsert = function(nums, target) { 7 | let start = 0; 8 | let end = nums.length-1; 9 | let ans = nums.length 10 | 11 | while(start <= end) { 12 | let mid = Math.floor((start + end) / 2); 13 | if (nums[mid] === target) { 14 | return mid; 15 | } 16 | if (nums[mid] < target) { 17 | start = mid + 1 18 | } 19 | if (nums[mid] > target) { 20 | ans = mid 21 | end = mid - 1 22 | } 23 | } 24 | 25 | return ans 26 | }; -------------------------------------------------------------------------------- /0035-search-insert-position/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0035-search-insert-position/README.md: -------------------------------------------------------------------------------- 1 |

35. Search Insert Position

Easy

Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

2 | 3 |

You must write an algorithm with O(log n) runtime complexity.

4 | 5 |

 

6 |

Example 1:

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

Example 2:

13 | 14 | 
Input: nums = [1,3,5,6], target = 2
15 | Output: 1
16 |
17 | 18 |

Example 3:

19 | 20 | 
Input: nums = [1,3,5,6], target = 7
21 | Output: 4
22 |
23 | 24 |

 

25 |

Constraints:

26 | 27 | 33 |
-------------------------------------------------------------------------------- /0058-length-of-last-word/0058-length-of-last-word.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var lengthOfLastWord = function(s) { 6 | let text = s.trim(); 7 | const myArray = text.split(" "); 8 | let filter = myArray.filter((element) => { 9 | return element !== ""; 10 | }); 11 | 12 | return filter[filter.length - 1].length 13 | }; -------------------------------------------------------------------------------- /0058-length-of-last-word/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0071-simplify-path/0071-simplify-path.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(item) { 7 | this.stack.push(item); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) { 12 | return "Stack kosong"; 13 | } 14 | return this.stack.pop(); 15 | } 16 | 17 | peek() { 18 | return this.stack[this.stack.length - 1]; 19 | } 20 | 21 | isEmpty() { 22 | return this.stack.length === 0; 23 | } 24 | 25 | join(){ 26 | return this.stack.join("/") 27 | } 28 | } 29 | 30 | const simplifyPath = function (path) { 31 | const stack = new Stack(); 32 | 33 | let split = path.split('/') 34 | 35 | for(const arr of split){ 36 | if(arr === "" || arr === ".") continue 37 | 38 | if(arr === ".."){ 39 | stack.pop() 40 | } else { 41 | stack.push(arr) 42 | } 43 | } 44 | return "/" + stack.join() 45 | }; -------------------------------------------------------------------------------- /0071-simplify-path/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0073-set-matrix-zeroes/0073-set-matrix-zeroes.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} matrix 3 | * @return {void} Do not return anything, modify matrix in-place instead. 4 | */ 5 | var setZeroes = function (matrix) { 6 | 7 | let found = []; 8 | for (let row = 0; row < matrix.length; row++) { 9 | for (let col = 0; col < matrix[0].length; col++) { 10 | if (matrix[row][col] === 0) { 11 | let foundAt = [row, col]; 12 | found.push(foundAt); 13 | } 14 | } 15 | } 16 | 17 | for (let i = 0; i < found.length; i++) { 18 | const [row, col] = found[i]; 19 | 20 | for (let i = 0; i < matrix.length; i++) { 21 | matrix[i][col] = 0 22 | } 23 | 24 | for (let i = 0; i < matrix[0].length; i++) { 25 | matrix[row][i] = 0 26 | } 27 | 28 | } 29 | 30 | return matrix 31 | }; -------------------------------------------------------------------------------- /0073-set-matrix-zeroes/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0074-search-a-2d-matrix/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0094-binary-tree-inorder-traversal/0094-binary-tree-inorder-traversal.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {number[]} 12 | */ 13 | var inorderTraversal = function(root) { 14 | let res = [] 15 | 16 | const dfs = (node) => { 17 | if(!node) return; 18 | 19 | dfs(node.left) 20 | res.push(node.val) 21 | dfs(node.right) 22 | } 23 | 24 | dfs(root) 25 | return res 26 | }; -------------------------------------------------------------------------------- /0094-binary-tree-inorder-traversal/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0094-binary-tree-inorder-traversal/README.md: -------------------------------------------------------------------------------- 1 |

94. Binary Tree Inorder Traversal

Easy

Given the root of a binary tree, return the inorder traversal of its nodes' values.

2 | 3 |

 

4 |

Example 1:

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

Example 2:

11 | 12 | 
Input: root = []
13 | Output: []
14 |
15 | 16 |

Example 3:

17 | 18 | 
Input: root = [1]
19 | Output: [1]
20 |
21 | 22 |

 

23 |

Constraints:

24 | 25 | 29 | 30 |

 

31 | Follow up: Recursive solution is trivial, could you do it iteratively?
-------------------------------------------------------------------------------- /0118-pascals-triangle/0118-pascals-triangle.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} numRows 3 | * @return {number[][]} 4 | */ 5 | var generate = function(numRows) { 6 | let res = []; 7 | if (numRows === 0){ 8 | return res; 9 | } 10 | 11 | res.push([1]); 12 | 13 | for (let i = 1; i < numRows; i++) { 14 | let list = []; 15 | list.push(1); 16 | 17 | for (let j = 1; j < res[i-1].length; j++) { 18 | let prev = res[i-1][j-1] 19 | let next = res[i-1][j] 20 | let sum = prev + next; 21 | list.push(sum); 22 | } 23 | 24 | list.push(1); 25 | 26 | res.push([...list]); 27 | } 28 | 29 | return res; 30 | }; -------------------------------------------------------------------------------- /0118-pascals-triangle/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0118-pascals-triangle/README.md: -------------------------------------------------------------------------------- 1 |

118. Pascal's Triangle

Easy

Given an integer numRows, return the first numRows of Pascal's triangle.

2 | 3 |

In Pascal's triangle, each number is the sum of the two numbers directly above it as shown:

4 | 5 |

 

6 |

Example 1:

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

Example 2:

10 | 
Input: numRows = 1
11 | Output: [[1]]
12 |
13 |

 

14 |

Constraints:

15 | 16 | 19 |
-------------------------------------------------------------------------------- /0121-best-time-to-buy-and-sell-stock/0121-best-time-to-buy-and-sell-stock.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxProfit(self, prices: List[int]) -> int: 3 | l = 0 4 | max_profit = 0 5 | 6 | for r in range(1, len(prices)): 7 | if prices[r] > prices[l]: 8 | cur_profit = prices[r] - prices[l] 9 | max_profit = max(max_profit, cur_profit) 10 | elif prices[r] < prices[l]: 11 | l = r 12 | 13 | return max_profit -------------------------------------------------------------------------------- /0121-best-time-to-buy-and-sell-stock/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0136-single-number/0136-single-number.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var singleNumber = function(nums) { 6 | let map = new Map(); 7 | 8 | nums.forEach((element, index) => { 9 | if (map.has(element) === false) { 10 | let temp = 0; 11 | map.set(element, temp + 1); 12 | } else { 13 | let temp = map.get(element); 14 | map.set(element, temp + 1); 15 | } 16 | }); 17 | 18 | map 19 | let res = 0; 20 | map.forEach((kunci, nilai) => { 21 | if (kunci === 1) { 22 | res = nilai; 23 | } 24 | }); 25 | 26 | return res; 27 | }; -------------------------------------------------------------------------------- /0136-single-number/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0136-single-number/README.md: -------------------------------------------------------------------------------- 1 |

136. Single Number

Easy

Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.

2 | 3 |

You must implement a solution with a linear runtime complexity and use only constant extra space.

4 | 5 |

 

6 |

Example 1:

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

Example 2:

10 | 
Input: nums = [4,1,2,1,2]
11 | Output: 4
12 |

Example 3:

13 | 
Input: nums = [1]
14 | Output: 1
15 |
16 |

 

17 |

Constraints:

18 | 19 | 24 |
-------------------------------------------------------------------------------- /0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {number[]} 12 | */ 13 | var preorderTraversal = function(root) { 14 | let res = [] 15 | 16 | const dfs = (node) => { 17 | if(!node) return; 18 | 19 | res.push(node.val) 20 | dfs(node.left) 21 | dfs(node.right) 22 | } 23 | 24 | dfs(root) 25 | return res 26 | }; -------------------------------------------------------------------------------- /0144-binary-tree-preorder-traversal/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0144-binary-tree-preorder-traversal/README.md: -------------------------------------------------------------------------------- 1 |

144. Binary Tree Preorder Traversal

Easy

Given the root of a binary tree, return the preorder traversal of its nodes' values.

2 | 3 |

 

4 |

Example 1:

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

Example 2:

11 | 12 | 
Input: root = []
13 | Output: []
14 |
15 | 16 |

Example 3:

17 | 18 | 
Input: root = [1]
19 | Output: [1]
20 |
21 | 22 |

 

23 |

Constraints:

24 | 25 | 29 | 30 |

 

31 |

Follow up: Recursive solution is trivial, could you do it iteratively?

32 |
-------------------------------------------------------------------------------- /0145-binary-tree-postorder-traversal/0145-binary-tree-postorder-traversal.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {number[]} 12 | */ 13 | var postorderTraversal = function(root) { 14 | let res = [] 15 | 16 | const dfs = (node) => { 17 | if(!node) return; 18 | 19 | dfs(node.left) 20 | dfs(node.right) 21 | res.push(node.val) 22 | } 23 | 24 | dfs(root) 25 | return res 26 | }; -------------------------------------------------------------------------------- /0145-binary-tree-postorder-traversal/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0145-binary-tree-postorder-traversal/README.md: -------------------------------------------------------------------------------- 1 |

145. Binary Tree Postorder Traversal

Easy

Given the root of a binary tree, return the postorder traversal of its nodes' values.

2 | 3 |

 

4 |

Example 1:

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

Example 2:

11 | 12 | 
Input: root = []
13 | Output: []
14 |
15 | 16 |

Example 3:

17 | 18 | 
Input: root = [1]
19 | Output: [1]
20 |
21 | 22 |

 

23 |

Constraints:

24 | 25 | 29 | 30 |

 

31 | Follow up: Recursive solution is trivial, could you do it iteratively?
-------------------------------------------------------------------------------- /0162-find-peak-element/0162-find-peak-element.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | function findPeakElement(nums) { 6 | let left = 0; 7 | let right = nums.length - 1; 8 | while (left <= right) { 9 | let mid = Math.floor(left + (right - left) / 2); 10 | 11 | if ( 12 | nums[mid] > (nums[mid - 1] || -Infinity) && 13 | nums[mid] > (nums[mid + 1] || -Infinity) 14 | ) return mid; 15 | else if (nums[mid - 1] > nums[mid + 1]) right = mid - 1; 16 | else left = mid + 1; 17 | } 18 | } -------------------------------------------------------------------------------- /0162-find-peak-element/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0169-majority-element/0169-majority-element.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var majorityElement = function(nums) { 6 | const n = nums.length; 7 | const map = new Map(); 8 | for (let i = 0; i < n; i++) { 9 | map.set(nums[i], (map.get(nums[i]) || 0) + 1); 10 | if (map.get(nums[i]) > n / 2) return nums[i]; 11 | } 12 | return -1; 13 | }; -------------------------------------------------------------------------------- /0169-majority-element/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0169-majority-element/README.md: -------------------------------------------------------------------------------- 1 |

169. Majority Element

Easy

Given an array nums of size n, return the majority element.

2 | 3 |

The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.

4 | 5 |

 

6 |

Example 1:

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

Example 2:

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

 

14 |

Constraints:

15 | 16 | 21 | 22 |

 

23 | Follow-up: Could you solve the problem in linear time and in O(1) space?
-------------------------------------------------------------------------------- /0175-combine-two-tables/0175-combine-two-tables.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT p.firstName, p.lastName, a.city, a.state 3 | FROM Person p 4 | LEFT JOIN Address a ON p.personId = a.personId 5 | -------------------------------------------------------------------------------- /0175-combine-two-tables/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0182-duplicate-emails/0182-duplicate-emails.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT email 3 | FROM Person 4 | GROUP BY email 5 | HAVING count(email) > 1 -------------------------------------------------------------------------------- /0182-duplicate-emails/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0183-customers-who-never-order/0183-customers-who-never-order.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT name as Customers 4 | FROM Customers c 5 | LEFT JOIN Orders o 6 | ON c.id = o.customerId 7 | WHERE o.id IS NULL -------------------------------------------------------------------------------- /0184-department-highest-salary/0184-department-highest-salary.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT d.name AS Department, e.name AS Employee, e.salary AS Salary 3 | FROM Employee e 4 | JOIN Department d ON e.departmentId = d.id 5 | WHERE (e.departmentId, e.salary) IN ( 6 | SELECT departmentId, MAX(salary) 7 | FROM Employee 8 | GROUP BY departmentId 9 | ) 10 | 11 | 12 | -------------------------------------------------------------------------------- /0184-department-highest-salary/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0197-rising-temperature/0197-rising-temperature.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT 4 | w1.Id 5 | FROM weather w1, weather w2 6 | WHERE DATEDIFF(w1.RecordDate, w2.RecordDate) = 1 AND w1.Temperature > w2.Temperature; 7 | -------------------------------------------------------------------------------- /0197-rising-temperature/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0202-happy-number/0202-happy-number.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {boolean} 4 | */ 5 | var isHappy = function(n) { 6 | function getNext(n) { 7 | let totalSum = 0; 8 | while (n > 0) { 9 | let d = n % 10; 10 | n = Math.floor(n / 10); 11 | totalSum += d * d; 12 | } 13 | return totalSum; 14 | } 15 | 16 | let seen = new Set(); 17 | while (n !== 1 && !seen.has(n)) { 18 | seen.add(n); 19 | n = getNext(n); 20 | } 21 | return n === 1; 22 | }; -------------------------------------------------------------------------------- /0202-happy-number/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0205-isomorphic-strings/0205-isomorphic-strings.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @param {string} t 4 | * @return {boolean} 5 | */ 6 | var isIsomorphic = function(s, t) { 7 | //jika jumlah tidak sama maka false 8 | if (s.length != t.length) return false; 9 | 10 | let temp_1 = []; 11 | let temp_2 = []; 12 | 13 | for (let i = 0; i < s.length; i++) { 14 | temp_1.push(s.indexOf(s[i])); 15 | temp_2.push(t.indexOf(t[i])); 16 | 17 | //ketika tidak sama, berarti terdapat item yang sama, karena akan mengeluarkan index yang sudah ada 18 | if (temp_1[i] != temp_2[i]) return false; 19 | } 20 | return true; 21 | }; -------------------------------------------------------------------------------- /0205-isomorphic-strings/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0205-isomorphic-strings/README.md: -------------------------------------------------------------------------------- 1 |

205. Isomorphic Strings

Easy

Given two strings s and t, determine if they are isomorphic.

2 | 3 |

Two strings s and t are isomorphic if the characters in s can be replaced to get t.

4 | 5 |

All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character, but a character may map to itself.

6 | 7 |

 

8 |

Example 1:

9 | 
Input: s = "egg", t = "add"
10 | Output: true
11 |

Example 2:

12 | 
Input: s = "foo", t = "bar"
13 | Output: false
14 |

Example 3:

15 | 
Input: s = "paper", t = "title"
16 | Output: true
17 |
18 |

 

19 |

Constraints:

20 | 21 | 26 |
-------------------------------------------------------------------------------- /0209-minimum-size-subarray-sum/0209-minimum-size-subarray-sum.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} target 3 | * @param {number[]} nums 4 | * @return {number} 5 | */ 6 | var minSubArrayLen = function(target, array) { 7 | const n = array.length; 8 | let minLength = Infinity; 9 | let sum = 0; 10 | let left = 0; 11 | 12 | for (let right = 0; right < n; right++) { 13 | sum += array[right]; 14 | 15 | while (sum >= target) { 16 | minLength = Math.min(minLength, right - left + 1); 17 | sum -= array[left]; 18 | left++; 19 | } 20 | } 21 | return minLength === Infinity ? 0 : minLength; 22 | }; -------------------------------------------------------------------------------- /0209-minimum-size-subarray-sum/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0217-contains-duplicate/0217-contains-duplicate.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {boolean} 4 | */ 5 | var containsDuplicate = function(nums) { 6 | let map = new Map(); 7 | 8 | nums.forEach(element => { 9 | if(map.has(element) === false){ 10 | let temp = 0 11 | map.set(element, temp+1) 12 | } else { 13 | let temp = map.get(element) 14 | map.set(element, temp+1) 15 | } 16 | }); 17 | 18 | for (let index = 0; index < nums.length; index++) { 19 | if(map.get(nums[index])>1) return true 20 | } 21 | 22 | return false 23 | }; -------------------------------------------------------------------------------- /0217-contains-duplicate/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0217-contains-duplicate/README.md: -------------------------------------------------------------------------------- 1 |

217. Contains Duplicate

Easy

Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.

2 | 3 |

 

4 |

Example 1:

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

Example 2:

8 | 
Input: nums = [1,2,3,4]
 9 | Output: false
10 |

Example 3:

11 | 
Input: nums = [1,1,1,3,3,4,3,2,4,2]
12 | Output: true
13 |
14 |

 

15 |

Constraints:

16 | 17 | 21 |
-------------------------------------------------------------------------------- /0228-summary-ranges/0228-summary-ranges.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {string[]} 4 | */ 5 | var summaryRanges = function(nums) { 6 | const res = []; 7 | 8 | let i = 0; 9 | while (i < nums.length) { 10 | let start, last; 11 | start = nums[i]; 12 | 13 | //melakukan perulangan dari index awal, jika index selanjutnya lebih dari i+1, maka berhenti 14 | while (i + 1 < nums.length && nums[i + 1] == nums[i] + 1) { 15 | i++; 16 | } 17 | 18 | last = nums[i]; 19 | //jika awal dan akhirnya sama, berarti hanya satu index 20 | if (start == last) { 21 | res.push(start + ""); 22 | } else { 23 | res.push(start + "->" + last); 24 | } 25 | 26 | i++; 27 | } 28 | 29 | return res; 30 | }; -------------------------------------------------------------------------------- /0228-summary-ranges/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0258-add-digits/0258-add-digits.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} num 3 | * @return {number} 4 | */ 5 | const addDigits = (num) => { 6 | let result = Infinity; 7 | 8 | if (num === 0) return 0; 9 | 10 | while (true) { 11 | if (result < 10) return result; 12 | digVal = (num % 10) + Math.floor(num / 10); 13 | result = digVal; 14 | result 15 | num = digVal; 16 | } 17 | }; -------------------------------------------------------------------------------- /0258-add-digits/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0258-add-digits/README.md: -------------------------------------------------------------------------------- 1 |

258. Add Digits

Easy

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

2 | 3 |

 

4 |

Example 1:

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

Example 2:

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

 

21 |

Constraints:

22 | 23 | 26 | 27 |

 

28 |

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

29 |
-------------------------------------------------------------------------------- /0290-word-pattern/0290-word-pattern.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} pattern 3 | * @param {string} s 4 | * @return {boolean} 5 | */ 6 | var wordPattern = function(pattern, s) { 7 | let map1 = new Map(); 8 | let map2 = new Map(); 9 | 10 | let split_pattern = pattern.split(""); 11 | let split_s = s.split(" "); 12 | 13 | if (split_pattern.length !== split_s.length) { 14 | return false; 15 | } 16 | 17 | for (let i = 0; i < split_pattern.length; i++) { 18 | const char = split_pattern[i]; 19 | const word = split_s[i]; 20 | 21 | if (map1.has(char)) { 22 | if (map1.get(char) !== word) { 23 | return false; 24 | } 25 | } else { 26 | map1.set(char, word); 27 | } 28 | 29 | if (map2.has(word)) { 30 | if (map2.get(word) !== char) { 31 | return false; 32 | } 33 | } else { 34 | map2.set(word, char); 35 | } 36 | } 37 | 38 | return true; 39 | }; -------------------------------------------------------------------------------- /0290-word-pattern/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0303-range-sum-query-immutable/0303-range-sum-query-immutable.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | */ 4 | var NumArray = function(nums) { 5 | this.prefixSum = nums.slice(); 6 | //rumus prefixSum 7 | for (let i = 1; i < this.prefixSum.length; i++) { 8 | this.prefixSum[i] = this.prefixSum[i - 1] + nums[i]; 9 | } 10 | }; 11 | 12 | /** 13 | * @param {number} left 14 | * @param {number} right 15 | * @return {number} 16 | */ 17 | NumArray.prototype.sumRange = function(left, right) { 18 | if (left === 0) { 19 | return this.prefixSum[right]; 20 | } 21 | return this.prefixSum[right] - this.prefixSum[left - 1]; 22 | }; 23 | 24 | /** 25 | * Your NumArray object will be instantiated and called as such: 26 | * var obj = new NumArray(nums) 27 | * var param_1 = obj.sumRange(left,right) 28 | */ -------------------------------------------------------------------------------- /0303-range-sum-query-immutable/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0344-reverse-string/0344-reverse-string.js: -------------------------------------------------------------------------------- 1 | function swap(arr, i, j) { 2 | [arr[i], arr[j]] = [arr[j], arr[i]]; 3 | } 4 | 5 | 6 | var reverseString = function(s) { 7 | let i = 0 8 | let j = s.length - 1 9 | 10 | while(i < j){ 11 | swap(s, i, j) 12 | i++ 13 | j-- 14 | } 15 | 16 | if(i === j){ 17 | s[i] = s[j] 18 | } 19 | }; -------------------------------------------------------------------------------- /0344-reverse-string/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0344-reverse-string/README.md: -------------------------------------------------------------------------------- 1 |

344. Reverse String

Easy

Write a function that reverses a string. The input string is given as an array of characters s.

2 | 3 |

You must do this by modifying the input array in-place with O(1) extra memory.

4 | 5 |

 

6 |

Example 1:

7 | 
Input: s = ["h","e","l","l","o"]
 8 | Output: ["o","l","l","e","h"]
 9 |

Example 2:

10 | 
Input: s = ["H","a","n","n","a","h"]
11 | Output: ["h","a","n","n","a","H"]
12 |
13 |

 

14 |

Constraints:

15 | 16 | 20 |
-------------------------------------------------------------------------------- /0345-reverse-vowels-of-a-string/0345-reverse-vowels-of-a-string.js: -------------------------------------------------------------------------------- 1 | var reverseVowels = function (s) { 2 | let stack = [] 3 | 4 | let vowel = 'aiueoAIUEO' 5 | let split = s.split("") 6 | for (let i = 0; i < split.length; i++) { 7 | if(vowel.includes(split[i])) stack.push(split[i]) 8 | } 9 | 10 | let res = [] 11 | for (let i = 0; i < split.length; i++) { 12 | if(vowel.includes(split[i].toLowerCase())){ 13 | res.push(stack.pop()) 14 | } else { 15 | res.push(split[i]) 16 | } 17 | } 18 | 19 | return res.join("") 20 | }; -------------------------------------------------------------------------------- /0345-reverse-vowels-of-a-string/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0345-reverse-vowels-of-a-string/README.md: -------------------------------------------------------------------------------- 1 |

345. Reverse Vowels of a String

Easy

Given a string s, reverse only all the vowels in the string and return it.

2 | 3 |

The vowels are 'a', 'e', 'i', 'o', and 'u', and they can appear in both lower and upper cases, more than once.

4 | 5 |

 

6 |

Example 1:

7 | 
Input: s = "hello"
 8 | Output: "holle"
 9 |

Example 2:

10 | 
Input: s = "leetcode"
11 | Output: "leotcede"
12 |
13 |

 

14 |

Constraints:

15 | 16 | 20 |
-------------------------------------------------------------------------------- /0347-top-k-frequent-elements/0347-top-k-frequent-elements.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {number[]} 5 | */ 6 | var topKFrequent = function(nums, k) { 7 | const map = new Map(); 8 | for (const num of nums) { 9 | map.set(num, (map.get(num) || 0) + 1); 10 | } 11 | 12 | const result = Array.from(map.entries()) 13 | .sort((a, b) => b[1] - a[1]) 14 | .slice(0, k) 15 | .map(([key]) => key); 16 | 17 | return result; 18 | }; -------------------------------------------------------------------------------- /0347-top-k-frequent-elements/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0349-intersection-of-two-arrays/0349-intersection-of-two-arrays.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums1 3 | * @param {number[]} nums2 4 | * @return {number[]} 5 | */ 6 | var intersection = function(nums1, nums2) { 7 | let arr=[] 8 | let obj={}; 9 | for(let i=0;i349. Intersection of Two Arrays

Easy

Given two integer arrays nums1 and nums2, return an array of their intersection. Each element in the result must be unique and you may return the result in any order.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
Input: nums1 = [1,2,2,1], nums2 = [2,2]
 7 | Output: [2]
 8 |
9 | 10 |

Example 2:

11 | 12 | 
Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
13 | Output: [9,4]
14 | Explanation: [4,9] is also accepted.
15 |
16 | 17 |

 

18 |

Constraints:

19 | 20 | 24 |
-------------------------------------------------------------------------------- /0442-find-all-duplicates-in-an-array/0442-find-all-duplicates-in-an-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var findDuplicates = function(nums) { 6 | const counter = {}; 7 | const duplicates = []; 8 | 9 | nums.forEach(num => { 10 | counter[num] = (counter[num] || 0) + 1; 11 | if (counter[num] === 2) { 12 | duplicates.push(num); 13 | } 14 | }); 15 | 16 | return duplicates; 17 | }; -------------------------------------------------------------------------------- /0442-find-all-duplicates-in-an-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0442-find-all-duplicates-in-an-array/README.md: -------------------------------------------------------------------------------- 1 |

442. Find All Duplicates in an Array

Medium

Given an integer array nums of length n where all the integers of nums are in the range [1, n] and each integer appears once or twice, return an array of all the integers that appears twice.

2 | 3 |

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

4 | 5 |

 

6 |

Example 1:

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

Example 2:

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

Example 3:

13 | 
Input: nums = [1]
14 | Output: []
15 |
16 |

 

17 |

Constraints:

18 | 19 | 25 |
-------------------------------------------------------------------------------- /0448-find-all-numbers-disappeared-in-an-array/0448-find-all-numbers-disappeared-in-an-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var findDisappearedNumbers = function(nums) { 6 | let res = [] 7 | 8 | let map = new Map() 9 | for (let i = 0; i < nums.length; i++) { 10 | const element = nums[i] 11 | map.set(element, (map.get(element) || 0) + 1) 12 | } 13 | for (let i = 1; i <= nums.length; i++) { 14 | if(!map.has(i)) res.push(i) 15 | } 16 | return res 17 | }; -------------------------------------------------------------------------------- /0448-find-all-numbers-disappeared-in-an-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0448-find-all-numbers-disappeared-in-an-array/README.md: -------------------------------------------------------------------------------- 1 |

448. Find All Numbers Disappeared in an Array

Easy

Given an array nums of n integers where nums[i] is in the range [1, n], return an array of all the integers in the range [1, n] that do not appear in nums.

2 | 3 |

 

4 |

Example 1:

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

Example 2:

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

 

12 |

Constraints:

13 | 14 | 19 | 20 |

 

21 |

Follow up: Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.

22 |
-------------------------------------------------------------------------------- /0451-sort-characters-by-frequency/0451-sort-characters-by-frequency.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var frequencySort = function(s) { 6 | let map = new Map() 7 | let res = [] 8 | for (let i = 0; i < s.length; i++) { 9 | const element = s[i]; 10 | map.set(element, (map.get(element) || 0) + 1) 11 | } 12 | 13 | const result = Array.from(map.entries()).sort((a, b) => b[1] - a[1]); 14 | 15 | for (let i = 0; i < result.length; i++) { 16 | for (let j = 0; j < result[i][1]; j++) { 17 | res.push(result[i][0]) 18 | } 19 | } 20 | 21 | return res.join("") 22 | }; -------------------------------------------------------------------------------- /0451-sort-characters-by-frequency/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0496-next-greater-element-i/0496-next-greater-element-i.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums1 3 | * @param {number[]} nums2 4 | * @return {number[]} 5 | */ 6 | var nextGreaterElement = function(nums1, nums2) { 7 | const hashmap = {}; 8 | const output = []; 9 | 10 | for (let i = 0; i < nums2.length; i++) { 11 | hashmap[nums2[i]] = i; 12 | } 13 | 14 | for (let i = 0; i < nums1.length; i++) { 15 | const number = nums1[i]; 16 | for (let j = hashmap[number]; j < nums2.length; j++) { 17 | if (nums2[j] > number) { 18 | output.push(nums2[j]); 19 | break; 20 | } 21 | if (j === nums2.length - 1) { 22 | output.push(-1); 23 | } 24 | } 25 | } 26 | 27 | return output; 28 | }; -------------------------------------------------------------------------------- /0496-next-greater-element-i/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0511-game-play-analysis-i/0511-game-play-analysis-i.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT player_id, MIN(event_date) as 'first_login' 4 | FROM Activity 5 | GROUP BY player_id -------------------------------------------------------------------------------- /0511-game-play-analysis-i/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0530-minimum-absolute-difference-in-bst/0530-minimum-absolute-difference-in-bst.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {number} 12 | */ 13 | var getMinimumDifference = function(root) { 14 | let minDiff = Infinity; 15 | let prevValue = null; 16 | 17 | function dfs(node) { 18 | if (node === null) { 19 | return; 20 | } 21 | dfs(node.left); 22 | if (prevValue !== null) { 23 | minDiff = Math.min(minDiff, Math.abs(node.val - prevValue)); 24 | } 25 | prevValue = node.val; 26 | dfs(node.right); 27 | } 28 | 29 | dfs(root); 30 | return minDiff; 31 | }; -------------------------------------------------------------------------------- /0530-minimum-absolute-difference-in-bst/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0530-minimum-absolute-difference-in-bst/README.md: -------------------------------------------------------------------------------- 1 |

530. Minimum Absolute Difference in BST

Easy

Given the root of a Binary Search Tree (BST), return the minimum absolute difference between the values of any two different nodes in the tree.

2 | 3 |

 

4 |

Example 1:

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

Example 2:

11 | 12 | 
Input: root = [1,0,48,null,null,12,49]
13 | Output: 1
14 |
15 | 16 |

 

17 |

Constraints:

18 | 19 | 23 | 24 |

 

25 |

Note: This question is the same as 783: https://leetcode.com/problems/minimum-distance-between-bst-nodes/

26 |
-------------------------------------------------------------------------------- /0532-k-diff-pairs-in-an-array/0532-k-diff-pairs-in-an-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {number} 5 | */ 6 | var findPairs = function(nums, k) { 7 | let set = new Set(); 8 | 9 | for (let i = 0; i < nums.length; i++) { 10 | const element = nums[i]; 11 | for (let j = i + 1; j < nums.length; j++) { 12 | const diff = nums[j]; 13 | if (diff === element + k || diff === element - k) { 14 | const smaller = Math.min(element, diff); 15 | const larger = Math.max(element, diff); 16 | set.add(`${smaller}, ${larger}`); 17 | } 18 | } 19 | } 20 | 21 | return set.size; 22 | }; -------------------------------------------------------------------------------- /0532-k-diff-pairs-in-an-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0535-encode-and-decode-tinyurl/0535-encode-and-decode-tinyurl.js: -------------------------------------------------------------------------------- 1 | const linkCode = new Map(); 2 | const urlAsli = new Map(); 3 | const chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; 4 | 5 | const getCode = () => 6 | "http://tinyurl.com/" + 7 | Array.from({ length: 6 }, () => chars.charAt(Math.random() * 62)).join(""); 8 | 9 | const encode = (longUrl) => { 10 | if (urlAsli.has(longUrl)) { 11 | return urlAsli.get(longUrl); 12 | } 13 | 14 | let code = getCode(); 15 | while (linkCode.has(code)) { 16 | code = getCode(); 17 | } 18 | 19 | linkCode.set(code, longUrl); 20 | urlAsli.set(longUrl, code); 21 | 22 | return code; 23 | }; 24 | 25 | const decode = (shortUrl) => linkCode.get(shortUrl); -------------------------------------------------------------------------------- /0535-encode-and-decode-tinyurl/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0557-reverse-words-in-a-string-iii/0557-reverse-words-in-a-string-iii.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var reverseWords = function(s) { 6 | let split = s.split(' ') 7 | let res = [] 8 | 9 | split.forEach((element, index) => { 10 | let reverseKata = element.split('') 11 | for (let i = reverseKata.length-1; i >= 0; i--) { 12 | res.push(reverseKata[i]); 13 | } 14 | index === split.length - 1 ? res.push() : res.push(' '); 15 | }) 16 | return res.join('') 17 | }; -------------------------------------------------------------------------------- /0557-reverse-words-in-a-string-iii/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0557-reverse-words-in-a-string-iii/README.md: -------------------------------------------------------------------------------- 1 |

557. Reverse Words in a String III

Easy

Given a string s, reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.

2 | 3 |

 

4 |

Example 1:

5 | 
Input: s = "Let's take LeetCode contest"
 6 | Output: "s'teL ekat edoCteeL tsetnoc"
 7 |

Example 2:

8 | 
Input: s = "God Ding"
 9 | Output: "doG gniD"
10 |
11 |

 

12 |

Constraints:

13 | 14 | 21 |
-------------------------------------------------------------------------------- /0595-big-countries/0595-big-countries.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT name, population, area 3 | FROM world 4 | WHERE area >= 3000000 OR population >= 25000000 5 | ORDER BY name -------------------------------------------------------------------------------- /0595-big-countries/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0596-classes-more-than-5-students/0596-classes-more-than-5-students.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | 4 | SELECT class 5 | FROM Courses 6 | GROUP BY class 7 | HAVING count(class) >= 5 -------------------------------------------------------------------------------- /0596-classes-more-than-5-students/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0605-can-place-flowers/0605-can-place-flowers.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} flowerbed 3 | * @param {number} n 4 | * @return {boolean} 5 | */ 6 | var canPlaceFlowers = function (flowerbed, n) { 7 | for (let i = 0; i < flowerbed.length; i++) { 8 | if (flowerbed[i] === 1) continue; 9 | 10 | if ( 11 | (i === 0 || flowerbed[i - 1] === 0) && 12 | (i === flowerbed.length - 1 || flowerbed[i + 1] === 0) 13 | ) { 14 | flowerbed[i] = 1; 15 | n--; 16 | } 17 | } 18 | 19 | return n <= 0; 20 | }; -------------------------------------------------------------------------------- /0605-can-place-flowers/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0605-can-place-flowers/README.md: -------------------------------------------------------------------------------- 1 |

605. Can Place Flowers

Easy

You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots.

2 | 3 |

Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, return true if n new flowers can be planted in the flowerbed without violating the no-adjacent-flowers rule and false otherwise.

4 | 5 |

 

6 |

Example 1:

7 | 
Input: flowerbed = [1,0,0,0,1], n = 1
 8 | Output: true
 9 |

Example 2:

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

 

14 |

Constraints:

15 | 16 | 22 |
-------------------------------------------------------------------------------- /0619-biggest-single-number/0619-biggest-single-number.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT ifnull( 4 | (SELECT num 5 | FROM MyNumbers 6 | GROUP BY num 7 | HAVING count(*)=1 8 | ORDER BY num DESC limit 1),null) AS num -------------------------------------------------------------------------------- /0619-biggest-single-number/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0620-not-boring-movies/0620-not-boring-movies.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT id, movie, description, rating 4 | FROM Cinema 5 | WHERE id % 2 = 1 AND description != "boring" 6 | ORDER BY rating DESC 7 | 8 | -------------------------------------------------------------------------------- /0620-not-boring-movies/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0627-swap-salary/0627-swap-salary.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | UPDATE salary 4 | SET sex = CASE 5 | WHEN sex = 'm' THEN 'f' 6 | WHEN sex = 'f' THEN 'm' 7 | END -------------------------------------------------------------------------------- /0627-swap-salary/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0682-baseball-game/0682-baseball-game.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(item) { 7 | this.stack.push(item); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) { 12 | return "Stack kosong"; 13 | } 14 | return this.stack.pop(); 15 | } 16 | 17 | peek() { 18 | return this.stack[this.stack.length - 1]; 19 | } 20 | 21 | isEmpty() { 22 | return this.stack.length === 0; 23 | } 24 | 25 | plus(){ 26 | return parseInt(this.stack[this.stack.length - 1]) + parseInt(this.stack[this.stack.length - 2]) 27 | } 28 | 29 | getSum(){ 30 | let sum = 0 31 | for (let i = 0; i < this.stack.length; i++) { 32 | sum+= parseInt(this.stack[i]); 33 | } 34 | return sum 35 | } 36 | } 37 | 38 | 39 | var calPoints = function (operations) { 40 | let stack = new Stack(); 41 | 42 | let sum = 0 43 | operations.forEach((element) => { 44 | if (element === "C") { 45 | stack.pop() 46 | } else if(element === "D"){ 47 | stack.push(stack.peek() * 2) 48 | } else if(element === "+"){ 49 | stack.push(stack.plus()) 50 | } else { 51 | stack.push(element) 52 | } 53 | }); 54 | 55 | return stack.getSum() 56 | }; 57 | 58 | console.log(calPoints(["5", "2", "C", "D", "+"])); 59 | -------------------------------------------------------------------------------- /0682-baseball-game/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0692-top-k-frequent-words/0692-top-k-frequent-words.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} words 3 | * @param {number} k 4 | * @return {string[]} 5 | */ 6 | var topKFrequent = function (words, k) { 7 | let map = new Map(); 8 | words.forEach((element) => map.set(element, (map.get(element) || 0) + 1)); 9 | 10 | return Array.from(map.entries()).sort((a, b) => { 11 | let countCompare = b[1] - a[1]; 12 | //bandingkan sesuai leksikografis jika value nya sama 13 | if (countCompare === 0) { 14 | return a[0].localeCompare(b[0]); 15 | } else { 16 | return countCompare; 17 | } 18 | }).slice(0, k).map((entry) => entry[0]) 19 | }; -------------------------------------------------------------------------------- /0692-top-k-frequent-words/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0705-design-hashset/0705-design-hashset.js: -------------------------------------------------------------------------------- 1 | var MyHashSet = function () { 2 | this.set = new Set() 3 | }; 4 | 5 | /** 6 | * @param {number} key 7 | * @return {void} 8 | */ 9 | MyHashSet.prototype.add = function (key) { 10 | this.set.add(key) 11 | }; 12 | 13 | /** 14 | * @param {number} key 15 | * @return {void} 16 | */ 17 | MyHashSet.prototype.remove = function (key) { 18 | this.set.delete(key) 19 | }; 20 | 21 | /** 22 | * @param {number} key 23 | * @return {boolean} 24 | */ 25 | MyHashSet.prototype.contains = function (key) { 26 | return this.set.has(key) 27 | }; 28 | 29 | /** 30 | * Your MyHashSet object will be instantiated and called as such: 31 | * var obj = new MyHashSet() 32 | * obj.add(key) 33 | * obj.remove(key) 34 | * var param_3 = obj.contains(key) 35 | */ -------------------------------------------------------------------------------- /0705-design-hashset/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0706-design-hashmap/0706-design-hashmap.js: -------------------------------------------------------------------------------- 1 | var MyHashMap = function () { 2 | this.map = new Map() 3 | }; 4 | 5 | /** 6 | * @param {number} key 7 | * @param {number} value 8 | * @return {void} 9 | */ 10 | MyHashMap.prototype.put = function (key, value) { 11 | this.map.set(key, value) 12 | }; 13 | 14 | /** 15 | * @param {number} key 16 | * @return {number} 17 | */ 18 | MyHashMap.prototype.get = function (key) { 19 | if(this.map.has(key)){ 20 | return this.map.get(key) 21 | } else { 22 | return -1 23 | } 24 | }; 25 | 26 | /** 27 | * @param {number} key 28 | * @return {void} 29 | */ 30 | MyHashMap.prototype.remove = function (key) { 31 | this.map.delete(key) 32 | }; -------------------------------------------------------------------------------- /0706-design-hashmap/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0724-find-pivot-index/0724-find-pivot-index.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var pivotIndex = function (nums) { 6 | //melalukan rumus prefix sum 7 | let prefixSum = []; 8 | prefixSum[0] = nums[0] 9 | for (let i = 1; i < nums.length; i++) { 10 | prefixSum[i] = prefixSum[i-1] + nums[i] 11 | } 12 | 13 | //melakukan perulangan sampai mendapatkan value yang sama 14 | for (let i = 0; i < nums.length; i++) { 15 | let a = prefixSum[i-1]; 16 | if(!a) a=0 17 | const b = prefixSum[nums.length - 1] - prefixSum[i+1-1] 18 | if(a==b) return i 19 | } 20 | 21 | //kembalikan -1 jika tidak ada yang sama di perulangan sblmnya 22 | return -1; 23 | }; -------------------------------------------------------------------------------- /0724-find-pivot-index/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0783-minimum-distance-between-bst-nodes/0783-minimum-distance-between-bst-nodes.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {number} 12 | */ 13 | var minDiffInBST = function(root) { 14 | let min = Number.MAX_SAFE_INTEGER; 15 | let prev = null 16 | 17 | const dfs = (node) => { 18 | if(!node) return; 19 | 20 | dfs(node.left) 21 | if(prev != null) { 22 | min = Math.min(min, node.val-prev) 23 | } 24 | prev = node.val 25 | dfs(node.right) 26 | } 27 | 28 | dfs(root) 29 | return min 30 | }; -------------------------------------------------------------------------------- /0783-minimum-distance-between-bst-nodes/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0783-minimum-distance-between-bst-nodes/README.md: -------------------------------------------------------------------------------- 1 |

783. Minimum Distance Between BST Nodes

Easy

Given the root of a Binary Search Tree (BST), return the minimum difference between the values of any two different nodes in the tree.

2 | 3 |

 

4 |

Example 1:

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

Example 2:

11 | 12 | 
Input: root = [1,0,48,null,null,12,49]
13 | Output: 1
14 |
15 | 16 |

 

17 |

Constraints:

18 | 19 | 23 | 24 |

 

25 |

Note: This question is the same as 530: https://leetcode.com/problems/minimum-absolute-difference-in-bst/

26 |
-------------------------------------------------------------------------------- /0791-custom-sort-string/0791-custom-sort-string.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} order 3 | * @param {string} s 4 | * @return {string} 5 | */ 6 | const customSortString = (order, s) => { 7 | let orderMap = new Map(); 8 | for (let i = 0; i < order.length; i++) { 9 | orderMap.set(order[i], i); 10 | } 11 | 12 | let chars = s.split(""); 13 | 14 | chars.sort((a, b) => (orderMap.get(a) || 0) - (orderMap.get(b) || 0)); 15 | 16 | let sortedString = chars.join(""); 17 | 18 | return sortedString; 19 | }; -------------------------------------------------------------------------------- /0791-custom-sort-string/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0804-unique-morse-code-words/0804-unique-morse-code-words.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} words 3 | * @return {number} 4 | */ 5 | 6 | const alphabet = { 7 | a: '.-', b: '-...', c: '-.-.', d: '-..', e: '.', f: '..-.', g: '--.', h: '....', i: '..', j: '.---', k: '-.-', l: '.-..', m: '--', 8 | n: '-.', o: '---', p: '.--.', q: '--.-', r: '.-.', s: '...', t: '-', u: '..-', v: '...-', w: '.--', x: '-..-', y: '-.--', z: '--..' 9 | } 10 | 11 | var uniqueMorseRepresentations = function(words) { 12 | let morses = words.map((word) => { 13 | let chars = [...word]; 14 | let morse = chars.map((char) => alphabet[char]).join(""); 15 | return morse; 16 | }); 17 | 18 | let uniqueSet = new Set(morses); 19 | return uniqueSet.size; 20 | }; -------------------------------------------------------------------------------- /0832-flipping-an-image/0832-flipping-an-image.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} image 3 | * @return {number[][]} 4 | */ 5 | var flipAndInvertImage = function(image) { 6 | let res = [] 7 | 8 | image.forEach(element => { 9 | let reversed = element.reverse() 10 | let temp = [] 11 | reversed.map((element) => { 12 | if(element === 0){ 13 | temp.push(1) 14 | } else { 15 | temp.push(0) 16 | } 17 | }) 18 | res.push([...temp]) 19 | }); 20 | 21 | return res 22 | }; -------------------------------------------------------------------------------- /0832-flipping-an-image/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0844-backspace-string-compare/0844-backspace-string-compare.js: -------------------------------------------------------------------------------- 1 | class Stack{ 2 | constructor(){ 3 | this.stack = [] 4 | } 5 | 6 | push(element){ 7 | this.stack.push(element) 8 | } 9 | 10 | pop(){ 11 | if(this.isEmpty()) return "Stack Kosong" 12 | return this.stack.pop() 13 | } 14 | 15 | isEmpty(){ 16 | return this.stack.length === 0 17 | } 18 | 19 | peek(){ 20 | return this.stack[this.stack.length - 1] 21 | } 22 | 23 | size(){ 24 | return this.stack.length 25 | } 26 | 27 | print(){ 28 | let string = "" 29 | for(let i = 0; i < this.stack.length; i++){ 30 | string += this.stack[i] 31 | } 32 | return string 33 | } 34 | } 35 | 36 | 37 | 38 | var backspaceCompare = function(s, t) { 39 | let stack1 = new Stack() 40 | let stack2 = new Stack() 41 | 42 | s.split("").forEach((element) => { 43 | if(element === "#"){ 44 | stack1.pop() 45 | } else { 46 | stack1.push(element) 47 | } 48 | }) 49 | 50 | t.split("").forEach((element) => { 51 | if(element === "#"){ 52 | stack2.pop() 53 | } else { 54 | stack2.push(element) 55 | } 56 | }) 57 | 58 | return stack1.print() === stack2.print() 59 | 60 | }; -------------------------------------------------------------------------------- /0844-backspace-string-compare/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0852-peak-index-in-a-mountain-array/0852-peak-index-in-a-mountain-array.js: -------------------------------------------------------------------------------- 1 | var peakIndexInMountainArray = function (arr) { 2 | let left = 0; 3 | let right = arr.length - 1; 4 | 5 | while (left <= right) { 6 | let mid = Math.floor((left + right) / 2); 7 | 8 | if (arr[mid] < arr[mid - 1]) { 9 | right = mid - 1; 10 | } else { 11 | left = mid + 1 12 | } 13 | } 14 | 15 | return right 16 | }; -------------------------------------------------------------------------------- /0852-peak-index-in-a-mountain-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0867-transpose-matrix/0867-transpose-matrix.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} matrix 3 | * @return {number[][]} 4 | */ 5 | var transpose = function(matrix) { 6 | let res = [] 7 | for (let i = 0; i < matrix[0].length; i++) { 8 | let temp = [] 9 | for (let j = 0; j < matrix.length; j++) { 10 | let tranpose = matrix[j][i] 11 | temp.push(tranpose) 12 | } 13 | res.push(temp) 14 | } 15 | 16 | return res 17 | }; -------------------------------------------------------------------------------- /0867-transpose-matrix/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0867-transpose-matrix/README.md: -------------------------------------------------------------------------------- 1 |

867. Transpose Matrix

Easy

Given a 2D integer array matrix, return the transpose of matrix.

2 | 3 |

The transpose of a matrix is the matrix flipped over its main diagonal, switching the matrix's row and column indices.

4 | 5 |

6 | 7 |

 

8 |

Example 1:

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

Example 2:

15 | 16 | 
Input: matrix = [[1,2,3],[4,5,6]]
17 | Output: [[1,4],[2,5],[3,6]]
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 | 30 |
-------------------------------------------------------------------------------- /0874-backspace-string-compare/0874-backspace-string-compare.js: -------------------------------------------------------------------------------- 1 | class Stack{ 2 | constructor(){ 3 | this.stack = [] 4 | } 5 | 6 | push(element){ 7 | this.stack.push(element) 8 | } 9 | 10 | pop(){ 11 | if(this.isEmpty()) return "Stack Kosong" 12 | return this.stack.pop() 13 | } 14 | 15 | isEmpty(){ 16 | return this.stack.length === 0 17 | } 18 | 19 | peek(){ 20 | return this.stack[this.stack.length - 1] 21 | } 22 | 23 | size(){ 24 | return this.stack.length 25 | } 26 | 27 | print(){ 28 | let string = "" 29 | for(let i = 0; i < this.stack.length; i++){ 30 | string += this.stack[i] 31 | } 32 | return string 33 | } 34 | } 35 | 36 | 37 | 38 | var backspaceCompare = function(s, t) { 39 | let stack1 = new Stack() 40 | let stack2 = new Stack() 41 | 42 | s.split("").forEach((element) => { 43 | if(element === "#"){ 44 | stack1.pop() 45 | } else { 46 | stack1.push(element) 47 | } 48 | }) 49 | 50 | t.split("").forEach((element) => { 51 | if(element === "#"){ 52 | stack2.pop() 53 | } else { 54 | stack2.push(element) 55 | } 56 | }) 57 | 58 | return stack1.print() === stack2.print() 59 | 60 | }; -------------------------------------------------------------------------------- /0905-sort-array-by-parity/0905-sort-array-by-parity.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var sortArrayByParity = function(nums) { 6 | let res = [] 7 | let even = [] ; let odd = [] 8 | nums.map((element) => { 9 | if(element % 2 === 0){ 10 | even.push(element) 11 | } else { 12 | odd.push(element) 13 | } 14 | }) 15 | 16 | return res.concat(even, odd) 17 | }; -------------------------------------------------------------------------------- /0905-sort-array-by-parity/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0905-sort-array-by-parity/README.md: -------------------------------------------------------------------------------- 1 |

905. Sort Array By Parity

Easy

Given an integer array nums, move all the even integers at the beginning of the array followed by all the odd integers.

2 | 3 |

Return any array that satisfies this condition.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: nums = [3,1,2,4]
 9 | Output: [2,4,3,1]
10 | Explanation: The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
11 |
12 | 13 |

Example 2:

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

 

20 |

Constraints:

21 | 22 | 26 |
-------------------------------------------------------------------------------- /0929-unique-email-addresses/0929-unique-email-addresses.js: -------------------------------------------------------------------------------- 1 | var numUniqueEmails = function (emails) { 2 | let counter = new Set(); 3 | for (let email of emails) { 4 | let splited = email.split("@") 5 | let local = splited[0].split("+") 6 | let localfiltered = local[0].replaceAll(".", "") 7 | counter.add(localfiltered+"@"+splited[1]) 8 | } 9 | return counter.size 10 | }; -------------------------------------------------------------------------------- /0929-unique-email-addresses/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0961-n-repeated-element-in-size-2n-array/0961-n-repeated-element-in-size-2n-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var repeatedNTimes = function(nums) { 6 | const map = new Map(); 7 | for (const num of nums) { 8 | map.set(num, (map.get(num) || 0) + 1); 9 | if (map.get(num) === nums.length / 2) return num; 10 | } 11 | }; 12 | -------------------------------------------------------------------------------- /0961-n-repeated-element-in-size-2n-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0961-n-repeated-element-in-size-2n-array/README.md: -------------------------------------------------------------------------------- 1 |

961. N-Repeated Element in Size 2N Array

Easy

You are given an integer array nums with the following properties:

2 | 3 | 8 | 9 |

Return the element that is repeated n times.

10 | 11 |

 

12 |

Example 1:

13 | 
Input: nums = [1,2,3,3]
14 | Output: 3
15 |

Example 2:

16 | 
Input: nums = [2,1,2,5,3,2]
17 | Output: 2
18 |

Example 3:

19 | 
Input: nums = [5,1,5,2,5,3,5,4]
20 | Output: 5
21 |
22 |

 

23 |

Constraints:

24 | 25 | 31 |
-------------------------------------------------------------------------------- /0977-squares-of-a-sorted-array/0977-squares-of-a-sorted-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var sortedSquares = function(nums) { 6 | let res = nums.map((number)=>{ 7 | return Math.abs(number)**2 8 | }).sort((a,b) => a-b) 9 | return res 10 | }; -------------------------------------------------------------------------------- /0977-squares-of-a-sorted-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0977-squares-of-a-sorted-array/README.md: -------------------------------------------------------------------------------- 1 |

977. Squares of a Sorted Array

Easy

Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
Input: nums = [-4,-1,0,3,10]
 7 | Output: [0,1,9,16,100]
 8 | Explanation: After squaring, the array becomes [16,1,0,9,100].
 9 | After sorting, it becomes [0,1,9,16,100].
10 |
11 | 12 |

Example 2:

13 | 14 | 
Input: nums = [-7,-3,2,3,11]
15 | Output: [4,9,9,49,121]
16 |
17 | 18 |

 

19 |

Constraints:

20 | 21 | 26 | 27 |

 

28 | Follow up: Squaring each element and sorting the new array is very trivial, could you find an O(n) solution using a different approach?
-------------------------------------------------------------------------------- /0985-sum-of-even-numbers-after-queries/0985-sum-of-even-numbers-after-queries.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number[][]} queries 4 | * @return {number[]} 5 | */ 6 | var sumEvenAfterQueries = function(nums, queries) { 7 | let res = []; 8 | let evenSum = nums.reduce((acc, curr) => acc + (curr % 2 === 0 ? curr : 0), 0); 9 | 10 | for (let i = 0; i < queries.length; i++) { 11 | const val = queries[i][0]; 12 | const index = queries[i][1]; 13 | const prevNum = nums[index]; 14 | const newNum = prevNum + val; 15 | 16 | if (prevNum % 2 === 0) { 17 | evenSum -= prevNum; 18 | } 19 | if (newNum % 2 === 0) { 20 | evenSum += newNum; 21 | } 22 | 23 | nums[index] = newNum; 24 | res.push(evenSum); 25 | } 26 | 27 | return res; 28 | }; 29 | -------------------------------------------------------------------------------- /0985-sum-of-even-numbers-after-queries/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0989-add-to-array-form-of-integer/0989-add-to-array-form-of-integer.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def addToArrayForm(self, num: List[int], k: int) -> List[int]: 3 | 4 | sisa = 0 5 | len_a = len(num) - 1 6 | len_b = len(str(k)) - 1 7 | 8 | res = [] 9 | 10 | while len_a >= 0 or len_b >= 0 or sisa: 11 | # digit_a = int(num[len_a]) if len_a >= 0 else 0 12 | # digit_b = int(k[len_b]) if len_b >= 0 else 0 13 | digit_a = num[len_a] if len_a >= 0 else 0 14 | digit_b = int(str(k)[len_b]) if len_b >= 0 else 0 15 | 16 | total = digit_a + digit_b + sisa 17 | hasil = total % 10 18 | sisa = total // 10 19 | 20 | res.insert(0, hasil) 21 | 22 | len_a -= 1 23 | len_b -= 1 24 | 25 | return res -------------------------------------------------------------------------------- /0989-add-to-array-form-of-integer/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1047-remove-all-adjacent-duplicates-in-string/1047-remove-all-adjacent-duplicates-in-string.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(element) { 7 | this.stack.push(element); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) return "Stack Kosong"; 12 | return this.stack.pop(); 13 | } 14 | 15 | isEmpty() { 16 | return this.stack.length === 0; 17 | } 18 | 19 | peek() { 20 | return this.stack[this.stack.length - 1]; 21 | } 22 | 23 | size() { 24 | return this.stack.length; 25 | } 26 | 27 | print() { 28 | let string = ""; 29 | for (let i = 0; i < this.stack.length; i++) { 30 | string += this.stack[i]; 31 | } 32 | return string; 33 | } 34 | } 35 | 36 | var removeDuplicates = function (s) { 37 | let stack = new Stack(); 38 | 39 | for (let i = 0; i < s.length; i++) { 40 | const element = s[i]; 41 | element 42 | if(stack.isEmpty() || stack.peek() !== element) { 43 | stack.push(element) 44 | } else { 45 | stack.pop() 46 | } 47 | } 48 | 49 | return stack.print(); 50 | }; 51 | -------------------------------------------------------------------------------- /1047-remove-all-adjacent-duplicates-in-string/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1050-actors-and-directors-who-cooperated-at-least-three-times/1050-actors-and-directors-who-cooperated-at-least-three-times.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT actor_id, director_id 4 | FROM ActorDirector 5 | GROUP BY actor_id, director_id 6 | HAVING COUNT(timestamp) >= 3 -------------------------------------------------------------------------------- /1050-actors-and-directors-who-cooperated-at-least-three-times/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1051-height-checker/1051-height-checker.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} heights 3 | * @return {number} 4 | */ 5 | var heightChecker = function(heights) { 6 | let res = 0 7 | const sorted = [...heights].sort((a, b) => a - b); 8 | for (let i = 0; i < heights.length; i++) { 9 | if(heights[i] !== sorted[i]) res++ 10 | } 11 | return res 12 | }; -------------------------------------------------------------------------------- /1051-height-checker/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1068-product-sales-analysis-i/1068-product-sales-analysis-i.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT p.product_name, s.year, s.price 4 | FROM Sales s 5 | JOIN Product p ON s.product_id = p.product_id -------------------------------------------------------------------------------- /1068-product-sales-analysis-i/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1075-project-employees-i/1075-project-employees-i.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT project_id, ROUND(AVG(experience_years),2) as average_years 4 | FROM Project p 5 | JOIN Employee e ON p.employee_id = e.employee_id 6 | GROUP BY p.project_id -------------------------------------------------------------------------------- /1075-project-employees-i/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1108-defanging-an-ip-address/1108-defanging-an-ip-address.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} address 3 | * @return {string} 4 | */ 5 | var defangIPaddr = function(address) { 6 | return address.replaceAll('.','[.]') 7 | }; -------------------------------------------------------------------------------- /1108-defanging-an-ip-address/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1108-defanging-an-ip-address/README.md: -------------------------------------------------------------------------------- 1 |

1108. Defanging an IP Address

Easy

Given a valid (IPv4) IP address, return a defanged version of that IP address.

2 | 3 |

A defanged IP address replaces every period "." with "[.]".

4 | 5 |

 

6 |

Example 1:

7 | 
Input: address = "1.1.1.1"
 8 | Output: "1[.]1[.]1[.]1"
 9 |

Example 2:

10 | 
Input: address = "255.100.50.0"
11 | Output: "255[.]100[.]50[.]0"
12 |
13 |

 

14 |

Constraints:

15 | 16 |
-------------------------------------------------------------------------------- /1122-relative-sort-array/1122-relative-sort-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} arr1 3 | * @param {number[]} arr2 4 | * @return {number[]} 5 | */ 6 | var relativeSortArray = function(arr1, arr2) { 7 | let res = []; 8 | let sisa = []; 9 | 10 | let map = new Map(); 11 | arr2.forEach((element) => { 12 | if (!map.has(element)) { 13 | map.set(element, 0); 14 | } 15 | }); 16 | 17 | arr1.forEach((element) => { 18 | if (!map.has(element)) { 19 | sisa.push(element); 20 | } else { 21 | map.set(element, map.get(element) + 1); 22 | } 23 | }); 24 | 25 | map.forEach((element, index) => { 26 | for (let i = 0; i < element; i++) { 27 | res.push(index); 28 | } 29 | }); 30 | 31 | return res.concat(sisa.sort((a, b) => a - b)); 32 | }; -------------------------------------------------------------------------------- /1122-relative-sort-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1122-relative-sort-array/README.md: -------------------------------------------------------------------------------- 1 |

1122. Relative Sort Array

Easy

Given two arrays arr1 and arr2, the elements of arr2 are distinct, and all elements in arr2 are also in arr1.

2 | 3 |

Sort the elements of arr1 such that the relative ordering of items in arr1 are the same as in arr2. Elements that do not appear in arr2 should be placed at the end of arr1 in ascending order.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
 9 | Output: [2,2,2,1,4,3,3,9,6,7,19]
10 |
11 | 12 |

Example 2:

13 | 14 | 
Input: arr1 = [28,6,22,8,44,17], arr2 = [22,28,8,6]
15 | Output: [22,28,8,6,17,44]
16 |
17 | 18 |

 

19 |

Constraints:

20 | 21 | 27 |
-------------------------------------------------------------------------------- /1128-remove-all-adjacent-duplicates-in-string/1128-remove-all-adjacent-duplicates-in-string.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(element) { 7 | this.stack.push(element); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) return "Stack Kosong"; 12 | return this.stack.pop(); 13 | } 14 | 15 | isEmpty() { 16 | return this.stack.length === 0; 17 | } 18 | 19 | peek() { 20 | return this.stack[this.stack.length - 1]; 21 | } 22 | 23 | size() { 24 | return this.stack.length; 25 | } 26 | 27 | print() { 28 | let string = ""; 29 | for (let i = 0; i < this.stack.length; i++) { 30 | string += this.stack[i]; 31 | } 32 | return string; 33 | } 34 | } 35 | 36 | var removeDuplicates = function (s) { 37 | let stack = new Stack(); 38 | 39 | for (let i = 0; i < s.length; i++) { 40 | const element = s[i]; 41 | element 42 | if(stack.isEmpty() || stack.peek() !== element) { 43 | stack.push(element) 44 | } else { 45 | stack.pop() 46 | } 47 | } 48 | 49 | return stack.print(); 50 | }; 51 | -------------------------------------------------------------------------------- /1136-actors-and-directors-who-cooperated-at-least-three-times/1136-actors-and-directors-who-cooperated-at-least-three-times.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT actor_id, director_id 4 | FROM ActorDirector 5 | GROUP BY actor_id, director_id 6 | HAVING COUNT(timestamp) >= 3 -------------------------------------------------------------------------------- /1158-market-analysis-i/1158-market-analysis-i.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT u.user_id as buyer_id, u.join_date, COUNT(order_id) as orders_in_2019 3 | 4 | FROM Users u 5 | LEFT JOIN Orders o 6 | ON u.user_id = o.buyer_id 7 | 8 | AND YEAR(o.order_date)=2019 9 | GROUP BY u.user_id 10 | -------------------------------------------------------------------------------- /1158-market-analysis-i/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1268-market-analysis-i/1268-market-analysis-i.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT u.user_id as buyer_id, u.join_date, COUNT(order_id) as orders_in_2019 3 | 4 | FROM Users u 5 | LEFT JOIN Orders o 6 | ON u.user_id = o.buyer_id 7 | 8 | AND YEAR(o.order_date)=2019 9 | GROUP BY u.user_id 10 | -------------------------------------------------------------------------------- /1282-group-the-people-given-the-group-size-they-belong-to/1282-group-the-people-given-the-group-size-they-belong-to.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} groupSizes 3 | * @return {number[][]} 4 | */ 5 | var groupThePeople = function(groupSizes) { 6 | const result = []; 7 | const map = new Map(); 8 | 9 | for (let index = 0; index < groupSizes.length; index++) { 10 | const groupSize = groupSizes[index]; 11 | 12 | //periksa apakah sudah ada key nya atau belum, 13 | //jika tidak buat key dengan value array temp 14 | if (map.has(groupSize) === false) { 15 | map.set(groupSize, []); 16 | } 17 | 18 | //masukan index(index) ke array temp tadi 19 | map.get(groupSize).push(index); 20 | 21 | //cek terlebih dahulu jika size array sama dengan value groupsize 22 | if (map.get(groupSize).length === groupSize) { 23 | //masukan temp array tadi ke result 24 | let arr = map.get(groupSize) 25 | result.push(arr); 26 | //hapus key sebelumnya 27 | map.delete(groupSize); 28 | } 29 | } 30 | 31 | return result; 32 | }; -------------------------------------------------------------------------------- /1282-group-the-people-given-the-group-size-they-belong-to/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1323-maximum-69-number/1323-maximum-69-number.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} num 3 | * @return {number} 4 | */ 5 | var maximum69Number = function (num) { 6 | let curMax = num; 7 | 8 | let length = num.toString().split("").length 9 | 10 | for (let i = 0; i < length; i++) { 11 | let temp = num.toString().split("") 12 | if(temp[i] === "6") { 13 | temp[i] = '9' 14 | } else { 15 | temp[i] = '6' 16 | } 17 | 18 | curMax = Math.max(curMax, temp.join("")) 19 | } 20 | 21 | return curMax 22 | }; -------------------------------------------------------------------------------- /1323-maximum-69-number/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold/1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} arr 3 | * @param {number} k 4 | * @param {number} threshold 5 | * @return {number} 6 | */ 7 | var numOfSubarrays = function(arr, k, threshold) { 8 | let res = 0; 9 | let windowSum = 0; 10 | 11 | for (let i = 0; i < k; i++) { 12 | windowSum += arr[i]; 13 | } 14 | 15 | if (windowSum / k >= threshold) { 16 | res++; 17 | } 18 | 19 | for (let i = k; i < arr.length; i++) { 20 | let nextWindow = arr[i] 21 | let prevWindow = arr[i-k] 22 | windowSum += nextWindow - prevWindow; 23 | if (windowSum / k >= threshold) { 24 | res++; 25 | } 26 | } 27 | 28 | return res; 29 | 30 | }; -------------------------------------------------------------------------------- /1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1351-count-negative-numbers-in-a-sorted-matrix/1351-count-negative-numbers-in-a-sorted-matrix.js: -------------------------------------------------------------------------------- 1 | function binarySearch(arr) { 2 | let left = 0; 3 | let right = arr.length - 1; 4 | 5 | while (left <= right) { 6 | let mid = Math.floor((left + right) / 2); 7 | 8 | if (arr[mid] < 0) { 9 | right = mid - 1; 10 | } else { 11 | left = mid + 1; 12 | } 13 | } 14 | 15 | return left; 16 | } 17 | 18 | var countNegatives = function (grid) { 19 | let res = 0; 20 | for (let i = 0; i < grid.length; i++) { 21 | res += grid[i].length - binarySearch(grid[i]); 22 | } 23 | 24 | return res; 25 | }; 26 | -------------------------------------------------------------------------------- /1351-count-negative-numbers-in-a-sorted-matrix/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1351-count-negative-numbers-in-a-sorted-matrix/README.md: -------------------------------------------------------------------------------- 1 |

1351. Count Negative Numbers in a Sorted Matrix

Easy

Given a m x n matrix grid which is sorted in non-increasing order both row-wise and column-wise, return the number of negative numbers in grid.

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
Input: grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
 7 | Output: 8
 8 | Explanation: There are 8 negatives number in the matrix.
 9 |
10 | 11 |

Example 2:

12 | 13 | 
Input: grid = [[3,2],[1,0]]
14 | Output: 0
15 |
16 | 17 |

 

18 |

Constraints:

19 | 20 | 26 | 27 |

 

28 | Follow up: Could you find an O(n + m) solution?
-------------------------------------------------------------------------------- /1357-apply-discount-every-n-orders/1357-apply-discount-every-n-orders.js: -------------------------------------------------------------------------------- 1 | class Cashier { 2 | constructor(n, discount, products, prices) { 3 | this.map = new Map(); 4 | for (let i = 0; i < products.length; i++) { 5 | this.map.set(products[i], prices[i]); 6 | } 7 | 8 | this.n = n; 9 | this.discount = discount; 10 | this.count = 0; 11 | } 12 | 13 | getBill(product, amount) { 14 | this.total = 0; 15 | this.barang = 0; 16 | for (let i = 0; i < product.length; i++) { 17 | let jumlah_barang = amount[i]; 18 | this.barang++; 19 | this.total += this.map.get(product[i]) * jumlah_barang; 20 | } 21 | 22 | this.count++; 23 | if (this.count === this.n) { 24 | this.count = 0; 25 | return this.total * ((100 - this.discount) / 100); 26 | } 27 | 28 | return this.total; 29 | } 30 | } -------------------------------------------------------------------------------- /1357-apply-discount-every-n-orders/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1365-how-many-numbers-are-smaller-than-the-current-number/1365-how-many-numbers-are-smaller-than-the-current-number.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var smallerNumbersThanCurrent = function(nums) { 6 | let res = [] 7 | 8 | for (let i = 0; i < nums.length; i++) { 9 | let count = 0 10 | for (let j = 0; j < nums.length; j++) { 11 | if(nums[j] < nums[i]) count++ 12 | } 13 | res.push(count) 14 | 15 | } 16 | 17 | return res 18 | }; -------------------------------------------------------------------------------- /1365-how-many-numbers-are-smaller-than-the-current-number/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1381-design-a-stack-with-increment-operation/1381-design-a-stack-with-increment-operation.js: -------------------------------------------------------------------------------- 1 | class CustomStack { 2 | constructor(maxSize) { 3 | this.stack = [] 4 | this.count = 0 5 | this.maxSize = maxSize 6 | } 7 | 8 | push(element) { 9 | if(this.count !== this.maxSize) { 10 | this.stack.push(element) 11 | this.count = this.count + 1 12 | } 13 | } 14 | 15 | pop() { 16 | if (this.isEmpty()) { 17 | return -1; 18 | } else { 19 | this.count-- 20 | return this.stack.pop(); 21 | } 22 | } 23 | 24 | isEmpty() { 25 | return this.stack.length === 0; 26 | } 27 | 28 | peek() { 29 | return this.stack[this.stack.length - 1]; 30 | } 31 | 32 | increment(k, val){ 33 | for (let i = 0; i < Math.min(k, this.count); i++) { 34 | this.stack[i] = this.stack[i] + val 35 | } 36 | } 37 | 38 | } 39 | 40 | /** 41 | * Your CustomStack object will be instantiated and called as such: 42 | * var obj = new CustomStack(maxSize) 43 | * obj.push(x) 44 | * var param_2 = obj.pop() 45 | * obj.increment(k,val) 46 | */ -------------------------------------------------------------------------------- /1381-design-a-stack-with-increment-operation/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1393-capital-gain-loss/1393-capital-gain-loss.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT stock_name, SUM(CASE WHEN operation = "Buy" THEN price * -1 ELSE price END) as 'capital_gain_loss' 4 | FROM Stocks 5 | GROUP BY stock_name 6 | ORDER BY capital_gain_loss DESC -------------------------------------------------------------------------------- /1393-capital-gain-loss/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1394-find-lucky-integer-in-an-array/1394-find-lucky-integer-in-an-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} arr 3 | * @return {number} 4 | */ 5 | var findLucky = function(arr) { 6 | const frequency = {}; 7 | 8 | // Menghitung frekuensi setiap elemen dalam array 9 | for (let i = 0; i < arr.length; i++) { 10 | const num = arr[i]; 11 | if (frequency[num]) { 12 | frequency[num]++; 13 | } else { 14 | frequency[num] = 1; 15 | } 16 | } 17 | 18 | frequency 19 | 20 | // Mencari angka beruntung (lucky number) 21 | let luckyNumber = -1; 22 | for (const key in frequency) { 23 | if (parseInt(key) === frequency[key]) { 24 | luckyNumber = Math.max(luckyNumber, parseInt(key)); 25 | } 26 | } 27 | 28 | return luckyNumber; 29 | }; -------------------------------------------------------------------------------- /1394-find-lucky-integer-in-an-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1394-find-lucky-integer-in-an-array/README.md: -------------------------------------------------------------------------------- 1 |

1394. Find Lucky Integer in an Array

Easy

Given an array of integers arr, a lucky integer is an integer that has a frequency in the array equal to its value.

2 | 3 |

Return the largest lucky integer in the array. If there is no lucky integer return -1.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: arr = [2,2,3,4]
 9 | Output: 2
10 | Explanation: The only lucky number in the array is 2 because frequency[2] == 2.
11 |
12 | 13 |

Example 2:

14 | 15 | 
Input: arr = [1,2,2,3,3,3]
16 | Output: 3
17 | Explanation: 1, 2 and 3 are all lucky numbers, return the largest of them.
18 |
19 | 20 |

Example 3:

21 | 22 | 
Input: arr = [2,2,2,3,3]
23 | Output: -1
24 | Explanation: There are no lucky numbers in the array.
25 |
26 | 27 |

 

28 |

Constraints:

29 | 30 | 34 |
-------------------------------------------------------------------------------- /1407-top-travellers/1407-top-travellers.sql: -------------------------------------------------------------------------------- 1 | SELECT u.name, sum(IF(distance is NULL,0,distance)) as travelled_distance 2 | FROM Users u 3 | LEFT JOIN Rides r ON u.id = r.user_id 4 | GROUP BY u.id 5 | ORDER BY travelled_distance DESC, u.name ASC; 6 | -------------------------------------------------------------------------------- /1407-top-travellers/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1436-destination-city/1436-destination-city.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[][]} paths 3 | * @return {string} 4 | */ 5 | var destCity = function (paths) { 6 | let set = new Set(); 7 | 8 | paths.forEach((path) => { 9 | set.add(path[1]); 10 | }); 11 | 12 | paths.forEach((path) => { 13 | if(set.has(path[0])) set.delete(path[0]) 14 | }) 15 | 16 | let res = '' 17 | set.forEach((element)=>{ 18 | res = element 19 | }) 20 | 21 | return res 22 | }; -------------------------------------------------------------------------------- /1436-destination-city/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1484-group-sold-products-by-the-date/1484-group-sold-products-by-the-date.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT sell_date, count(DISTINCT(product)) as num_sold, 3 | GROUP_CONCAT(DISTINCT product ORDER BY product ASC SEPARATOR ',') AS products 4 | FROM Activities 5 | GROUP BY sell_date 6 | ORDER BY sell_date ASC -------------------------------------------------------------------------------- /1484-group-sold-products-by-the-date/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1496-path-crossing/1496-path-crossing.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} path 3 | * @return {boolean} 4 | */ 5 | var isPathCrossing = function (path) { 6 | let arr = path.split(""); 7 | let map = {}; 8 | 9 | let x = 0; 10 | let y = 0; 11 | map[`${x},${y}`] = true; 12 | 13 | for (let i = 0; i < arr.length; i++) { 14 | const element = arr[i]; 15 | if (element === "N") { 16 | y++; 17 | } else if (element === "E") { 18 | x++; 19 | } else if (element === "S") { 20 | y--; 21 | } else if (element === "W") { 22 | x--; 23 | } 24 | 25 | let newCoor = `${x},${y}`; 26 | newCoor; 27 | 28 | //pengecekan 29 | if (map.hasOwnProperty(newCoor)) { 30 | return true; 31 | } else { 32 | map[newCoor] = true; 33 | } 34 | } 35 | 36 | return false; 37 | }; -------------------------------------------------------------------------------- /1496-path-crossing/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1502-can-make-arithmetic-progression-from-sequence/1502-can-make-arithmetic-progression-from-sequence.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} arr 3 | * @return {boolean} 4 | */ 5 | var canMakeArithmeticProgression = function(arr) { 6 | let sorted = arr.sort((a,b) => a-b) 7 | let arimatika = true 8 | let op = sorted[1] - sorted[0] 9 | for(let i = 0; i < sorted.length - 1; i++){ 10 | if(sorted[i] + op !== sorted[i+1]){ 11 | arimatika = false 12 | break 13 | } 14 | } 15 | 16 | return arimatika 17 | }; -------------------------------------------------------------------------------- /1502-can-make-arithmetic-progression-from-sequence/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1502-can-make-arithmetic-progression-from-sequence/README.md: -------------------------------------------------------------------------------- 1 |

1502. Can Make Arithmetic Progression From Sequence

Easy

A sequence of numbers is called an arithmetic progression if the difference between any two consecutive elements is the same.

2 | 3 |

Given an array of numbers arr, return true if the array can be rearranged to form an arithmetic progression. Otherwise, return false.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: arr = [3,5,1]
 9 | Output: true
10 | Explanation: We can reorder the elements as [1,3,5] or [5,3,1] with differences 2 and -2 respectively, between each consecutive elements.
11 |
12 | 13 |

Example 2:

14 | 15 | 
Input: arr = [1,2,4]
16 | Output: false
17 | Explanation: There is no way to reorder the elements to obtain an arithmetic progression.
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 | 27 |
-------------------------------------------------------------------------------- /1512-number-of-good-pairs/1512-number-of-good-pairs.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | function numIdenticalPairs(nums) { 6 | let i=0 7 | let j=i+1 8 | let count=0 9 | nums.sort() 10 | while(i1512. Number of Good Pairs

Easy

Given an array of integers nums, return the number of good pairs.

2 | 3 |

A pair (i, j) is called good if nums[i] == nums[j] and i < j.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: nums = [1,2,3,1,1,3]
 9 | Output: 4
10 | Explanation: There are 4 good pairs (0,3), (0,4), (3,4), (2,5) 0-indexed.
11 |
12 | 13 |

Example 2:

14 | 15 | 
Input: nums = [1,1,1,1]
16 | Output: 6
17 | Explanation: Each pair in the array are good.
18 |
19 | 20 |

Example 3:

21 | 22 | 
Input: nums = [1,2,3]
23 | Output: 0
24 |
25 | 26 |

 

27 |

Constraints:

28 | 29 |
    30 |
  • 1 <= nums.length <= 100
    • 31 |
  • 1 <= nums[i] <= 100
    • 32 |
33 |
-------------------------------------------------------------------------------- /1528-shuffle-string/1528-shuffle-string.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @param {number[]} indices 4 | * @return {string} 5 | */ 6 | var restoreString = function(s, indices) { 7 | var str = new Array(indices.length); 8 | 9 | for (let index = 0; index < indices.length; index++) { 10 | str[indices[index]] = s[index]; 11 | } 12 | 13 | return str.join('') 14 | }; -------------------------------------------------------------------------------- /1528-shuffle-string/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1541-top-travellers/1541-top-travellers.sql: -------------------------------------------------------------------------------- 1 | SELECT u.name, sum(IF(distance is NULL,0,distance)) as travelled_distance 2 | FROM Users u 3 | LEFT JOIN Rides r ON u.id = r.user_id 4 | GROUP BY u.id 5 | ORDER BY travelled_distance DESC, u.name ASC; 6 | -------------------------------------------------------------------------------- /1572-matrix-diagonal-sum/1572-matrix-diagonal-sum.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} mat 3 | * @return {number} 4 | */ 5 | var diagonalSum = function(mat) { 6 | let total = mat.length 7 | 8 | let primaryDiagonal = 0 9 | let secondaryDiagonal = 0 10 | for (let i = 0; i < total; i++) { 11 | const element = mat[i][i]; 12 | primaryDiagonal = primaryDiagonal + element 13 | } 14 | 15 | if(total % 2 === 1){ 16 | let temp = total 17 | for (let j = 0; j < total; j++) { 18 | const element = mat[j][temp-1]; 19 | element 20 | if(j !== temp-1){ 21 | secondaryDiagonal = secondaryDiagonal + element 22 | } 23 | temp-- 24 | } 25 | } else { 26 | let temp = total 27 | for (let j = 0; j < total; j++) { 28 | const element = mat[j][temp-1]; 29 | temp-- 30 | secondaryDiagonal = secondaryDiagonal + element 31 | } 32 | } 33 | 34 | return primaryDiagonal + secondaryDiagonal 35 | }; -------------------------------------------------------------------------------- /1572-matrix-diagonal-sum/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1587-bank-account-summary-ii/1587-bank-account-summary-ii.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT u.name, SUM(amount) as 'balance' 4 | FROM Transactions t 5 | JOIN Users u ON t.account = u.account 6 | GROUP BY t.account 7 | HAVING balance > 10000 -------------------------------------------------------------------------------- /1587-bank-account-summary-ii/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1588-sum-of-all-odd-length-subarrays/1588-sum-of-all-odd-length-subarrays.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} arr 3 | * @return {number} 4 | */ 5 | 6 | var sumOddLengthSubarrays = function(arr) { 7 | const n = arr.length; 8 | let sum = 0; 9 | 10 | if (n === 1) return arr[0]; 11 | 12 | // Turn arr into a prefix sum array 13 | for (let i = 1; i < n; i++) 14 | arr[i] += arr[i-1]; 15 | 16 | let numOfSlidingWindows = Math.ceil(n/2); 17 | 18 | for (let i = 0; i < numOfSlidingWindows; i++) { 19 | for (let j = i*2; j < n; j++) { 20 | if (j-(i*2)-1 < 0) { 21 | sum += arr[j]; 22 | } 23 | else sum += arr[j] - arr[j-(i*2)-1] 24 | } 25 | } 26 | return sum; 27 | }; 28 | -------------------------------------------------------------------------------- /1588-sum-of-all-odd-length-subarrays/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1598-crawler-log-folder/1598-crawler-log-folder.js: -------------------------------------------------------------------------------- 1 | class Stack { 2 | constructor() { 3 | this.stack = []; 4 | } 5 | 6 | push(item) { 7 | this.stack.push(item); 8 | } 9 | 10 | pop() { 11 | if (this.isEmpty()) return "Stack Kosong"; 12 | return this.stack.pop(); 13 | } 14 | 15 | isEmpty() { 16 | return this.stack.length === 0; 17 | } 18 | 19 | peek() { 20 | return this.stack[this.stack.length - 1]; 21 | } 22 | 23 | size(){ 24 | return this.stack.length 25 | } 26 | } 27 | 28 | var minOperations = function (logs) { 29 | let stack = new Stack(); 30 | 31 | const operations = { 32 | "../": () => { 33 | stack.pop(); 34 | }, 35 | "./": () => { 36 | stack.peek(); 37 | }, 38 | default: (element) => stack.push(element), 39 | }; 40 | 41 | logs.forEach((element) => { 42 | const action = operations[element] || operations.default; 43 | action(element); 44 | }); 45 | 46 | return stack.size() 47 | }; 48 | -------------------------------------------------------------------------------- /1598-crawler-log-folder/1598-crawler-log-folder.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minOperations(self, logs: List[str]) -> int: 3 | stack=[] 4 | for log in logs: 5 | if log == "./": 6 | continue 7 | elif stack and log == "../": 8 | stack.pop() 9 | elif log != '../': 10 | stack.append(log) 11 | return len(stack) -------------------------------------------------------------------------------- /1598-crawler-log-folder/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1603-design-parking-system/1603-design-parking-system.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} big 3 | * @param {number} medium 4 | * @param {number} small 5 | */ 6 | var ParkingSystem = function (big, medium, small) { 7 | this.big = big 8 | this.medium = medium 9 | this.small = small 10 | }; 11 | 12 | /** 13 | * @param {number} carType 14 | * @return {boolean} 15 | */ 16 | ParkingSystem.prototype.addCar = function(carType) { 17 | switch (carType) { 18 | case 1: 19 | return --this.big >= 0; 20 | case 2: 21 | return --this.medium >= 0; 22 | case 3: 23 | return --this.small >= 0; 24 | default: 25 | break; 26 | } 27 | }; -------------------------------------------------------------------------------- /1603-design-parking-system/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1603-running-sum-of-1d-array/1603-running-sum-of-1d-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var runningSum = function(nums) { 6 | let sums = 0; 7 | let retSums = []; 8 | for(let i of nums) { 9 | sums += i; 10 | retSums.push(sums); 11 | } 12 | return retSums; 13 | } -------------------------------------------------------------------------------- /1603-running-sum-of-1d-array/README.md: -------------------------------------------------------------------------------- 1 |

1603. Running Sum of 1d Array

Easy

Given an array nums. We define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i]).

2 | 3 |

Return the running sum of nums.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
 9 | Input: nums = [1,2,3,4]
10 | Output: [1,3,6,10]
11 | Explanation: Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].
12 | 13 |

Example 2:

14 | 15 | 
16 | Input: nums = [1,1,1,1,1]
17 | Output: [1,2,3,4,5]
18 | Explanation: Running sum is obtained as follows: [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1].
19 | 20 |

Example 3:

21 | 22 | 
23 | Input: nums = [3,1,2,10,1]
24 | Output: [3,4,6,16,17]
25 |
26 | 27 |

 

28 |

Constraints:

29 | 30 | -------------------------------------------------------------------------------- /1614-maximum-nesting-depth-of-the-parentheses/1614-maximum-nesting-depth-of-the-parentheses.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var maxDepth = function(s) { 6 | let stack = [] 7 | 8 | let max = 0 9 | let counter = 0 10 | s.split("").forEach((element) => { 11 | if(element === "("){ 12 | counter++ 13 | max = Math.max(max, counter) 14 | } else if (element === ")"){ 15 | counter-- 16 | } 17 | }) 18 | 19 | return max 20 | }; -------------------------------------------------------------------------------- /1614-maximum-nesting-depth-of-the-parentheses/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1624-largest-substring-between-two-equal-characters/1624-largest-substring-between-two-equal-characters.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var maxLengthBetweenEqualCharacters = function(s) { 6 | let array = s.split('') 7 | 8 | let temp = [] 9 | let res = [] 10 | let max = 0 11 | for (let i = 0; i < array.length; i++) { 12 | for (let j = i+1; j < array.length; j++) { 13 | if(array[i] === array[j]){ 14 | temp.push(i, j) 15 | } 16 | } 17 | } 18 | 19 | for (let i = 0; i < temp.length; i++) { 20 | let element = temp[i] 21 | let element2 = temp[i+1] 22 | let sum = element2 - element 23 | if(sum > max){ 24 | max = sum 25 | } 26 | } 27 | 28 | if(temp.length && res.length >= 0){ 29 | return max-1 30 | } else if (temp.length && res.length === 0){ 31 | return temp.length 32 | } else { 33 | return -1 34 | } 35 | }; -------------------------------------------------------------------------------- /1624-largest-substring-between-two-equal-characters/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1624-largest-substring-between-two-equal-characters/README.md: -------------------------------------------------------------------------------- 1 |

1624. Largest Substring Between Two Equal Characters

Easy

Given a string s, return the length of the longest substring between two equal characters, excluding the two characters. If there is no such substring return -1.

2 | 3 |

A substring is a contiguous sequence of characters within a string.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: s = "aa"
 9 | Output: 0
10 | Explanation: The optimal substring here is an empty substring between the two 'a's.
11 | 12 |

Example 2:

13 | 14 | 
Input: s = "abca"
15 | Output: 2
16 | Explanation: The optimal substring here is "bc".
17 |
18 | 19 |

Example 3:

20 | 21 | 
Input: s = "cbzxy"
22 | Output: -1
23 | Explanation: There are no characters that appear twice in s.
24 |
25 | 26 |

 

27 |

Constraints:

28 | 29 |
    30 |
  • 1 <= s.length <= 300
    • 31 |
  • s contains only lowercase English letters.
    • 32 |
33 |
-------------------------------------------------------------------------------- /1625-group-sold-products-by-the-date/1625-group-sold-products-by-the-date.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT sell_date, count(DISTINCT(product)) as num_sold, 3 | GROUP_CONCAT(DISTINCT product ORDER BY product ASC SEPARATOR ',') AS products 4 | FROM Activities 5 | GROUP BY sell_date 6 | ORDER BY sell_date ASC -------------------------------------------------------------------------------- /1630-arithmetic-subarrays/1630-arithmetic-subarrays.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number[]} l 4 | * @param {number[]} r 5 | * @return {boolean[]} 6 | */ 7 | var checkArithmeticSubarrays = function(nums, l, r) { 8 | let res = []; 9 | 10 | for (let i = 0; i < l.length; i++) { 11 | let temp = nums.slice(l[i], r[i] + 1); 12 | let sorted = temp.slice().sort((a, b) => a - b); 13 | let op = sorted[1] - sorted[0]; 14 | let isArithmetic = true; 15 | 16 | for (let j = 0; j < sorted.length - 1; j++) { 17 | if (sorted[j] + op !== sorted[j + 1]) { 18 | isArithmetic = false; 19 | break; 20 | } 21 | } 22 | 23 | res.push(isArithmetic); 24 | } 25 | 26 | return res; 27 | }; -------------------------------------------------------------------------------- /1630-arithmetic-subarrays/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1633-percentage-of-users-attended-a-contest/1633-percentage-of-users-attended-a-contest.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT r.contest_id, 4 | ROUND((COUNT(r.user_id) * 100 / (SELECT COUNT(user_id) FROM Users)), 2) as percentage 5 | FROM Users u 6 | JOIN Register r ON u.user_id = r.user_id 7 | GROUP BY r.contest_id 8 | ORDER BY percentage DESC, contest_id; 9 | -------------------------------------------------------------------------------- /1633-percentage-of-users-attended-a-contest/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1636-sort-array-by-increasing-frequency/1636-sort-array-by-increasing-frequency.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var frequencySort = function(nums) { 6 | let res = [] 7 | let map = new Map() 8 | nums.forEach((element) => { 9 | map.set(element, (map.get(element) || 0) + 1) 10 | }) 11 | map 12 | 13 | let arr = Array.from([...map.entries()]).sort((a, b) => { 14 | // Mengurutkan berdasarkan nilai index 1 15 | if (a[1] !== b[1]) { 16 | return a[1] - b[1]; 17 | } 18 | // Jika nilai index 1 sama, mengurutkan berdasarkan nilai index 0 19 | return b[0] - a[0]; 20 | }); 21 | 22 | for(const [key, value] of arr){ 23 | for (let i = 0; i < value; i++) { 24 | res.push(key) 25 | } 26 | } 27 | 28 | return res 29 | }; -------------------------------------------------------------------------------- /1636-sort-array-by-increasing-frequency/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1636-sort-array-by-increasing-frequency/README.md: -------------------------------------------------------------------------------- 1 |

1636. Sort Array by Increasing Frequency

Easy

Given an array of integers nums, sort the array in increasing order based on the frequency of the values. If multiple values have the same frequency, sort them in decreasing order.

2 | 3 |

Return the sorted array.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: nums = [1,1,2,2,2,3]
 9 | Output: [3,1,1,2,2,2]
10 | Explanation: '3' has a frequency of 1, '1' has a frequency of 2, and '2' has a frequency of 3.
11 |
12 | 13 |

Example 2:

14 | 15 | 
Input: nums = [2,3,1,3,2]
16 | Output: [1,3,3,2,2]
17 | Explanation: '2' and '3' both have a frequency of 2, so they are sorted in decreasing order.
18 |
19 | 20 |

Example 3:

21 | 22 | 
Input: nums = [-1,1,-6,4,5,-6,1,4,1]
23 | Output: [5,-1,4,4,-6,-6,1,1,1]
24 | 25 |

 

26 |

Constraints:

27 | 28 |
    29 |
  • 1 <= nums.length <= 100
    • 30 |
  • -100 <= nums[i] <= 100
    • 31 |
32 |
-------------------------------------------------------------------------------- /1672-richest-customer-wealth/1672-richest-customer-wealth.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} accounts 3 | * @return {number} 4 | */ 5 | var maximumWealth = function(accounts) { 6 | let highest = 0; 7 | 8 | accounts.forEach((account) => { 9 | let sum = account.reduce((x,y) => { 10 | return x + y 11 | }, 0); 12 | if ( highest < sum ) highest = sum; 13 | }) 14 | 15 | return highest; 16 | }; -------------------------------------------------------------------------------- /1672-richest-customer-wealth/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1683-invalid-tweets/1683-invalid-tweets.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT tweet_id 4 | FROM Tweets 5 | WHERE LENGTH(content) > 15 6 | -------------------------------------------------------------------------------- /1683-invalid-tweets/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1693-daily-leads-and-partners/1693-daily-leads-and-partners.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT date_id, make_name, COUNT(DISTINCT lead_id) as 'unique_leads', COUNT(DISTINCT partner_id) as 'unique_partners' 4 | FROM DailySales 5 | GROUP BY date_id, make_name -------------------------------------------------------------------------------- /1693-daily-leads-and-partners/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1700-number-of-students-unable-to-eat-lunch/1700-number-of-students-unable-to-eat-lunch.js: -------------------------------------------------------------------------------- 1 | const countStudents = function(students, sandwiches) { 2 | const queue = new Queue(); 3 | 4 | for (const student of students) { 5 | queue.enqueue(student); 6 | } 7 | 8 | let count = 0; 9 | while (!queue.isEmpty() && count < queue.size()) { 10 | if (queue.front() === sandwiches[0]) { 11 | count = 0; 12 | queue.dequeue(); 13 | sandwiches.shift(); 14 | } else { 15 | count++; 16 | queue.enqueue(queue.dequeue()); 17 | } 18 | } 19 | 20 | return queue.size(); 21 | }; 22 | -------------------------------------------------------------------------------- /1700-number-of-students-unable-to-eat-lunch/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1729-find-followers-count/1729-find-followers-count.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT user_id, COUNT(DISTINCT follower_id) as followers_count 3 | FROM Followers 4 | GROUP BY user_id -------------------------------------------------------------------------------- /1729-find-followers-count/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1732-find-the-highest-altitude/1732-find-the-highest-altitude.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} gain 3 | * @return {number} 4 | */ 5 | var largestAltitude = function(gain) { 6 | let arr = [] 7 | arr.push(0, gain[0]) 8 | 9 | for (let i = 0; i < gain.length-1; i++) { 10 | let sum = arr[i+1] + gain[i+1] 11 | arr.push(sum) 12 | } 13 | 14 | let alt = arr.sort((a, b) => b-a) 15 | 16 | return alt[0] 17 | }; -------------------------------------------------------------------------------- /1732-find-the-highest-altitude/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1732-find-the-highest-altitude/README.md: -------------------------------------------------------------------------------- 1 |

1732. Find the Highest Altitude

Easy

There is a biker going on a road trip. The road trip consists of n + 1 points at different altitudes. The biker starts his trip on point 0 with altitude equal 0.

2 | 3 |

You are given an integer array gain of length n where gain[i] is the net gain in altitude between points i​​​​​​ and i + 1 for all (0 <= i < n). Return the highest altitude of a point.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: gain = [-5,1,5,0,-7]
 9 | Output: 1
10 | Explanation: The altitudes are [0,-5,-4,1,1,-6]. The highest is 1.
11 |
12 | 13 |

Example 2:

14 | 15 | 
Input: gain = [-4,-3,-2,-1,4,3,2]
16 | Output: 0
17 | Explanation: The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0.
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 |
    24 |
  • n == gain.length
    • 25 |
  • 1 <= n <= 100
    • 26 |
  • -100 <= gain[i] <= 100
    • 27 |
28 |
-------------------------------------------------------------------------------- /1737-maximum-nesting-depth-of-the-parentheses/1737-maximum-nesting-depth-of-the-parentheses.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var maxDepth = function(s) { 6 | let stack = [] 7 | 8 | let max = 0 9 | let counter = 0 10 | s.split("").forEach((element) => { 11 | if(element === "("){ 12 | counter++ 13 | max = Math.max(max, counter) 14 | } else if (element === ")"){ 15 | counter-- 16 | } 17 | }) 18 | 19 | return max 20 | }; -------------------------------------------------------------------------------- /1748-sum-of-unique-elements/1748-sum-of-unique-elements.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var sumOfUnique = function(nums) { 6 | let map = new Map() 7 | let res = 0 8 | nums.forEach((element) => { 9 | map.set(element, (map.get(element) || 0) + 1) 10 | }) 11 | map.forEach((key, value) => { 12 | if(key == 1){ 13 | res += value 14 | } 15 | }) 16 | return res 17 | }; -------------------------------------------------------------------------------- /1748-sum-of-unique-elements/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1748-sum-of-unique-elements/README.md: -------------------------------------------------------------------------------- 1 |

1748. Sum of Unique Elements

Easy

You are given an integer array nums. The unique elements of an array are the elements that appear exactly once in the array.

2 | 3 |

Return the sum of all the unique elements of nums.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: nums = [1,2,3,2]
 9 | Output: 4
10 | Explanation: The unique elements are [1,3], and the sum is 4.
11 |
12 | 13 |

Example 2:

14 | 15 | 
Input: nums = [1,1,1,1,1]
16 | Output: 0
17 | Explanation: There are no unique elements, and the sum is 0.
18 |
19 | 20 |

Example 3:

21 | 22 | 
Input: nums = [1,2,3,4,5]
23 | Output: 15
24 | Explanation: The unique elements are [1,2,3,4,5], and the sum is 15.
25 |
26 | 27 |

 

28 |

Constraints:

29 | 30 |
    31 |
  • 1 <= nums.length <= 100
    • 32 |
  • 1 <= nums[i] <= 100
    • 33 |
34 |
-------------------------------------------------------------------------------- /1768-merge-strings-alternately/1768-merge-strings-alternately.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} word1 3 | * @param {string} word2 4 | * @return {string} 5 | */ 6 | var mergeAlternately = function(word1, word2) { 7 | let res = '' 8 | for (let i = 0; i < Math.max(word1.length, word2.length); i++) { 9 | if(word1[i]) res+= word1[i] 10 | if(word2[i]) res+= word2[i] 11 | } 12 | return res 13 | }; -------------------------------------------------------------------------------- /1768-merge-strings-alternately/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1773-count-items-matching-a-rule/1773-count-items-matching-a-rule.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[][]} items 3 | * @param {string} ruleKey 4 | * @param {string} ruleValue 5 | * @return {number} 6 | */ 7 | var countMatches = function (items, ruleKey, ruleValue) { 8 | let find = 0; 9 | if (ruleKey === "type") find = 0; 10 | if (ruleKey === "color") find = 1; 11 | if (ruleKey === "name") find = 2; 12 | 13 | let arr = items.map((element) => { 14 | return element[find] 15 | }).filter((elemen) => elemen === ruleValue); 16 | 17 | return arr.length; 18 | }; -------------------------------------------------------------------------------- /1773-count-items-matching-a-rule/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1816-truncate-sentence/1816-truncate-sentence.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @param {number} k 4 | * @return {string} 5 | */ 6 | var truncateSentence = function(s, k) { 7 | let split = s.split(' ') 8 | let res = [] 9 | for (let index = 0; index < k; index++) { 10 | res.push(split[index]) 11 | } 12 | 13 | return res.join(' ') 14 | }; -------------------------------------------------------------------------------- /1816-truncate-sentence/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1817-finding-the-users-active-minutes/1817-finding-the-users-active-minutes.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} logs 3 | * @param {number} k 4 | * @return {number[]} 5 | */ 6 | var findingUsersActiveMinutes = function (logs, k) { 7 | let map = new Map(); 8 | 9 | for (const [user, time] of logs) { 10 | //jika tidak ada user maka buat key baru dan value berupa set 11 | if (map.has(user) === false) { 12 | map.set(user, new Set()); 13 | } 14 | //tambahkan value berupa set yang berisi time 15 | let set = map.get(user) 16 | set.add(time); 17 | } 18 | 19 | 20 | //tambah 0 ke array sesuai k 21 | let arr = new Array(k).fill(0); 22 | 23 | for (const actions of map.values()) { 24 | arr[actions.size - 1] = arr[actions.size - 1]+1; 25 | } 26 | 27 | return arr; 28 | }; -------------------------------------------------------------------------------- /1817-finding-the-users-active-minutes/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1865-finding-pairs-with-a-certain-sum/1865-finding-pairs-with-a-certain-sum.js: -------------------------------------------------------------------------------- 1 | var FindSumPairs = function (nums1, nums2) { 2 | this.nums1 = nums1; 3 | this.nums2 = nums2; 4 | this.map = new Map(); 5 | this.map2 = new Map(); 6 | 7 | nums1.forEach((num1) => { 8 | this.map.set(num1, (this.map.get(num1) || 0) + 1); 9 | }); 10 | nums2.forEach((num2) => { 11 | this.map2.set(num2, (this.map2.get(num2) || 0) + 1); 12 | }); 13 | }; 14 | 15 | FindSumPairs.prototype.add = function (index, val) { 16 | var x = this.nums2[index]; 17 | this.map2.set(x, this.map2.get(x) - 1); 18 | this.nums2[index] += val; 19 | var newX = x + val; 20 | this.map2.set(newX, (this.map2.get(newX) || 0) + 1); 21 | }; 22 | 23 | FindSumPairs.prototype.count = function (tot) { 24 | var count = 0; 25 | for (var [key, value] of this.map) { 26 | var diff = tot - key; 27 | var value2 = this.map2.get(diff); 28 | if (value2 !== undefined) { 29 | count += value * value2; 30 | } 31 | } 32 | return count; 33 | }; -------------------------------------------------------------------------------- /1865-finding-pairs-with-a-certain-sum/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1873-calculate-special-bonus/1873-calculate-special-bonus.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | select employee_id, 4 | CASE 5 | WHEN employee_id%2 != 0 AND name NOT LIKE 'M%' THEN salary 6 | ELSE 0 7 | END as bonus 8 | FROM employees 9 | ORDER BY employee_id; -------------------------------------------------------------------------------- /1876-substrings-of-size-three-with-distinct-characters/1876-substrings-of-size-three-with-distinct-characters.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var countGoodSubstrings = function (s) { 6 | return Array.from({ length: s.length - 2 }, (_, l) => new Set(`${s[l]}${s[l + 1]}${s[l + 2]}`).size === 3).filter(Boolean).length; 7 | }; -------------------------------------------------------------------------------- /1876-substrings-of-size-three-with-distinct-characters/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1877-find-followers-count/1877-find-followers-count.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | SELECT user_id, COUNT(DISTINCT follower_id) as followers_count 3 | FROM Followers 4 | GROUP BY user_id -------------------------------------------------------------------------------- /1903-largest-odd-number-in-string/1903-largest-odd-number-in-string.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} num 3 | * @return {string} 4 | */ 5 | var largestOddNumber = function(num) { 6 | num = num.split(""); 7 | for(let i = num.length - 1; i >= 0; i--){ 8 | if(num[i] % 2 == 0){ 9 | num.pop(); 10 | } else { 11 | break; 12 | } 13 | } 14 | return num.join(""); 15 | }; -------------------------------------------------------------------------------- /1903-largest-odd-number-in-string/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1920-build-array-from-permutation/1920-build-array-from-permutation.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var buildArray = function(nums) { 6 | let array = []; 7 | nums.forEach(element => { 8 | array.push(nums[element]) 9 | }); 10 | 11 | return array; 12 | }; -------------------------------------------------------------------------------- /1920-build-array-from-permutation/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1929-concatenation-of-array/1929-concatenation-of-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var getConcatenation = function(nums) { 6 | let array2 = [] 7 | nums.forEach(element => { 8 | array2.push(element) 9 | }); 10 | 11 | let result = nums.concat(array2) 12 | return result 13 | }; -------------------------------------------------------------------------------- /1929-concatenation-of-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1965-employees-with-missing-information/1965-employees-with-missing-information.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT s.employee_id 4 | FROM Salaries s 5 | LEFT JOIN Employees e ON s.employee_id = e.employee_id 6 | WHERE e.employee_id IS NULL 7 | 8 | UNION ALL 9 | 10 | SELECT e.employee_id 11 | FROM Employees e 12 | LEFT JOIN Salaries s ON e.employee_id = s.employee_id 13 | WHERE s.employee_id IS NULL 14 | 15 | ORDER BY employee_id; 16 | 17 | 18 | -------------------------------------------------------------------------------- /1965-employees-with-missing-information/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1984-minimum-difference-between-highest-and-lowest-of-k-scores/1984-minimum-difference-between-highest-and-lowest-of-k-scores.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minimumDifference(self, nums: List[int], k: int) -> int: 3 | 4 | nums.sort() 5 | 6 | l = 0 7 | r = k - 1 8 | 9 | res = float('inf') 10 | 11 | while r < len(nums): 12 | res = min(res, nums[r] - nums[l]) 13 | l += 1 14 | r += 1 15 | 16 | return res -------------------------------------------------------------------------------- /1984-minimum-difference-between-highest-and-lowest-of-k-scores/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1991-find-the-middle-index-in-array/1991-find-the-middle-index-in-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findMiddleIndex = function(nums) { 6 | //melalukan rumus prefix sum 7 | let prefixSum = []; 8 | prefixSum[0] = nums[0] 9 | for (let i = 1; i < nums.length; i++) { 10 | prefixSum[i] = prefixSum[i-1] + nums[i] 11 | } 12 | 13 | 14 | //melakukan perulangan sampai mendapatkan value yang sama 15 | for (let i = 0; i < nums.length; i++) { 16 | let a = prefixSum[i-1]; 17 | if(!a) a=0 18 | let b = prefixSum[nums.length - 1] - prefixSum[i+1-1] 19 | 20 | //jika a dan b sama, maka return index nya 21 | if(a==b) return i 22 | } 23 | 24 | //kembalikan -1 jika tidak ada yang sama di perulangan sblmnya 25 | return -1; 26 | }; -------------------------------------------------------------------------------- /1991-find-the-middle-index-in-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2006-count-number-of-pairs-with-absolute-difference-k/2006-count-number-of-pairs-with-absolute-difference-k.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {number} 5 | */ 6 | var countKDifference = function(nums, k) { 7 | 8 | let count = 0 9 | for (let i = 0; i < nums.length; i++) { 10 | const element = nums[i]; 11 | for (let j = 0; j < nums.length; j++) { 12 | const diff = nums[j]; 13 | if(diff === element + k) count++ 14 | } 15 | } 16 | return count 17 | }; -------------------------------------------------------------------------------- /2006-count-number-of-pairs-with-absolute-difference-k/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2070-most-beautiful-item-for-each-query/2070-most-beautiful-item-for-each-query.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} items 3 | * @param {number[]} queries 4 | * @return {number[]} 5 | */ 6 | var maximumBeauty = function(items, queries) { 7 | items.sort((a, b) => a[0] - b[0]); 8 | const n = items.length; 9 | 10 | let max = items[0][1]; 11 | 12 | for (let i = 0; i < n; i++) { 13 | max = Math.max(max, items[i][1]); 14 | items[i][1] = max; 15 | } 16 | 17 | //metode binarySearch 18 | const binarySearch = (arr, target) => { 19 | let left = 0; 20 | let right = arr.length - 1; 21 | let result = 0; 22 | while (left <= right) { 23 | let mid = Math.floor((left + right) / 2); 24 | if (arr[mid][0] <= target) { 25 | result = arr[mid][1]; 26 | left = mid + 1; 27 | } else { 28 | right = mid - 1; 29 | } 30 | } 31 | return result; 32 | }; 33 | 34 | const ans = []; 35 | queries.forEach(element => ans.push(binarySearch(items, element))) 36 | 37 | return ans; 38 | }; -------------------------------------------------------------------------------- /2070-most-beautiful-item-for-each-query/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2079-watering-plants/2079-watering-plants.js: -------------------------------------------------------------------------------- 1 | var wateringPlants = function(plants, capacity) { 2 | 3 | let steps = 0 4 | let water = capacity 5 | for (let index = 0; index < plants.length; index++) { 6 | let plant = plants[index]; 7 | 8 | if (plant <= water) { 9 | //tambahkan steps 10 | steps++; 11 | //kurangi water sesuai kebutuhan tanaman 12 | water = water - plant; 13 | } else { 14 | //reset water menjadi full lagi 15 | water = capacity; 16 | 17 | //rumus jika kembali dan datang lagi 18 | let additionalSteps = index * 2 + 1; 19 | 20 | //tambahkan ke steps 21 | steps += additionalSteps; 22 | 23 | //kurangi water sesuai kebutuhan tanaman 24 | water = water - plant; 25 | } 26 | } 27 | 28 | return steps 29 | 30 | }; -------------------------------------------------------------------------------- /2079-watering-plants/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2089-find-target-indices-after-sorting-array/2089-find-target-indices-after-sorting-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} target 4 | * @return {number[]} 5 | */ 6 | var targetIndices = function(nums, target) { 7 | let sorted = nums.sort((a,b) => a-b) 8 | let indexs = [] 9 | sorted.map((element, index) => { 10 | if(element === target){ 11 | indexs.push(index) 12 | } 13 | }) 14 | 15 | return indexs 16 | }; -------------------------------------------------------------------------------- /2089-find-target-indices-after-sorting-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2090-k-radius-subarray-averages/2090-k-radius-subarray-averages.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {number[]} 5 | */ 6 | var getAverages = function(nums, k) { 7 | 8 | const prefixSum = new Array(nums.length).fill(-1); 9 | for (let i = 0; i < nums.length; i++) { 10 | if (i === 0) { 11 | prefixSum[i] = nums[i]; 12 | } else { 13 | prefixSum[i] = nums[i] + prefixSum[i - 1]; 14 | } 15 | } 16 | console.log(prefixSum) // [7,11,14,23,24,32,37,39,45] 17 | 18 | const res = new Array(nums.length).fill(-1); 19 | for (let i = k ; i <= (nums.length - 1) - k; i++) { 20 | if (i === k) { 21 | res[i] = Math.floor(prefixSum[i + k] / (k*2+1)); 22 | } else { 23 | res[i] = Math.floor((prefixSum[i + k] - prefixSum[i - k - 1]) / (k*2+1)); 24 | } 25 | } 26 | return res; 27 | }; -------------------------------------------------------------------------------- /2090-k-radius-subarray-averages/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2125-number-of-laser-beams-in-a-bank/2125-number-of-laser-beams-in-a-bank.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} bank 3 | * @return {number} 4 | */ 5 | var numberOfBeams = function (bank) { 6 | 7 | //variable untuk menyimpan total device yang tersedia 8 | let devices = []; 9 | 10 | //metode matriks untuk mengambil setiap value 11 | for (let i = 0; i < bank.length; i++) { 12 | const row = bank[i].split(""); 13 | 14 | //deviceBaris untuk menentukan berapa devices dari setiap baris 15 | let deviceBaris = 0; 16 | for (let j = 0; j < row.length; j++) { 17 | const col = bank[i][j]; 18 | //jika setiap value bernilai 1, 19 | if (col === "1") { 20 | //tambah ke deviceBaris 21 | deviceBaris++; 22 | } 23 | } 24 | 25 | //jika deviceBaris tidak ada, tidak usah dimasukkan ke devices 26 | if (deviceBaris > 0) { 27 | devices.push(deviceBaris); 28 | } 29 | } 30 | 31 | //variable untuk menyimpan laser-lasernya 32 | let res = 0; 33 | //melalukan perhitungan Math untuk menghubungkan devices ke devices 34 | for (let i = 0; i < devices.length - 1; i++) { 35 | res += devices[i] * devices[i + 1] 36 | } 37 | 38 | return res; 39 | }; -------------------------------------------------------------------------------- /2125-number-of-laser-beams-in-a-bank/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2154-keep-multiplying-found-values-by-two/2154-keep-multiplying-found-values-by-two.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} original 4 | * @return {number} 5 | */ 6 | var findFinalValue = function(nums, original) { 7 | while(nums.includes(original)){ 8 | original *=2 9 | } 10 | return original 11 | }; -------------------------------------------------------------------------------- /2154-keep-multiplying-found-values-by-two/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2215-find-the-difference-of-two-arrays/2215-find-the-difference-of-two-arrays.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums1 3 | * @param {number[]} nums2 4 | * @return {number[][]} 5 | */ 6 | var findDifference = function(nums1, nums2) { 7 | 8 | nums1 = new Set(nums1) 9 | nums2 = new Set(nums2) 10 | 11 | for (let item of nums1){ 12 | if (nums2.has(item)) { 13 | nums1.delete(item) 14 | nums2.delete(item) 15 | } 16 | } 17 | return [Array.from(nums1),Array.from(nums2)] 18 | 19 | }; -------------------------------------------------------------------------------- /2215-find-the-difference-of-two-arrays/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2243-calculate-digit-sum-of-a-string/2243-calculate-digit-sum-of-a-string.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @param {number} k 4 | * @return {string} 5 | */ 6 | var digitSum = function(s, k) { 7 | while (s.length > k) { 8 | let current = ''; 9 | for (let i = 0; i < s.length; i += k) { 10 | let chunk = s.slice(i, i + k); 11 | let sum = chunk.split('').reduce((a, b) => parseInt(a) + parseInt(b)); 12 | current += sum; 13 | } 14 | s = current; 15 | } 16 | return s; 17 | }; -------------------------------------------------------------------------------- /2243-calculate-digit-sum-of-a-string/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2270-number-of-ways-to-split-array/2270-number-of-ways-to-split-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var waysToSplitArray = function(nums) { 6 | 7 | let prefixSum = [] 8 | prefixSum[0] = nums[0] 9 | for (let i = 1; i < nums.length; i++) { 10 | prefixSum[i] = prefixSum[i-1] + nums[i] 11 | } 12 | 13 | let count = 0 14 | for (let i = 0; i < nums.length - 1; i++) { 15 | const left = prefixSum[i]; 16 | const right = prefixSum[nums.length - 1] - prefixSum[i+1-1] 17 | if(left>=right) count++ 18 | } 19 | 20 | return count 21 | 22 | }; -------------------------------------------------------------------------------- /2270-number-of-ways-to-split-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2284-sender-with-largest-word-count/2284-sender-with-largest-word-count.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} messages 3 | * @param {string[]} senders 4 | * @return {string} 5 | */ 6 | var largestWordCount = function(messages, senders) { 7 | let map = new Map(); 8 | 9 | //menghitung sender ngirim berapa kata 10 | for (let i = 0; i < senders.length; i++) { 11 | //counter 12 | map.set(senders[i], (map.get(senders[i]) || 0) + messages[i].split(" ").length); 13 | } 14 | 15 | let largerName = ""; 16 | let sameValue = null; 17 | 18 | //membandingkan dengan yang lainnya 19 | for (const [sender, value] of map.entries()) { 20 | if ( 21 | sameValue === null || 22 | value > sameValue || 23 | (value === sameValue && sender > largerName) 24 | ) { 25 | largerName = sender; 26 | sameValue = value; 27 | } 28 | } 29 | 30 | return largerName; 31 | }; -------------------------------------------------------------------------------- /2284-sender-with-largest-word-count/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2352-equal-row-and-column-pairs/2352-equal-row-and-column-pairs.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} grid 3 | * @return {number} 4 | */ 5 | var equalPairs = function(grid) { 6 | let count = 0; 7 | const kolom = []; 8 | 9 | for (let row = 0; row < grid.length; row++) { 10 | let temp = []; 11 | for (let col = 0; col < grid.length; col++) { 12 | temp.push(grid[col][row]); 13 | } 14 | kolom.push([...temp]); 15 | } 16 | 17 | for (let i = 0; i < grid.length; i++) { 18 | const baris = grid[i]; 19 | for (let j = 0; j < kolom.length; j++) { 20 | const row = kolom[j]; 21 | if (JSON.stringify(row) === JSON.stringify(baris)) { 22 | count++; 23 | } 24 | } 25 | } 26 | 27 | return count; 28 | }; -------------------------------------------------------------------------------- /2352-equal-row-and-column-pairs/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2356-number-of-unique-subjects-taught-by-each-teacher/2356-number-of-unique-subjects-taught-by-each-teacher.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | SELECT teacher_id, COUNT(DISTINCT subject_id) as 'cnt' 4 | FROM Teacher 5 | GROUP BY teacher_id 6 | -------------------------------------------------------------------------------- /2356-number-of-unique-subjects-taught-by-each-teacher/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2373-largest-local-values-in-a-matrix/2373-largest-local-values-in-a-matrix.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} grid 3 | * @return {number[][]} 4 | */ 5 | var largestLocal = function(grid) { 6 | 7 | let lokal = [] 8 | for (let row = 0; row < grid.length - 2; row++) { 9 | let temp = [] 10 | for (let col = 0; col < grid.length - 2; col++) { 11 | temp.push(0) 12 | } 13 | lokal.push([...temp]) 14 | } 15 | 16 | for (let row = 0; row < grid.length - 2; row++) { 17 | for (let col = 0; col < grid.length - 2; col++) { 18 | lokal[row][col] = Math.max( 19 | grid[row][col], grid[row][col+1], grid[row][col+2], 20 | grid[row+1][col], grid[row+1][col+1], grid[row+1][col+2], 21 | grid[row+2][col], grid[row+2][col+1], grid[row+2][col+2] 22 | ) 23 | } 24 | } 25 | 26 | return lokal 27 | 28 | }; -------------------------------------------------------------------------------- /2373-largest-local-values-in-a-matrix/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2389-longest-subsequence-with-limited-sum/2389-longest-subsequence-with-limited-sum.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number[]} queries 4 | * @return {number[]} 5 | */ 6 | 7 | function binarySearch(prefixSum, target){ 8 | let left = 0 9 | let right = prefixSum.length - 1 10 | while(left<=right){ 11 | let mid = Math.floor((left+right) / 2) 12 | if(prefixSum[mid] <= target){ 13 | left = mid + 1 14 | } else { 15 | right = mid - 1 16 | } 17 | } 18 | return left 19 | } 20 | 21 | var answerQueries = function (nums, queries) { 22 | let sorted = nums.sort((a, b) => a - b); 23 | 24 | let prefixSum = []; 25 | prefixSum[0] = sorted[0]; 26 | for (let i = 1; i < sorted.length; i++) { 27 | prefixSum[i] = sorted[i] + prefixSum[i - 1]; 28 | } 29 | 30 | let res = [] 31 | queries.forEach((queri) => { 32 | res.push(binarySearch(prefixSum, queri)) 33 | }) 34 | 35 | return res; 36 | }; -------------------------------------------------------------------------------- /2389-longest-subsequence-with-limited-sum/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2390-removing-stars-from-a-string/2390-removing-stars-from-a-string.js: -------------------------------------------------------------------------------- 1 | class Stack{ 2 | constructor(){ 3 | this.stack = [] 4 | } 5 | 6 | push(element){ 7 | this.stack.push(element) 8 | } 9 | 10 | pop(){ 11 | if(this.isEmpty()) return "Stack Kosong" 12 | return this.stack.pop() 13 | } 14 | 15 | isEmpty(){ 16 | return this.stack.length === 0 17 | } 18 | 19 | peek(){ 20 | return this.stack[this.stack.length - 1] 21 | } 22 | 23 | print(){ 24 | let string = "" 25 | for(let i = 0; i num % 2 === 0).sort((a,b) => a-b); 10 | if(even.length === 0) return -1 11 | 12 | //menghitung / counter untuk mendapatkan jumlah angka genapnya 13 | even.forEach((element) => {map.set(element, (map.get(element) || 0) + 1);}); 14 | //sorting map berdasarkan value dari yang terkecil 15 | const result = Array.from(map.entries()).sort((a, b) => b[1] - a[1]).slice(0, 1).map(([key]) => key); 16 | 17 | return result; 18 | }; -------------------------------------------------------------------------------- /2404-most-frequent-even-element/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2404-most-frequent-even-element/README.md: -------------------------------------------------------------------------------- 1 |

2404. Most Frequent Even Element

Easy

Given an integer array nums, return the most frequent even element.

2 | 3 |

If there is a tie, return the smallest one. If there is no such element, return -1.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: nums = [0,1,2,2,4,4,1]
 9 | Output: 2
10 | Explanation:
11 | The even elements are 0, 2, and 4. Of these, 2 and 4 appear the most.
12 | We return the smallest one, which is 2.
13 | 14 |

Example 2:

15 | 16 | 
Input: nums = [4,4,4,9,2,4]
17 | Output: 4
18 | Explanation: 4 is the even element appears the most.
19 |
20 | 21 |

Example 3:

22 | 23 | 
Input: nums = [29,47,21,41,13,37,25,7]
24 | Output: -1
25 | Explanation: There is no even element.
26 |
27 | 28 |

 

29 |

Constraints:

30 | 31 |
    32 |
  • 1 <= nums.length <= 2000
    • 33 |
  • 0 <= nums[i] <= 105
    • 34 |
35 |
-------------------------------------------------------------------------------- /2418-sort-the-people/2418-sort-the-people.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} names 3 | * @param {number[]} heights 4 | * @return {string[]} 5 | */ 6 | var sortPeople = function(names, heights) { 7 | let map = new Map() 8 | for (let i = 0; i < names.length; i++) { 9 | map.set(heights[i], names[i]) 10 | } 11 | return res = Array.from(map.entries()).sort((a,b) => b[0] - a[0]).map(element => element[1]) 12 | }; -------------------------------------------------------------------------------- /2418-sort-the-people/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2428-maximum-sum-of-an-hourglass/2428-maximum-sum-of-an-hourglass.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} grid 3 | * @return {number} 4 | */ 5 | var maxSum = function(grid) { 6 | let max = 0 7 | 8 | for (let row = 0; row < grid.length-2; row++) { 9 | for (let col = 0; col < grid[0].length-2; col++) { 10 | max = Math.max(max, grid[row][col] + grid[row][col+1] + grid[row][col+2] + grid[row+1][col+1] + grid[row+2][col] + grid[row+2][col+1] + grid[row+2][col+2]) 11 | } 12 | } 13 | 14 | return max 15 | }; -------------------------------------------------------------------------------- /2428-maximum-sum-of-an-hourglass/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2455-average-value-of-even-numbers-that-are-divisible-by-three/2455-average-value-of-even-numbers-that-are-divisible-by-three.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var averageValue = function(nums) { 6 | let total = 0; 7 | let even = Math.floor(nums.filter((element) => { 8 | if (element % 3 === 0 && element % 2 === 0) { 9 | total++; 10 | return element % 3 === 0 && element % 2 === 0; 11 | } 12 | }).reduce((cur, number) => { 13 | return cur + number 14 | }, 0) / total); 15 | 16 | 17 | if (total === 0) { 18 | return 0; 19 | } else { 20 | return even; 21 | } 22 | }; -------------------------------------------------------------------------------- /2455-average-value-of-even-numbers-that-are-divisible-by-three/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2455-average-value-of-even-numbers-that-are-divisible-by-three/README.md: -------------------------------------------------------------------------------- 1 |

2455. Average Value of Even Numbers That Are Divisible by Three

Easy

Given an integer array nums of positive integers, return the average value of all even integers that are divisible by 3.

2 | 3 |

Note that the average of n elements is the sum of the n elements divided by n and rounded down to the nearest integer.

4 | 5 |

 

6 |

Example 1:

7 | 8 | 
Input: nums = [1,3,6,10,12,15]
 9 | Output: 9
10 | Explanation: 6 and 12 are even numbers that are divisible by 3. (6 + 12) / 2 = 9.
11 |
12 | 13 |

Example 2:

14 | 15 | 
Input: nums = [1,2,4,7,10]
16 | Output: 0
17 | Explanation: There is no single number that satisfies the requirement, so return 0.
18 |
19 | 20 |

 

21 |

Constraints:

22 | 23 |
    24 |
  • 1 <= nums.length <= 1000
    • 25 |
  • 1 <= nums[i] <= 1000
    • 26 |
27 |
-------------------------------------------------------------------------------- /2460-apply-operations-to-an-array/2460-apply-operations-to-an-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var applyOperations = function(nums) { 6 | let result = [] 7 | let zero = [] 8 | 9 | let temp = nums 10 | for (let index = 0; index < nums.length; index++) { 11 | const first = nums[index]; 12 | const second = nums[index + 1] 13 | if(first === second){ 14 | temp[index] = nums[index] * 2 15 | temp[index+1] = 0 16 | } 17 | } 18 | 19 | for (let index = 0; index < temp.length; index++) { 20 | const element = nums[index]; 21 | if(element !== 0){ 22 | result.push(element) 23 | } else { 24 | zero.push(element) 25 | } 26 | } 27 | 28 | return result.concat(zero) 29 | }; -------------------------------------------------------------------------------- /2460-apply-operations-to-an-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2465-number-of-distinct-averages/2465-number-of-distinct-averages.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var distinctAverages = function(nums) { 6 | 7 | let sorted = nums.sort((a, b) => a-b) 8 | let set = new Set() 9 | while(sorted.length !== 0){ 10 | let avg = (sorted.shift() + sorted.pop()) / 2 11 | set.add(avg) 12 | } 13 | 14 | return set.size 15 | 16 | }; -------------------------------------------------------------------------------- /2465-number-of-distinct-averages/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2470-removing-stars-from-a-string/2470-removing-stars-from-a-string.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var removeStars = function(s) { 6 | let stack = [] 7 | 8 | s.split("").forEach((element) => { 9 | if(element != "*"){ 10 | stack.push(element) 11 | } else { 12 | stack.pop() 13 | } 14 | }) 15 | 16 | return stack.join("") 17 | }; -------------------------------------------------------------------------------- /2500-delete-greatest-value-in-each-row/2500-delete-greatest-value-in-each-row.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} grid 3 | * @return {number} 4 | */ 5 | var deleteGreatestValue = function (grid) { 6 | let res = 0 7 | 8 | //sorting sub array, karena kita ingin mengambil yang terbesar 9 | for (let i = 0; i < grid.length; i++) { 10 | grid[i].sort((a, b) => b - a); 11 | } 12 | 13 | //lakukan perulangan dengan jumlah isi dari sub array 14 | let total_row = grid[0].length 15 | for (let i = 0; i < total_row; i++) { 16 | let max = -Infinity; 17 | //perulangan untuk mencari nilai maks dari isi subarray 18 | for (let j = 0; j < grid.length; j++) { 19 | //bandingkan sub array sebelumnya dan sub array selanjutnya 20 | max = Math.max(max, grid[j][i]); 21 | } 22 | 23 | //tambah res dengan nilai maksnya, lalu lanjutkan ke sub array selanjutnya 24 | res += max; 25 | } 26 | 27 | return res; 28 | }; -------------------------------------------------------------------------------- /2500-delete-greatest-value-in-each-row/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2535-difference-between-element-sum-and-digit-sum-of-an-array/2535-difference-between-element-sum-and-digit-sum-of-an-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var differenceOfSum = function(nums) { 6 | 7 | let a = 0 8 | let b = 0 9 | for (let i = 0; i < nums.length; i++) { 10 | a += nums[i] 11 | const element = String(nums[i]).split(''); 12 | for (let j = 0; j < element.length; j++) { 13 | b+=parseInt(element[j]); 14 | } 15 | } 16 | 17 | return a - b 18 | }; -------------------------------------------------------------------------------- /2535-difference-between-element-sum-and-digit-sum-of-an-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2545-sort-the-students-by-their-kth-score/2545-sort-the-students-by-their-kth-score.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} score 3 | * @param {number} k 4 | * @return {number[][]} 5 | */ 6 | var sortTheStudents = function(score, k) { 7 | return score.sort((a, b) => b[k] - a[k]) 8 | }; -------------------------------------------------------------------------------- /2545-sort-the-students-by-their-kth-score/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2554-maximum-number-of-integers-to-choose-from-a-range-i/2554-maximum-number-of-integers-to-choose-from-a-range-i.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} banned 3 | * @param {number} n 4 | * @param {number} maxSum 5 | * @return {number} 6 | */ 7 | var maxCount = function (banned, n, maxSum) { 8 | let sum = 0, count = 0; 9 | 10 | let set = new Set(banned) 11 | for (let i = 1; i <= n; i++) { 12 | if (!set.has(i)) { 13 | //jika maxsum masih lebih besar dari currentsum 14 | if(maxSum >= sum+i){ 15 | //tambahkan currentsum dengan indeks 16 | sum += i 17 | //tambahkan count untuk result 18 | count++ 19 | } 20 | } 21 | } 22 | 23 | return count; 24 | }; -------------------------------------------------------------------------------- /2554-maximum-number-of-integers-to-choose-from-a-range-i/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2562-find-the-array-concatenation-value/2562-find-the-array-concatenation-value.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findTheArrayConcVal = function(nums) { 6 | let iterasi = Math.floor(nums.length / 2) 7 | 8 | let start = 0 9 | 10 | let end = nums.length - 1 11 | 12 | let res = 0 13 | 14 | if(nums.length % 2 !== 0){ 15 | 16 | res = nums[iterasi] 17 | 18 | } 19 | 20 | while(start < iterasi){ 21 | 22 | res += parseInt(`${nums[start]}${nums[end]}`) 23 | 24 | start++ 25 | 26 | end-- 27 | 28 | } 29 | 30 | return res 31 | 32 | }; -------------------------------------------------------------------------------- /2562-find-the-array-concatenation-value/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2574-left-and-right-sum-differences/2574-left-and-right-sum-differences.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var leftRightDifference = function(nums) { 6 | 7 | let leftPrefixSum = [] 8 | leftPrefixSum[0] = 0 9 | for (let i = 1; i < nums.length; i++) { 10 | leftPrefixSum[i] = leftPrefixSum[i-1] + nums[i-1] 11 | } 12 | 13 | let rightPrefixSum = [] 14 | rightPrefixSum[nums.length - 1] = 0 15 | for (let i = nums.length - 1; i > 0; i--) { 16 | rightPrefixSum[i-1] = nums[i] + rightPrefixSum[i] 17 | } 18 | 19 | let res = [] 20 | for (let i = 0; i < nums.length; i++) { 21 | res.push(Math.abs(leftPrefixSum[i] - rightPrefixSum[i])) 22 | 23 | } 24 | 25 | return res 26 | }; -------------------------------------------------------------------------------- /2574-left-and-right-sum-differences/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2586-count-the-number-of-vowel-strings-in-range/2586-count-the-number-of-vowel-strings-in-range.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} words 3 | * @param {number} left 4 | * @param {number} right 5 | * @return {number} 6 | */ 7 | var vowelStrings = function (words, left, right) { 8 | const vocal = ["a", "i", "u", "e", "o"]; 9 | let res = 0; 10 | 11 | for (let i = left; i <= right; i++) { 12 | const element = words[i]; 13 | if (vocal.includes(element[0]) && vocal.includes(element[element.length-1])) { 14 | res++; 15 | } 16 | } 17 | 18 | return res; 19 | }; -------------------------------------------------------------------------------- /2586-count-the-number-of-vowel-strings-in-range/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2610-convert-an-array-into-a-2d-array-with-conditions/2610-convert-an-array-into-a-2d-array-with-conditions.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[][]} 4 | */ 5 | var findMatrix = function(nums) { 6 | let map = new Map(); 7 | let answer = []; 8 | 9 | //counter 10 | for (num of nums) { 11 | map.set(num, (map.get(num) || 0) + 1); 12 | } 13 | 14 | map.forEach((value, key) => { 15 | for (let i = 0; i < value; i++) { 16 | let temp = answer[i] 17 | temp 18 | if (!temp) { 19 | answer.push([]); 20 | } 21 | answer[i].push(key); 22 | } 23 | }); 24 | return answer; 25 | }; -------------------------------------------------------------------------------- /2610-convert-an-array-into-a-2d-array-with-conditions/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2620-counter/2620-counter.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {Function} counter 4 | */ 5 | var createCounter = function(n) { 6 | 7 | let current = n 8 | return function() { 9 | console.log(current); 10 | return current++; 11 | }; 12 | }; 13 | 14 | /** 15 | * const counter = createCounter(10) 16 | * counter() // 10 17 | * counter() // 11 18 | * counter() // 12 19 | */ -------------------------------------------------------------------------------- /2620-counter/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2620-counter/README.md: -------------------------------------------------------------------------------- 1 |

2620. Counter

Easy

Given an integer n, return a counter function. This counter function initially returns n and then returns 1 more than the previous value every subsequent time it is called (n, n + 1, n + 2, etc).

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
Input: 
 7 | n = 10 
 8 | ["call","call","call"]
 9 | Output: [10,11,12]
10 | Explanation: 
11 | counter() = 10 // The first time counter() is called, it returns n.
12 | counter() = 11 // Returns 1 more than the previous time.
13 | counter() = 12 // Returns 1 more than the previous time.
14 |
15 | 16 |

Example 2:

17 | 18 | 
Input: 
19 | n = -2
20 | ["call","call","call","call","call"]
21 | Output: [-2,-1,0,1,2]
22 | Explanation: counter() initially returns -2. Then increases after each sebsequent call.
23 |
24 | 25 |

 

26 |

Constraints:

27 | 28 |
    29 |
  • -1000 <= n <= 1000
    • 30 |
  • At most 1000 calls to counter() will be made
    • 31 |
32 |
-------------------------------------------------------------------------------- /2626-array-reduce-transformation/2626-array-reduce-transformation.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {Function} fn 4 | * @param {number} init 5 | * @return {number} 6 | */ 7 | var reduce = function(nums, fn, init) { 8 | if(nums.length === 0){ 9 | return init 10 | } 11 | 12 | var temp = 0; 13 | for (let index = 0; index < nums.length; index++) { 14 | const element = nums[index]; 15 | temp = fn(init,element) 16 | init = temp; 17 | } 18 | 19 | return temp; 20 | } ; -------------------------------------------------------------------------------- /2626-array-reduce-transformation/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2629-function-composition/2629-function-composition.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {Function[]} functions 3 | * @return {Function} 4 | */ 5 | var compose = function(functions) { 6 | return (value) => { 7 | return functions.reduceRight((result, fn) => { 8 | return fn(result); 9 | }, value); 10 | }; 11 | }; 12 | 13 | /** 14 | * const fn = compose([x => x + 1, x => 2 * x]) 15 | * fn(4) // 9 16 | */ -------------------------------------------------------------------------------- /2629-function-composition/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2634-filter-elements-from-array/2634-filter-elements-from-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} arr 3 | * @param {Function} fn 4 | * @return {number[]} 5 | */ 6 | var filter = function(arr, fn) { 7 | const result = []; 8 | 9 | for (let index = 0; index < arr.length; index++) { 10 | if(fn(arr[index], index)){ 11 | result.push(arr[index]) 12 | }; 13 | } 14 | 15 | return result; 16 | }; -------------------------------------------------------------------------------- /2634-filter-elements-from-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2635-apply-transform-over-each-element-in-array/2635-apply-transform-over-each-element-in-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} arr 3 | * @param {Function} fn 4 | * @return {number[]} 5 | */ 6 | var map = function(arr, fn) { 7 | const toReturnArr = new Array(arr.length); 8 | for( let i=0;i} 3 | */ 4 | var fibGenerator = function*() { 5 | let a = 0, b = 1 6 | yield 0 7 | yield 1 8 | while(true) { 9 | [a,b] = [b, a + b] 10 | yield b 11 | } 12 | }; 13 | 14 | /** 15 | * const gen = fibGenerator(); 16 | * gen.next().value; // 0 17 | * gen.next().value; // 1 18 | */ -------------------------------------------------------------------------------- /2648-generate-fibonacci-sequence/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2648-generate-fibonacci-sequence/README.md: -------------------------------------------------------------------------------- 1 |

2648. Generate Fibonacci Sequence

Easy

Write a generator function that returns a generator object which yields the fibonacci sequence.

2 | 3 |

The fibonacci sequence is defined by the relation Xn = Xn-1 + Xn-2.

4 | 5 |

The first few numbers of the series are 0, 1, 1, 2, 3, 5, 8, 13.

6 | 7 |

 

8 |

Example 1:

9 | 10 | 
Input: callCount = 5
11 | Output: [0,1,1,2,3]
12 | Explanation:
13 | const gen = fibGenerator();
14 | gen.next().value; // 0
15 | gen.next().value; // 1
16 | gen.next().value; // 1
17 | gen.next().value; // 2
18 | gen.next().value; // 3
19 |
20 | 21 |

Example 2:

22 | 23 | 
Input: callCount = 0
24 | Output: []
25 | Explanation: gen.next() is never called so nothing is outputted
26 |
27 | 28 |

 

29 |

Constraints:

30 | 31 |
    32 |
  • 0 <= callCount <= 50
    • 33 |
34 |
-------------------------------------------------------------------------------- /2652-sum-multiples/2652-sum-multiples.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var sumOfMultiples = function(n) { 6 | let ans = [] 7 | for (let i = 1; i <= n; i++) { 8 | if(i % 3 === 0 || i % 5 === 0 || i % 7 === 0){ 9 | ans.push(i) 10 | } 11 | } 12 | 13 | ans 14 | 15 | let sum = ans.reduce((cur, num) => { 16 | return cur + num 17 | }, 0) 18 | 19 | return sum; 20 | }; -------------------------------------------------------------------------------- /2652-sum-multiples/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2656-maximum-sum-with-exactly-k-elements/2656-maximum-sum-with-exactly-k-elements.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {number} 5 | */ 6 | var maximizeSum = function(nums, k) { 7 | let max = -Infinity 8 | let sum = 0 9 | for(let i = 0; i < k; i++){ 10 | max = Math.max(...nums) 11 | sum += max 12 | nums.push(max + 1) 13 | } 14 | 15 | return sum 16 | }; -------------------------------------------------------------------------------- /2656-maximum-sum-with-exactly-k-elements/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2657-find-the-prefix-common-array-of-two-arrays/2657-find-the-prefix-common-array-of-two-arrays.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} A 3 | * @param {number[]} B 4 | * @return {number[]} 5 | */ 6 | var findThePrefixCommonArray = function(A, B) { 7 | let res = [] 8 | 9 | for (let i = 1; i <= A.length; i++) { 10 | let a = A.slice(0, i) 11 | let b = B.slice(0, i) 12 | let arr = a.concat(b) 13 | let map = new Map() 14 | 15 | let temp = 0 16 | arr.forEach((element) => { 17 | map.set(element, (map.get(element) || 0) + 1) 18 | if (map.get(element) > 1) { 19 | temp++ 20 | } 21 | }) 22 | res.push(temp) 23 | } 24 | 25 | return res 26 | }; -------------------------------------------------------------------------------- /2657-find-the-prefix-common-array-of-two-arrays/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2665-counter-ii/2665-counter-ii.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {integer} init 3 | * @return { increment: Function, decrement: Function, reset: Function } 4 | */ 5 | var createCounter = function(init) { 6 | let currentCount = init; 7 | return { 8 | increment: function() { 9 | currentCount += 1; 10 | return currentCount; 11 | }, 12 | decrement: function() { 13 | currentCount -= 1; 14 | return currentCount; 15 | }, 16 | reset: function() { 17 | currentCount = init; 18 | return currentCount; 19 | }, 20 | } 21 | }; 22 | 23 | /** 24 | * const counter = createCounter(5) 25 | * counter.increment(); // 6 26 | * counter.reset(); // 5 27 | * counter.decrement(); // 4 28 | */ -------------------------------------------------------------------------------- /2665-counter-ii/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2667-create-hello-world-function/2667-create-hello-world-function.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @return {Function} 3 | */ 4 | var createHelloWorld = function() { 5 | return function(...args) { 6 | return "Hello World" 7 | } 8 | }; 9 | 10 | /** 11 | * const f = createHelloWorld(); 12 | * f(); // "Hello World" 13 | */ -------------------------------------------------------------------------------- /2667-create-hello-world-function/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2667-create-hello-world-function/README.md: -------------------------------------------------------------------------------- 1 |

2667. Create Hello World Function

Easy

Write a function createHelloWorld. It should return a new function that always returns "Hello World". 2 |

 

3 |

Example 1:

4 | 5 | 
Input: args = []
 6 | Output: "Hello World"
 7 | Explanation:
 8 | const f = createHelloWorld();
 9 | f(); // "Hello World"
10 | 
11 | The function returned by createHelloWorld should always return "Hello World".
12 |
13 | 14 |

Example 2:

15 | 16 | 
Input: args = [{},null,42]
17 | Output: "Hello World"
18 | Explanation:
19 | const f = createHelloWorld();
20 | f({}, null, 42); // "Hello World"
21 | 
22 | Any arguments could be passed to the function but it should still always return "Hello World".
23 |
24 | 25 |

 

26 |

Constraints:

27 | 28 |
    29 |
  • 0 <= args.length <= 10
    • 30 |
31 |
-------------------------------------------------------------------------------- /2670-find-the-distinct-difference-array/2670-find-the-distinct-difference-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var distinctDifferenceArray = function(nums) { 6 | let res = [] 7 | nums.forEach((element, index) => { 8 | let setPrefix = new Set() 9 | let setSuffix = new Set() 10 | 11 | for (let i = 0; i < index+1; i++) { 12 | setPrefix.add(nums[i]) 13 | } 14 | for (let i = index+1; i < nums.length; i++) { 15 | setSuffix.add(nums[i]) 16 | } 17 | res.push(setPrefix.size - setSuffix.size) 18 | }) 19 | 20 | return res 21 | }; -------------------------------------------------------------------------------- /2670-find-the-distinct-difference-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2677-chunk-array/2677-chunk-array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {Array} arr 3 | * @param {number} size 4 | * @return {Array[]} 5 | */ 6 | var chunk = function(arr, size) { 7 | var chunkedArray = []; 8 | var index = 0; 9 | 10 | while (index < arr.length) { 11 | const chunk = arr.slice(index, index + size) 12 | chunkedArray.push(chunk); 13 | index += size; 14 | } 15 | 16 | return chunkedArray; 17 | }; -------------------------------------------------------------------------------- /2677-chunk-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2678-number-of-senior-citizens/2678-number-of-senior-citizens.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} details 3 | * @return {number} 4 | */ 5 | var countSeniors = function(details) { 6 | let count = 0; 7 | details.forEach(element => { 8 | const age = element.slice(11,13) 9 | if(age > 60) count++ 10 | }); 11 | 12 | return count 13 | }; -------------------------------------------------------------------------------- /2678-number-of-senior-citizens/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2729-check-if-the-number-is-fascinating/2729-check-if-the-number-is-fascinating.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {boolean} 4 | */ 5 | var isFascinating = function(n) { 6 | 7 | //gabungkan jadi satu 8 | let res = `${n}${n*2}${n*3}`.split('') 9 | 10 | if(res.includes('0')){ 11 | return false 12 | } 13 | if(res.length !== 9){ 14 | return false 15 | } 16 | if ((new Set(res)).size !== 9) { 17 | return false 18 | } 19 | 20 | return true 21 | }; -------------------------------------------------------------------------------- /2729-check-if-the-number-is-fascinating/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2732-counter/2732-counter.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {Function} counter 4 | */ 5 | var createCounter = function(n) { 6 | 7 | let current = n 8 | return function() { 9 | console.log(current); 10 | return current++; 11 | }; 12 | }; 13 | 14 | /** 15 | * const counter = createCounter(10) 16 | * counter() // 10 17 | * counter() // 11 18 | * counter() // 12 19 | */ -------------------------------------------------------------------------------- /2732-counter/README.md: -------------------------------------------------------------------------------- 1 |

2732. Counter

Easy

Given an integer n, return a counter function. This counter function initially returns n and then returns 1 more than the previous value every subsequent time it is called (n, n + 1, n + 2, etc).

2 | 3 |

 

4 |

Example 1:

5 | 6 | 
 7 | Input: 
 8 | n = 10 
 9 | ["call","call","call"]
10 | Output: [10,11,12]
11 | Explanation: 
12 | counter() = 10 // The first time counter() is called, it returns n.
13 | counter() = 11 // Returns 1 more than the previous time.
14 | counter() = 12 // Returns 1 more than the previous time.
15 |
16 | 17 |

Example 2:

18 | 19 | 
20 | Input: 
21 | n = -2
22 | ["call","call","call","call","call"]
23 | Output: [-2,-1,0,1,2]
24 | Explanation: counter() initially returns -2. Then increases after each sebsequent call.
25 |
26 | 27 |

 

28 |

Constraints:

29 | 30 |
    31 |
  • -1000 <= n <= 1000
    • 32 |
  • At most 1000 calls to counter() will be made
    • 33 |
34 | -------------------------------------------------------------------------------- /2785-sort-vowels-in-a-string/2785-sort-vowels-in-a-string.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var sortVowels = function (s) { 6 | const vowel = "AEIOUaeiou"; 7 | let vowels = ""; 8 | 9 | for (let i = 0; i < s.length; i++) { 10 | if (vowel.includes(s[i])) { 11 | vowels += s[i]; 12 | } 13 | } 14 | 15 | vowels = vowels.split("").sort((a, b) => a.charCodeAt() - b.charCodeAt()).join(""); 16 | 17 | let result = ""; 18 | 19 | let j = 0; 20 | for (let i = 0; i < s.length; i++) { 21 | if (vowel.includes(s[i])) { 22 | result += vowels[j]; 23 | j++; 24 | } else { 25 | result += s[i]; 26 | } 27 | } 28 | 29 | return result; 30 | }; -------------------------------------------------------------------------------- /2785-sort-vowels-in-a-string/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2809-create-hello-world-function/2809-create-hello-world-function.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @return {Function} 3 | */ 4 | var createHelloWorld = function() { 5 | return function(...args) { 6 | return "Hello World" 7 | } 8 | }; 9 | 10 | /** 11 | * const f = createHelloWorld(); 12 | * f(); // "Hello World" 13 | */ -------------------------------------------------------------------------------- /2809-create-hello-world-function/README.md: -------------------------------------------------------------------------------- 1 |

2809. Create Hello World Function

Easy

Write a function createHelloWorld. It should return a new function that always returns "Hello World". 2 |

 

3 |

Example 1:

4 | 5 | 
 6 | Input: args = []
 7 | Output: "Hello World"
 8 | Explanation:
 9 | const f = createHelloWorld();
10 | f(); // "Hello World"
11 | 
12 | The function returned by createHelloWorld should always return "Hello World".
13 |
14 | 15 |

Example 2:

16 | 17 | 
18 | Input: args = [{},null,42]
19 | Output: "Hello World"
20 | Explanation:
21 | const f = createHelloWorld();
22 | f({}, null, 42); // "Hello World"
23 | 
24 | Any arguments could be passed to the function but it should still always return "Hello World".
25 |
26 | 27 |

 

28 |

Constraints:

29 | 30 |
    31 |
  • 0 <= args.length <= 10
    • 32 |
33 | -------------------------------------------------------------------------------- /2870-minimum-number-of-operations-to-make-array-empty/2870-minimum-number-of-operations-to-make-array-empty.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minOperations(self, nums: List[int]) -> int: 3 | count = Counter(nums) 4 | res = 0 5 | 6 | for total in count.values(): 7 | 8 | #return -1, karena kita hanya mengambil 2 atau 3 9 | if total < 2: 10 | return -1 11 | 12 | res += total // 3 13 | if total % 3 == 1 or total % 3 == 2: 14 | res += 1 15 | 16 | return res 17 | -------------------------------------------------------------------------------- /2870-minimum-number-of-operations-to-make-array-empty/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # leetcode-solved 2 | Collection of LeetCode questions to ace the coding interview! - Created using [LeetHub](https://github.com/QasimWani/LeetHub) 3 | --------------------------------------------------------------------------------