├── 0002-add-two-numbers ├── 0002-add-two-numbers.py ├── NOTES.md └── README.md ├── 0003-longest-substring-without-repeating-characters ├── 0003-longest-substring-without-repeating-characters.py ├── NOTES.md └── README.md ├── 0005-longest-palindromic-substring ├── 0005-longest-palindromic-substring.py ├── NOTES.md └── README.md ├── 0006-zigzag-conversion ├── 0006-zigzag-conversion.py ├── NOTES.md └── README.md ├── 0007-reverse-integer ├── 0007-reverse-integer.py ├── NOTES.md └── README.md ├── 0008-string-to-integer-atoi ├── 0008-string-to-integer-atoi.py ├── NOTES.md └── README.md ├── 0033-search-in-rotated-sorted-array ├── 0033-search-in-rotated-sorted-array.py └── README.md ├── 0041-first-missing-positive ├── 0041-first-missing-positive.py ├── NOTES.md └── README.md ├── 0043-multiply-strings ├── 0043-multiply-strings.py ├── NOTES.md └── README.md ├── 0049-group-anagrams ├── 0049-group-anagrams.py └── README.md ├── 0055-jump-game ├── 0055-jump-game.py ├── NOTES.md └── README.md ├── 0056-merge-intervals ├── 0056-merge-intervals.py ├── NOTES.md └── README.md ├── 0061-rotate-list ├── 0061-rotate-list.py ├── NOTES.md └── README.md ├── 0066-plus-one ├── 0066-plus-one.cpp ├── 0066-plus-one.java ├── 0066-plus-one.scala ├── 0066-plus-one.swift ├── NOTES.md └── README.md ├── 0070-climbing-stairs ├── 0070-climbing-stairs.py ├── NOTES.md └── README.md ├── 0079-word-search ├── 0079-word-search.py ├── NOTES.md └── README.md ├── 0086-partition-list ├── 0086-partition-list.py ├── NOTES.md └── README.md ├── 0124-binary-tree-maximum-path-sum ├── 0124-binary-tree-maximum-path-sum.py ├── NOTES.md └── README.md ├── 0148-sort-list ├── 0148-sort-list.py ├── NOTES.md └── README.md ├── 0150-evaluate-reverse-polish-notation ├── 0150-evaluate-reverse-polish-notation.py ├── NOTES.md └── README.md ├── 0167-two-sum-ii-input-array-is-sorted ├── 0167-two-sum-ii-input-array-is-sorted.py ├── NOTES.md └── README.md ├── 0198-house-robber ├── 0198-house-robber.py ├── NOTES.md └── README.md ├── 0222-count-complete-tree-nodes ├── 0222-count-complete-tree-nodes.py ├── NOTES.md └── README.md ├── 0232-implement-queue-using-stacks ├── 0232-implement-queue-using-stacks.py ├── NOTES.md └── README.md ├── 0263-ugly-number ├── 0263-ugly-number.py ├── NOTES.md └── README.md ├── 0279-perfect-squares ├── 0279-perfect-squares.py ├── NOTES.md └── README.md ├── 0295-find-median-from-data-stream ├── 0295-find-median-from-data-stream.py └── NOTES.md ├── 0309-best-time-to-buy-and-sell-stock-with-cooldown ├── 0309-best-time-to-buy-and-sell-stock-with-cooldown.py └── NOTES.md ├── 0328-odd-even-linked-list ├── 0328-odd-even-linked-list.py ├── NOTES.md └── README.md ├── 0374-guess-number-higher-or-lower ├── 0374-guess-number-higher-or-lower.py └── NOTES.md ├── 0380-insert-delete-getrandom-o1 ├── 0380-insert-delete-getrandom-o1.py ├── NOTES.md └── README.md ├── 0441-arranging-coins ├── 0441-arranging-coins.py └── README.md ├── 0451-sort-characters-by-frequency ├── 0451-sort-characters-by-frequency.py ├── NOTES.md └── README.md ├── 0507-perfect-number ├── 0507-perfect-number.py ├── NOTES.md └── README.md ├── 0520-detect-capital ├── 0520-detect-capital.py ├── NOTES.md └── README.md ├── 0646-maximum-length-of-pair-chain ├── 0646-maximum-length-of-pair-chain.py ├── NOTES.md └── README.md ├── 0728-self-dividing-numbers ├── 0728-self-dividing-numbers.py └── README.md ├── 0739-daily-temperatures ├── 0739-daily-temperatures.py ├── NOTES.md └── README.md ├── 0790-domino-and-tromino-tiling ├── 0790-domino-and-tromino-tiling.py └── README.md ├── 0797-all-paths-from-source-to-target ├── 0797-all-paths-from-source-to-target.py └── README.md ├── 0834-sum-of-distances-in-tree ├── 0834-sum-of-distances-in-tree.py └── README.md ├── 0841-keys-and-rooms ├── 0841-keys-and-rooms.py ├── NOTES.md └── README.md ├── 0872-leaf-similar-trees ├── 0872-leaf-similar-trees.py ├── NOTES.md └── README.md ├── 0876-middle-of-the-linked-list ├── 0876-middle-of-the-linked-list.py ├── NOTES.md └── README.md ├── 0886-possible-bipartition ├── 0886-possible-bipartition.py └── README.md ├── 0931-minimum-falling-path-sum ├── 0931-minimum-falling-path-sum.py ├── NOTES.md └── README.md ├── 0938-range-sum-of-bst ├── 0938-range-sum-of-bst.py ├── NOTES.md └── README.md ├── 0980-unique-paths-iii ├── 0980-unique-paths-iii.py ├── NOTES.md └── README.md ├── 1025-divisor-game ├── 1025-divisor-game.py ├── NOTES.md └── README.md ├── 1026-maximum-difference-between-node-and-ancestor ├── 1026-maximum-difference-between-node-and-ancestor.py ├── NOTES.md └── README.md ├── 1114-print-in-order ├── 1114-print-in-order.py ├── NOTES.md └── README.md ├── 1143-longest-common-subsequence ├── 1143-longest-common-subsequence.py ├── NOTES.md └── README.md ├── 1207-unique-number-of-occurrences ├── 1207-unique-number-of-occurrences.py ├── NOTES.md └── README.md ├── 1221-split-a-string-in-balanced-strings ├── 1221-split-a-string-in-balanced-strings.py ├── NOTES.md └── README.md ├── 1281-subtract-the-product-and-sum-of-digits-of-an-integer ├── 1281-subtract-the-product-and-sum-of-digits-of-an-integer.py ├── NOTES.md └── README.md ├── 1332-remove-palindromic-subsequences ├── 1332-remove-palindromic-subsequences.py └── NOTES.md ├── 1339-maximum-product-of-splitted-binary-tree ├── 1339-maximum-product-of-splitted-binary-tree.py ├── NOTES.md └── README.md ├── 1342-number-of-steps-to-reduce-a-number-to-zero ├── 1342-number-of-steps-to-reduce-a-number-to-zero.java ├── 1342-number-of-steps-to-reduce-a-number-to-zero.js ├── 1342-number-of-steps-to-reduce-a-number-to-zero.py ├── NOTES.md └── README.md ├── 1393-capital-gain-loss ├── 1393-capital-gain-loss.sql ├── NOTES.md └── README.md ├── 1408-string-matching-in-an-array ├── 1408-string-matching-in-an-array.py └── README.md ├── 1431-kids-with-the-greatest-number-of-candies ├── 1431-kids-with-the-greatest-number-of-candies.py ├── NOTES.md └── README.md ├── 1491-average-salary-excluding-the-minimum-and-maximum-salary ├── NOTES.md └── README.md ├── 1657-determine-if-two-strings-are-close ├── 1657-determine-if-two-strings-are-close.py ├── NOTES.md └── README.md ├── 1662-check-if-two-string-arrays-are-equivalent ├── 1662-check-if-two-string-arrays-are-equivalent.py ├── NOTES.md └── README.md ├── 1672-richest-customer-wealth ├── 1672-richest-customer-wealth.py ├── NOTES.md └── README.md ├── 1678-goal-parser-interpretation ├── 1678-goal-parser-interpretation.py ├── NOTES.md └── README.md ├── 1688-count-of-matches-in-tournament ├── 1688-count-of-matches-in-tournament.py └── README.md ├── 1693-daily-leads-and-partners ├── 1693-daily-leads-and-partners.sql └── README.md ├── 1704-determine-if-string-halves-are-alike ├── 1704-determine-if-string-halves-are-alike.py ├── NOTES.md └── README.md ├── 1732-find-the-highest-altitude ├── 1732-find-the-highest-altitude.py ├── NOTES.md └── README.md ├── 1741-find-total-time-spent-by-each-employee ├── 1741-find-total-time-spent-by-each-employee.sql └── README.md ├── 1768-merge-strings-alternately ├── 1768-merge-strings-alternately.py ├── NOTES.md └── README.md ├── 1773-count-items-matching-a-rule ├── 1773-count-items-matching-a-rule.py └── README.md ├── 1816-truncate-sentence ├── 1816-truncate-sentence.py ├── NOTES.md └── README.md ├── 1832-check-if-the-sentence-is-pangram ├── 1832-check-if-the-sentence-is-pangram.py └── NOTES.md ├── 1834-single-threaded-cpu ├── 1834-single-threaded-cpu.py ├── NOTES.md └── README.md ├── 1877-minimize-maximum-pair-sum-in-array ├── 1877-minimize-maximum-pair-sum-in-array.py ├── NOTES.md └── README.md ├── 1926-nearest-exit-from-entrance-in-maze ├── 1926-nearest-exit-from-entrance-in-maze.py ├── NOTES.md └── README.md ├── 1941-check-if-all-characters-have-equal-number-of-occurrences ├── 1941-check-if-all-characters-have-equal-number-of-occurrences.py ├── NOTES.md └── README.md ├── 1962-remove-stones-to-minimize-the-total ├── 1962-remove-stones-to-minimize-the-total.py └── README.md ├── 1971-find-if-path-exists-in-graph ├── 1971-find-if-path-exists-in-graph.py ├── NOTES.md └── README.md ├── 2089-find-target-indices-after-sorting-array ├── 2089-find-target-indices-after-sorting-array.py ├── NOTES.md └── README.md ├── 2114-maximum-number-of-words-found-in-sentences ├── 2114-maximum-number-of-words-found-in-sentences.py ├── NOTES.md └── README.md ├── 2131-longest-palindrome-by-concatenating-two-letter-words ├── 2131-longest-palindrome-by-concatenating-two-letter-words.py └── README.md ├── 2176-count-equal-and-divisible-pairs-in-an-array ├── 2176-count-equal-and-divisible-pairs-in-an-array.py ├── NOTES.md └── README.md ├── 2256-minimum-average-difference ├── 2256-minimum-average-difference.py ├── NOTES.md └── README.md ├── 2259-remove-digit-from-number-to-maximize-result ├── 2259-remove-digit-from-number-to-maximize-result.py ├── NOTES.md └── README.md ├── 2279-maximum-bags-with-full-capacity-of-rocks ├── 2279-maximum-bags-with-full-capacity-of-rocks.py ├── NOTES.md └── README.md ├── 2309-greatest-english-letter-in-upper-and-lower-case ├── 2309-greatest-english-letter-in-upper-and-lower-case.py ├── NOTES.md └── README.md ├── 2315-count-asterisks ├── 2315-count-asterisks.py ├── NOTES.md └── README.md ├── 2363-merge-similar-items ├── 2363-merge-similar-items.py ├── NOTES.md └── README.md ├── 2367-number-of-arithmetic-triplets ├── 2367-number-of-arithmetic-triplets.py ├── NOTES.md └── README.md ├── 2389-longest-subsequence-with-limited-sum ├── 2389-longest-subsequence-with-limited-sum.py ├── NOTES.md └── README.md ├── 2469-convert-the-temperature ├── 2469-convert-the-temperature.py ├── NOTES.md └── README.md ├── 2506-count-pairs-of-similar-strings ├── 2506-count-pairs-of-similar-strings.py ├── NOTES.md └── README.md ├── 2574-left-and-right-sum-differences ├── 2574-left-and-right-sum-differences.py ├── NOTES.md └── README.md ├── 2619-array-prototype-last ├── 2619-array-prototype-last.js ├── NOTES.md └── README.md ├── 2620-counter ├── 2620-counter.js ├── NOTES.md └── README.md ├── 2621-sleep ├── 2621-sleep.ts ├── NOTES.md └── README.md ├── 2652-sum-multiples ├── 2652-sum-multiples.py ├── NOTES.md └── README.md ├── 2703-return-length-of-arguments-passed ├── 2703-return-length-of-arguments-passed.js ├── NOTES.md └── README.md ├── 3Sum └── 3Sum.py ├── ActorsAndDirectorsWhoCooperatedAtLeastThreeTimes └── ActorsAndDirectorsWhoCooperatedAtLeastThreeTimes.sql ├── AddBinary ├── AddBinary.js └── AddBinary.py ├── AddDigits └── AddDigits.py ├── AddStrings ├── AddStrings.js └── AddStrings.py ├── AddTwoIntegers └── AddTwoIntegers.py ├── ArrayPartition ├── ArrayPartition.js └── ArrayPartition.py ├── AssignCookies ├── AssignCookies.js └── AssignCookies.py ├── AverageSalaryExcludingTheMinimumAndMaximumSalary └── AverageSalaryExcludingTheMinimumAndMaximumSalary.py ├── BalancedBinaryTree ├── BalBinTree.js └── BalBinTree.py ├── BaseballGame ├── BaseBallGame.js └── BaseballGame.py ├── BestTimeToBuyAndSellStock ├── BestTime.js └── BestTime.py ├── BigCountries └── BigCountries.sql ├── BinarySearch └── BinarySearch.py ├── BinaryTreeInorderTraversal ├── BinTreeInTrav.js └── BinTreeInTrav.py ├── BinaryTreePaths ├── BinaryTreePaths.js └── BinaryTreePaths.py ├── BinaryTreePostorderTraversal └── BinaryTreePostorderTraversal.py ├── BinaryTreePreorderTraversal └── BinaryTreePreorderTraversal.py ├── BinaryTreeWithFactors └── BinaryTreeWithFactors.py ├── BuddyStrings └── BuddyStrings.py ├── BuildArrayFromPermutation └── BuildArrayFromPermutation.py ├── CanMakeArithmeticProgressionFromSequence └── CanMakeArithmeticProgressionFromSequence.py ├── CanPlaceFlowers ├── CanPlaceFlowers.js └── CanPlaceFlowers.py ├── CheckIfNAndItsDoubleExist ├── CheckIfNAndItsDoubleExist.js └── CheckIfNAndItsDoubleExist.py ├── ClassesMoreThan5Students └── ClassesMoreThan5Students.sql ├── ClimbingStairs ├── CliSta.js └── CliSta.py ├── CombinationSum └── CombinationSum.py ├── CombinationSumII └── CombinationSumII.py ├── CombinationSumIV └── CombinationSumIV.py ├── CombineTwoTables └── CombineTwoTables.sql ├── ConcatenationOfArray └── ConcatenationOfArray.py ├── ConstructStringFromBinaryTree └── ConstructStringFromBinaryTree.py ├── ContainerWithMostWater └── ContainerWithMostWater.py ├── ContainsDublicate ├── ContainsDub.js └── ContainsDub.py ├── ContainsDublicateII(2) ├── ContainsDubII.js └── ContainsDubII.py ├── ConvertSortedArrayToBinarySearchTree ├── ConSortArrBinTree.js └── ConSortArrBinTree.py ├── CountAndSay └── CountAndSay.py ├── CountBinarySubstrings └── CountBinarySubstrings.py ├── CountVowelsPermutation └── CountVowelsPermutation.py ├── CreateTargetArrayInTheGivenOrder └── CreateTargetArrayInTheGivenOrder.py ├── CustomerPlacingTheLargestNumberOfOrders └── CustomerPlacingTheLargestNumberOfOrders.sql ├── CustomersWhoNeverOrder └── CusWhoNevOrd.sql ├── DefangingAnIPAddress └── DefangingAnIPAddress.py ├── DegreeOfAnArray ├── DegreeOfAnArray.js └── DegreeOfAnArray.py ├── DeleteDublicateEmails └── DeleteDublicateEmails.sql ├── DesignHashSet └── DesignHashSet.py ├── DesignHashmap ├── DesMap.js └── DesMap.py ├── DetectCapital ├── DetectCapital.js └── DetectCapital.py ├── DistributeCandies ├── DisCan.js └── DisCan.py ├── DuplicateEmails └── DuplicateEmails.sql ├── EmployeesEarningMoreThanTheirManagers └── EmployessEarning.sql ├── ExcelSheetColumnNumber ├── ExcelSheetColumnNumber.js └── ExcelSheetColumnNumber.py ├── ExcelSheetColumnTitle ├── ExcelSheetColumnTitle.js └── ExcelSheetColumnTitle.py ├── FairCandySwap └── FairCandySwap.py ├── Fibonacci ├── Fibo.js └── Fibo.py ├── FinalValueOfVariableAfterPerformingOperations └── FinalValueOfVariableAfterPerformingOperations.py ├── FindAllNumbersDisappearedInAnArray ├── FindAllNumDis.js └── FindAllNumDis.py ├── FindCommonCharacters └── FindCommonCharacters.py ├── FindCustomerReferee └── FindCustomerReferee.sql ├── FindFirstAndLastPositionOfElementInSortedArray └── FindFirstAndLastPositionOfElementInSortedArray.py ├── FindLuckyIntegerInAnArray └── FindLuckyIntegerInAnArray.py ├── FindTheDifference ├── FindTheDifference.js └── FindTheDifference.py ├── FindTheDistanceValueBetweenTwoArrays └── FindTheDistanceValueBetweenTwoArrays.py ├── FindTheTownJudge └── FindTheTownJudge.py ├── FindTotalTimeSpentByEachEmployee └── FindTotalTimeSpentByEachEmployee.sql ├── FirstUniqueCharacterInString ├── FirstUnCharStr.js └── FirstUnCharStr.py ├── FizzBuzz ├── FizzBuzz.js └── FizzBuzz.py ├── GamePlayAnalysisI └── GamePlayAnalysisI.sql ├── GenerateParentheses └── GenerateParentheses.py ├── GroupAnagrams └── GroupAnagrams.py ├── GroupThePeopleGivenTheGroupSizeTheyBelongTo └── GroupThePeopleGivenTheGroupSizeTheyBelongTo.py ├── HappyNumber └── HappyNumber.py ├── HeightChecker └── HeightChecker.py ├── HowManyNumbersAreSmallerThanTheCurrentNumber └── HowManyNumbersAreSmallerThanTheCurrentNumber.py ├── ImageSmoother ├── ImageSmoother.js └── ImageSmoother.py ├── ImplementQueueUsingStacks └── ImplementQueueUsingStacks.py ├── ImplementStr ├── ImplStr.js └── ImplStr.py ├── IncreasingTripletSubsequence ├── IncreasingTripletSubsequence.js └── IncreasingTripletSubsequence.py ├── IntegerToRoman ├── IntegerToRoman.js └── IntegerToRoman.py ├── InterSectionOfTwoArraysII ├── InsecOfTwoArrII.js └── InsecOfTwoArrII.py ├── IntersectionOfTwoArrays ├── InsecOfTwoArr.js └── InsecOfTwoArr.py ├── IntersectionOfTwoLinkedLists └── IntersectionOfTwoLinkedLists.py ├── InvertBinaryTree └── InvertBinaryTree.py ├── IsSubsequence ├── IsSubsequence.js └── IsSubsequence.py ├── IslandPerimeter ├── IslandPerimeter.js └── IslandPerimeter.py ├── IsomorphicStrings ├── IsomorphicStrings.js └── IsomorphicStrings.py ├── JewelsAndStones ├── JewelsAndStones.js └── JewelsAndStones.py ├── JumpGame └── JumpGame.py ├── JumpGameII └── JumpGameII.py ├── KeyboardRow ├── KeyboardRow.js └── KeyboardRow.py ├── KthSmallestElementInSortedMatrix └── KthSmallElemInSortMatrix.py ├── LargestNumberAtLeastTwiceOfOthers └── LargestNumberAtLeastTwiceOfOthers.py ├── LargestPerimeterTriangle └── LargestPerimeterTriangle.py ├── LengthOfLastWord ├── LenLastWord.py └── LenLastWors.js ├── LetterCombinationsOfPhoneNumber └── LetterCombinationsOfPhoneNumber.py ├── LicenseKeyFormatting └── LicenseKeyFormat.py ├── LinkedListCycle └── LinkedListCycle.py ├── LongestCommonPrefix ├── LonComPref.js └── LonComPref.py ├── LongestContinuousIncreasingSubsequence ├── LonConIncSub.js └── LonConIncSub.py ├── LongestHarmoniousSubsequence ├── LonHarSub.py └── LonHurSub.js ├── LongestIncreasingSubsequence └── LongestIncreasingSubsequence.py ├── LongestPalindrome ├── LongestPalindrome.js └── LongestPalindrome.py ├── LongestUncommonSubsequenceI └── LongestUncommonSubsequenceI.py ├── LowestCommonAncestorOfBinarySearchTree └── LowestCommonAncestorOfBinarySearchTree.py ├── MajorityElement ├── MajorityElem.js └── MajorityElem.py ├── MakeTheStringGreat └── MakeTheStringGreat.py ├── MakeTwoArraysEqualByReversingSubarrays └── MakeTwoArraysEqualByReversingSubarrays.py ├── MatrixCellsInDistanceOrder └── MatrixCellsInDistanceOrder.py ├── MaxConsecutiveOnes ├── MaxConOne.js └── MaxConOne.py ├── MaxSumOfRectangleNoLargerThanK └── MaxSumOfRectangleNoLargerThanK.py ├── MaximizeSumOfArrayAfterKNegations └── MaximizeSumOfArrayAfterKNegations.py ├── Maximum69Number └── Maximum69Number.py ├── MaximumAverageSubarrayI ├── MaxAverSubArrI.js └── MaxAverSubArrI.py ├── MaximumDepthOfBinaryTree └── MaximumDepthOfBinaryTree.py ├── MaximumProductDifferenceBetweenTwoPairs └── MaximumProductDifferenceBetweenTwoPairs.py ├── MaximumProductOfThreeNumbers ├── MaxProdOfThreeNum.js └── MaxProdOfThreeNum.py ├── MaximumProductOfTwoElementsInAnArray └── MaximumProductOfTwoElementsInAnArray.py ├── MaximumSubarray ├── MaxSubArr.js └── MaxSubArr.py ├── MaximumUnitsOnTruck └── MaximumUnitsOnTruck.py ├── MeanOfArrayAfterRemovingSomeElements └── MeanOfArrayAfterRemovingSomeElements.py ├── MergeSortedArray ├── MerSortArr.js └── MerSortArr.py ├── MergeTwoSortedLists ├── Merge.js └── Merge.py ├── MinimumAbsoluteDifference └── MinimumAbsoluteDifference.py ├── MinimumDepthOfBinaryTree └── MinimumDepthOfBinaryTree.py ├── MinimumDifferenceBetweenHighestAndLowest0fKScores └── MinimumDifferenceBetweenHighestAndLowestOfKScores.py ├── MinimumIndexSumOfTwoLists ├── MinIndSumOfTwoLists.js └── MinIndSumOfTwoLists.py ├── MinimumNumberOfRefuelingStops └── MinimumNumberOfRefuelingStops.py ├── MinimumOperationsToMakeArrayEqual └── MinimumOperationsToMakeArrayEqual.py ├── MinimumSubsequenceInNon-IncreasingOrder └── MinimumSubsequenceInNon-IncreasingOrder.py ├── MirrorReflection └── MirrorReflection.py ├── MissingNumber ├── MissNum.js └── MissNum.py ├── MostCommonWord └── MostCommonWord.py ├── MoveZeroes ├── MoveZeroes.js └── MoveZeroes.py ├── MyCalendarI └── MyCalendarI.py ├── N-RepeatedElementInSize2NArray └── N-RepeatedElementInSize2NArray.py ├── NextGreaterElementI ├── NextGreatEl.js └── NextGreatEl.py ├── NimGame └── NimGame.py ├── NotBoringMovies └── NotBoringMovies.sql ├── NumberOfCommonFactors └── NumberOfCommonFactors.py ├── NumberOfGoodPairs └── NumberOfGoodPairs.py ├── NumberOfIslands └── NumberOfIslands.py ├── NumberOfLinesToWriteString └── NumberOfLinesToWriteString.py ├── NumberOfSegmentsInString ├── NumOfSegInStr.py └── NumOfSenInStr.js ├── OnlineStockSpan └── OnlineStockSpan.py ├── PacificAtlanticWaterFlow └── PacificAtlanticWaterFlow.py ├── PalindromeLinkedList └── PalindromeLinkedList.py ├── PalindromeNumber ├── Palindrome.js └── Palindrome.py ├── PartitioningIntoMinimumNumberOfDeci-BinaryNumbers └── PartitioningIntoMinimumNumberOfDeci-BinaryNumbers.py ├── PascalsTriangle ├── PasTri.js └── PasTri.py ├── PascalsTriangleII(2) ├── PasTriTwo.js └── PasTriTwo.py ├── PathSum └── PathSum.py ├── Permutations └── Permutations.py ├── PermutationsII └── PermutationsII.py ├── PlusOne ├── plusOne.js └── plusOne.py ├── PoorPigs └── PoorPigs.py ├── PowerOfFour └── PowerOfFour.py ├── PowerOfThree └── PowerOfThree.py ├── README.md ├── RangeAdditionII ├── RangeAddition.js └── RangeAdditionII.py ├── RangeSumQuery ├── RanSumQue.js └── RanSumQue.py ├── RankTransformOfAnArray └── RankTransformOfAnArray.py ├── RansomNote ├── RansomNote.js └── RansomNote.py ├── RearrangeArrayElementsBySign └── RearrangeArrayElementsBySign.py ├── RecyclableAndLowFatProducts └── RecyclableAndLowFatProducts.sql ├── ReduceArraySizeToTheHalf └── ReduceArraySizeToTheHalf.py ├── RelativeRanks ├── RelativeRanks.js └── RelativeRanks.py ├── RelativeSortArray └── RelativeSortArray.py ├── RemoveDublicates ├── RemDub.js └── RemDub.py ├── RemoveDublicatesFromSortedList ├── RemDubSortList.js └── RemDubSortList.py ├── RemoveDuplicatesFromSortedArrayII └── RemoveDuplicatesFromSortedArrayII.py ├── RemoveElement ├── RemoveElement.js └── RemoveElement.py ├── ReorderedPowerOf2 └── ReorderedPowerOf2.py ├── RepeatedSubstringPattern ├── RepeatedSubstringPattern.js └── RepeatedSubstringPattern.py ├── ReserveStringII └── ReserveStringII.py ├── ReshapeTheMatrix ├── ReshTheMat.js └── ReshTheMat.py ├── ReverseLinkedList ├── ReverseLinkedList.js └── ReverseLinkedList.py ├── ReverseString ├── ReverseString.js └── ReverseString.py ├── ReverseVowelsOfaString ├── ReverseVowels.js └── ReverseVowels.py ├── ReverseWordsInString └── ReverseWordsInString.py ├── ReverseWordsInStringIII └── ReverseWordsInStringIII.py ├── RisingTemperature └── RisingTemperature.sql ├── RobotReturnToOrigin └── RobotReturnToOrigin.py ├── RomanToInteger ├── RomToInt.js └── RomToInt.py ├── RotateImage └── RotateImage.py ├── RotateString └── RotateString.py ├── RunningSumOf1dArray └── RunningSumOf1dArray.py ├── SalesAnalysisIII └── SalesAnalysisIII.sql ├── SalesPerson └── SalesPerson.sql ├── SameTree ├── SameTree.js └── SameTree.py ├── SearchInsertPosition ├── Search.js └── Search.py ├── SetMismatch ├── SetMismatch.js └── SetMismatch.py ├── ShortestCompletingWord └── ShortestCompletingWord.py ├── ShortestDistanceToCharacter └── ShortestDistanceToCharacter.py ├── ShuffleString └── ShuffleString.py ├── ShuffleTheArray └── ShuffleTheArray.py ├── SingleNumber ├── SingleNum.js └── SingleNum.py ├── SmallestEvenMultiple └── SmallestEvenMultiple.py ├── SortArrayByIncreasingFrequency └── SortArrayByIncreasingFrequency.py ├── SortArrayByParity └── SortArrayByParity.py ├── SortArrayByParityII └── SortArrayByParityII.py ├── SortColors └── SortColors.py ├── SortIntegersByTheNumberOf1Bits └── SortIntegersByTheNumberOf1Bits.py ├── SortTheMatrixDiagonally └── SortTheMatrixDiagonally.py ├── SortingTheSentence └── SortingTheSentence.py ├── SpecialArrayWithXElementsGreaterThanOrEqualX └── SpecialArrayWithXElementsGreaterThanOrEqualX.py ├── SplitArrayIntoConsecutiveSubsequences └── SplitArrayIntoConsecutiveSubsequences.py ├── Sqrt ├── Sqrt.js └── Sqrt.py ├── SquaresOfSortedArray └── SquaresOfSortedArray.py ├── StampingTheSequence └── StampingTheSequence.py ├── StrictlyPalindromicNumber └── StrictlyPalindromicNumber.py ├── StudentAttendanceRecordI └── StudAttenRecI.py ├── SubrectangleQueries └── SubrectangleQueries.py ├── Subsets └── Subsets.py ├── SubstringWithConcatenationOfAllWords └── SubstringWithConcatenationOfAllWords.py ├── SummaryRanges ├── SumRanges.js └── SumRanges.py ├── SwapNodesInPairs └── SwapNodesInPairs.py ├── SwapSalary └── SwapSalary.sql ├── SymmetricTree ├── SymTree.js └── SymTree.py ├── TeemoAttacking ├── TeemoAttacking.js └── TeemoAttacking.py ├── TheKWeakestRowsInMatrix └── TheKWeakestRowsInMatrix.py ├── ThirdMaximumNumber ├── ThirdMaxNum.js └── ThirdMaxNum.py ├── ToLowerCase └── ToLowerCase.py ├── TopKFrequentWords └── TopKFrequentWords.py ├── TwoSum ├── TwoSum.js └── TwoSum.py ├── TwoSumIV-InputIsBST └── TwoSumIV-InputIsBST.py ├── UglyNumber └── UglyNumber.py ├── UncommonWordsFromTwoSentences └── UncommonWordsFromTwoSentences.py ├── UniqueEmailAddresses └── UniqueEmailAddresses.py ├── UniqueMorseCodeWords └── UniqueMorseCodeWords.py ├── UniquePaths └── UniquePaths.py ├── UserActivityForThePast30DaysI └── UserActivityForThePast30DaysI.sql ├── Valid Parentheses ├── Valid.js └── Valid.py ├── ValidAnagram ├── ValidAnagram.js └── ValidAnagram.py ├── ValidPalindrome ├── ValidPalindrome.js └── ValidPalindrome.py ├── ValidPalindromeII └── ValidPalindromeII.py ├── ValidPhoneNumbers └── ValidPhoneNumbers.bash ├── ValidateBinarySearchTree └── ValidateBinarySearchTree.py ├── VerifyingAnAlienDictionary └── VerifyingAnAlienDictionary.py ├── WordLadderII └── WordLadderII.py ├── WordPattern ├── WordPattern.js └── WordPattern.py └── XOfKindInDeckOfCards └── XOfKindInDeckOfCards.py /0002-add-two-numbers/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0003-longest-substring-without-repeating-characters/0003-longest-substring-without-repeating-characters.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def lengthOfLongestSubstring(self, s: str) -> int: 3 | output = 0 4 | count = {} 5 | pos = -1 6 | for index, letter in enumerate(s): 7 | if letter in count and count[letter] > pos: 8 | pos = count[letter] 9 | count[letter] = index 10 | output = max(output,index-pos) 11 | return output -------------------------------------------------------------------------------- /0003-longest-substring-without-repeating-characters/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0005-longest-palindromic-substring/0005-longest-palindromic-substring.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def longestPalindrome(self, s: str) -> str: 3 | size=len(s) 4 | while(size>0): 5 | for i in range(len(s)-size+1): 6 | x=s[i:i+size] 7 | if x==x[::-1]: 8 | return x 9 | size-=1 -------------------------------------------------------------------------------- /0005-longest-palindromic-substring/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0006-zigzag-conversion/0006-zigzag-conversion.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def convert(self, s: str, numRows: int) -> str: 3 | if numRows == 1: 4 | return s 5 | curr = (2 * numRows) - 2 6 | res = "" 7 | for i in range(numRows): 8 | j = 0 9 | while i + j < len(s): 10 | res += s[j + i] 11 | sec = (j - i) + curr 12 | if i != 0 and i != numRows - 1 and sec < len(s): 13 | res += s[sec] 14 | j += curr 15 | return res -------------------------------------------------------------------------------- /0006-zigzag-conversion/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0007-reverse-integer/0007-reverse-integer.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverse(self, x: int) -> int: 3 | x = str(x) 4 | 5 | if x[0] == "-": 6 | sign = -1 7 | else: 8 | sign = 1 9 | 10 | x = x.lstrip("-") 11 | x = x.lstrip("+") 12 | 13 | x = x[::-1] 14 | 15 | int_x = int(x) * sign 16 | 17 | if int_x > 2**31-1: 18 | return 0 19 | elif int_x < -2**31: 20 | return 0 21 | else: 22 | return int_x 23 | 24 | -------------------------------------------------------------------------------- /0007-reverse-integer/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0008-string-to-integer-atoi/0008-string-to-integer-atoi.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def myAtoi(self, s: str) -> int: 3 | s = s.strip() 4 | sign = 1 5 | if len(s)==0: return 0 6 | 7 | if s[0] == "-" or s[0] == "+": 8 | sign = -1 if s[0]=="-" else 1 9 | s = s[1:len(s)] 10 | 11 | 12 | num = 0; 13 | for c in s: 14 | char = ord(c)-48 15 | if char in range(0,10): 16 | num*=10 17 | num+=char 18 | else: 19 | break 20 | if num*sign >= 2147483647: 21 | return 2147483647 22 | if num*sign < -2147483647: 23 | return -2147483648 24 | return sign*num 25 | -------------------------------------------------------------------------------- /0008-string-to-integer-atoi/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0033-search-in-rotated-sorted-array/0033-search-in-rotated-sorted-array.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def search(self, nums: List[int], target: int) -> int: 3 | left = 0 4 | right = len(nums) - 1 5 | 6 | while left <= right: 7 | mid = (left + right) >> 1 8 | if nums[mid] == target: 9 | return mid 10 | elif nums[mid] >= nums[left]: 11 | if (target >= nums[left] and target < nums[mid]): 12 | right = mid - 1 13 | else: 14 | left = mid + 1 15 | else: 16 | if (target <= nums[right] and target > nums[mid]): 17 | left = mid + 1 18 | else: 19 | right = mid - 1 20 | 21 | return -1 -------------------------------------------------------------------------------- /0041-first-missing-positive/0041-first-missing-positive.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def firstMissingPositive(self, nums: List[int]) -> int: 3 | nums = sorted(list(set(nums))) 4 | count = 1 5 | for i in nums: 6 | if i == count: 7 | count += 1 8 | elif i > 0: 9 | return count 10 | return count -------------------------------------------------------------------------------- /0041-first-missing-positive/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0043-multiply-strings/0043-multiply-strings.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def multiply(self, num1: str, num2: str) -> str: 3 | dic = {} 4 | for i in range(10): 5 | dic[str(i)] = i 6 | 7 | a = 0 8 | deci_pos = 1 9 | for i in range(len(num1)-1,-1,-1): 10 | a += dic[num1[i]]*deci_pos 11 | deci_pos *= 10 12 | 13 | b = 0 14 | deci_pos = 1 15 | for i in range(len(num2)-1,-1,-1): 16 | b += dic[num2[i]]*deci_pos 17 | deci_pos *= 10 18 | 19 | return str(a*b) 20 | 21 | 22 | 23 | # sum_ = int(num1) * int(num2) 24 | # return str(sum_) -------------------------------------------------------------------------------- /0043-multiply-strings/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0049-group-anagrams/0049-group-anagrams.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def groupAnagrams(self, strs: List[str]) -> List[List[str]]: 3 | table = {} 4 | for i in strs: 5 | ele = "".join(sorted(list(i))) 6 | if ele not in table: 7 | table[ele] = [] 8 | table[ele].append(i) 9 | return list(table.values()) -------------------------------------------------------------------------------- /0055-jump-game/0055-jump-game.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def canJump(self, nums: List[int]) -> bool: 3 | max_ = 0 4 | for i, j in enumerate(nums): 5 | if i > max_: 6 | return False 7 | max_ = max(max_, i + j) 8 | return True -------------------------------------------------------------------------------- /0055-jump-game/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0056-merge-intervals/0056-merge-intervals.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def merge(self, intervals: List[List[int]]) -> List[List[int]]: 3 | arr = [] 4 | intervals.sort() 5 | for i in intervals: 6 | if not arr or arr[-1][1] < i[0]: 7 | arr.append(i) 8 | else: 9 | arr[-1][1] = max(arr[-1][1], i[1]) 10 | return arr -------------------------------------------------------------------------------- /0056-merge-intervals/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0061-rotate-list/0061-rotate-list.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, val=0, next=None): 4 | # self.val = val 5 | # self.next = next 6 | class Solution: 7 | def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]: 8 | if not head: return head 9 | 10 | cur = head 11 | length = 1 12 | while cur.next: 13 | cur = cur.next 14 | length += 1 15 | cur.next = head 16 | 17 | k = length - (k % length) 18 | while k > 0: 19 | cur=cur.next 20 | k -= 1 21 | 22 | newhead = cur.next 23 | cur.next = None 24 | return newhead -------------------------------------------------------------------------------- /0061-rotate-list/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0066-plus-one/0066-plus-one.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | class Solution { 9 | public: 10 | vector plusOne(vector& digits) { 11 | int n = digits.size(); 12 | for (int i = n - 1; i >= 0; i--) { 13 | if (digits[i] == 9) { 14 | digits[i] = 0; 15 | } else { 16 | digits[i] += 1; 17 | return digits; 18 | } 19 | } 20 | digits.push_back(0); 21 | digits[0] = 1; 22 | return digits; 23 | } 24 | }; -------------------------------------------------------------------------------- /0066-plus-one/0066-plus-one.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int[] plusOne(int[] digits) { 3 | for (int i = digits.length - 1; i >= 0; i--) { 4 | if (++digits[i] > 9) { 5 | digits[i] = 0; 6 | } else { 7 | return digits; 8 | } 9 | } 10 | int[] res = new int[digits.length + 1]; 11 | res[0] = 1; 12 | return res; 13 | } 14 | } -------------------------------------------------------------------------------- /0066-plus-one/0066-plus-one.scala: -------------------------------------------------------------------------------- 1 | object Solution { 2 | def plusOne(digits: Array[Int]): Array[Int] = { 3 | for (i <- digits.length - 1 to 0 by -1) { 4 | if (digits(i) < 9) { 5 | digits(i) += 1 6 | return digits 7 | } 8 | digits(i) = 0 9 | } 10 | 1 +: digits 11 | } 12 | } -------------------------------------------------------------------------------- /0066-plus-one/0066-plus-one.swift: -------------------------------------------------------------------------------- 1 | class Solution { 2 | func plusOne(_ digits: [Int]) -> [Int] { 3 | var result = digits 4 | var i = digits.count - 1 5 | result[i] += 1 6 | while result[i] > 9 { 7 | if i == 0 { 8 | result.insert(1, at: 0) 9 | i += 1 10 | } else { 11 | result[i - 1] += 1 12 | } 13 | result[i] = 0 14 | i -= 1 15 | } 16 | return result; 17 | } 18 | } -------------------------------------------------------------------------------- /0066-plus-one/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0070-climbing-stairs/0070-climbing-stairs.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def climbStairs(self, n: int) -> int: 3 | if n<=2: return n 4 | dp = [0]*(n+1) 5 | dp[1] = 1 6 | dp[2] = 2 7 | for i in range(3,n+1): 8 | dp[i] = dp[i-1]+dp[i-2] 9 | return dp[n] -------------------------------------------------------------------------------- /0070-climbing-stairs/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0079-word-search/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0086-partition-list/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0124-binary-tree-maximum-path-sum/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0148-sort-list/0148-sort-list.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, val=0, next=None): 4 | # self.val = val 5 | # self.next = next 6 | class Solution: 7 | def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]: 8 | if head is None: return head 9 | arr = [] 10 | 11 | while head: 12 | arr.append(head.val) 13 | head = head.next 14 | 15 | arr.sort() 16 | dummy=curr=ListNode(0) 17 | 18 | for i in arr: 19 | temp=ListNode(i) 20 | curr.next=temp 21 | curr=curr.next 22 | return dummy.next -------------------------------------------------------------------------------- /0148-sort-list/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0150-evaluate-reverse-polish-notation/0150-evaluate-reverse-polish-notation.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def evalRPN(self, tokens: List[str]) -> int: 3 | stack = [] 4 | oper = "+-*/" 5 | for i in tokens: 6 | if i in oper: 7 | two, one = stack.pop(), stack.pop() 8 | if i == "+": 9 | stack.append(one + two) 10 | elif i == "/": 11 | stack.append(int(one / two)) 12 | elif i == "*": 13 | stack.append(int(one * two)) 14 | else: 15 | stack.append(one - two) 16 | else: 17 | stack.append(int(i)) 18 | return stack.pop() -------------------------------------------------------------------------------- /0150-evaluate-reverse-polish-notation/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0167-two-sum-ii-input-array-is-sorted/0167-two-sum-ii-input-array-is-sorted.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def twoSum(self, numbers: List[int], target: int) -> List[int]: 3 | n = len(numbers) 4 | for i in range(n): 5 | left, right = i + 1, n - 1 6 | while left < right: 7 | mid = (left + right) // 2 8 | if numbers[i] + numbers[mid] >= target: 9 | right = mid 10 | else: 11 | left = mid + 1 12 | if numbers[left] + numbers[i] == target: 13 | return [i + 1, left + 1] 14 | -------------------------------------------------------------------------------- /0167-two-sum-ii-input-array-is-sorted/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0198-house-robber/0198-house-robber.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def rob(self, nums: List[int]) -> int: 3 | rob1, rob2 = 0, 0 4 | for n in nums: 5 | temp = max(n + rob1, rob2) 6 | rob1 = rob2 7 | rob2 = temp 8 | return rob2 -------------------------------------------------------------------------------- /0198-house-robber/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0222-count-complete-tree-nodes/0222-count-complete-tree-nodes.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def countNodes(self, root: Optional[TreeNode]) -> int: 9 | def pre(node): 10 | if node == None: return 0 11 | return pre(node.left) + pre(node.right) + 1 12 | return pre(root) 13 | -------------------------------------------------------------------------------- /0222-count-complete-tree-nodes/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0232-implement-queue-using-stacks/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0263-ugly-number/0263-ugly-number.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isUgly(self, n: int) -> bool: 3 | if n <= 0: return False 4 | for i in [2, 3, 5]: 5 | while n % i == 0: 6 | n = n // i 7 | return n == 1 -------------------------------------------------------------------------------- /0263-ugly-number/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0279-perfect-squares/0279-perfect-squares.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numSquares(self, n: int) -> int: 3 | squares = [x**2 for x in range(0, n) if x**2<=n] 4 | sqs = [n]*(n+1) 5 | sqs[0] = 0 6 | for i in range(1, n+1): 7 | for sq in squares: 8 | if i - sq < 0: 9 | break 10 | if 1 + sqs[i-sq] < sqs[i]: 11 | sqs[i] = 1 + sqs[i-sq] 12 | return sqs[n] -------------------------------------------------------------------------------- /0279-perfect-squares/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0295-find-median-from-data-stream/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0309-best-time-to-buy-and-sell-stock-with-cooldown/0309-best-time-to-buy-and-sell-stock-with-cooldown.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxProfit(self, prices: List[int]) -> int: 3 | n = len(prices) 4 | b = [0] * n 5 | s = [0] * n 6 | b[0] = -prices[0] 7 | for i in range(1, n): 8 | b[i] = max(b[i - 1], s[i - 2] - prices[i]) 9 | s[i] = max(s[i - 1], b[i - 1] + prices[i]) 10 | return s[-1] -------------------------------------------------------------------------------- /0309-best-time-to-buy-and-sell-stock-with-cooldown/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0328-odd-even-linked-list/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0374-guess-number-higher-or-lower/0374-guess-number-higher-or-lower.py: -------------------------------------------------------------------------------- 1 | # The guess API is already defined for you. 2 | # @param num, your guess 3 | # @return -1 if num is higher than the picked number 4 | # 1 if num is lower than the picked number 5 | # otherwise return 0 6 | # def guess(num: int) -> int: 7 | 8 | class Solution: 9 | def guessNumber(self, n: int) -> int: 10 | left, right = 1, n 11 | while left <= right: 12 | mid = (left + right) // 2 13 | if (guess(mid) == 1): left = mid + 1 14 | elif guess(mid) == -1: right = mid 15 | else: return mid -------------------------------------------------------------------------------- /0374-guess-number-higher-or-lower/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0380-insert-delete-getrandom-o1/0380-insert-delete-getrandom-o1.py: -------------------------------------------------------------------------------- 1 | class RandomizedSet: 2 | 3 | def __init__(self): 4 | self.sets = set() 5 | 6 | 7 | def insert(self, val: int) -> bool: 8 | if val in self.sets: return False 9 | self.sets.add(val) 10 | return True 11 | 12 | 13 | def remove(self, val: int) -> bool: 14 | if val in self.sets: 15 | self.sets.remove(val) 16 | return True 17 | return False 18 | 19 | def getRandom(self) -> int: 20 | return random.choice(list(self.sets)) 21 | 22 | 23 | 24 | # Your RandomizedSet object will be instantiated and called as such: 25 | # obj = RandomizedSet() 26 | # param_1 = obj.insert(val) 27 | # param_2 = obj.remove(val) 28 | # param_3 = obj.getRandom() -------------------------------------------------------------------------------- /0380-insert-delete-getrandom-o1/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0441-arranging-coins/0441-arranging-coins.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def arrangeCoins(self, n: int) -> int: 3 | left = 1 4 | right = n 5 | while left <= right: 6 | mid = (left + right) // 2 7 | if mid * (mid + 1) == 2 * n: 8 | return mid 9 | elif mid * (mid + 1) > 2 * n: 10 | right = mid - 1 11 | else: 12 | left = mid + 1 13 | return right -------------------------------------------------------------------------------- /0451-sort-characters-by-frequency/0451-sort-characters-by-frequency.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def frequencySort(self, s: str) -> str: 3 | count = Counter(s) 4 | sorted_count = sorted(count.items(), key=lambda x:x[1], reverse=True) 5 | res = "" 6 | for i in sorted_count: 7 | res += i[0] * i[1] 8 | return res -------------------------------------------------------------------------------- /0451-sort-characters-by-frequency/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0507-perfect-number/0507-perfect-number.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def checkPerfectNumber(self, num: int) -> bool: 3 | sums = 0 4 | if num == 1: 5 | return False 6 | 7 | for i in range(1, floor(num**0.5)+1): 8 | if num%i == 0: 9 | sums += i + num//i 10 | 11 | if sums == 2 * num: 12 | return True 13 | 14 | return False -------------------------------------------------------------------------------- /0507-perfect-number/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0520-detect-capital/0520-detect-capital.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def detectCapitalUse(self, word: str) -> bool: 3 | if word.isupper(): return True 4 | if word.islower(): return True 5 | if word[0].isupper() and word[1:].islower(): return True 6 | return False -------------------------------------------------------------------------------- /0520-detect-capital/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0646-maximum-length-of-pair-chain/0646-maximum-length-of-pair-chain.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findLongestChain(self, pairs: List[List[int]]) -> int: 3 | pairs = sorted(pairs, key=lambda x: x[1]) 4 | count = 1 5 | prev_elem = pairs[0] 6 | 7 | for i in range(1, len(pairs)): 8 | if pairs[i][0] > prev_elem[1]: 9 | count += 1 10 | prev_elem = pairs[i] 11 | 12 | return count -------------------------------------------------------------------------------- /0646-maximum-length-of-pair-chain/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0728-self-dividing-numbers/0728-self-dividing-numbers.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def selfDividingNumbers(self, left: int, right: int) -> List[int]: 3 | res = [] 4 | for i in range(left, right + 1): 5 | s = str(i) 6 | if "0" in s: 7 | continue 8 | d = 1 9 | for j in range(len(s)): 10 | if i % int(s[j]) != 0: 11 | d = 0 12 | break 13 | if d == 1: 14 | res.append(i) 15 | return res -------------------------------------------------------------------------------- /0739-daily-temperatures/0739-daily-temperatures.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def dailyTemperatures(self, temperatures: List[int]) -> List[int]: 3 | res = [0]*len(temperatures) 4 | stack = [] # pair : [temp, index] 5 | for i, t in enumerate(temperatures): 6 | while stack and t > stack[-1][0]: 7 | stackTemp, stackInd = stack.pop() 8 | res[stackInd] = (i - stackInd) 9 | stack.append((t, i)) 10 | return res -------------------------------------------------------------------------------- /0739-daily-temperatures/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0790-domino-and-tromino-tiling/0790-domino-and-tromino-tiling.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numTilings(self, n: int) -> int: 3 | if n == 1: return 1 4 | if n == 2: return 2 5 | if n == 3: return 5 6 | if n == 4: return 11 7 | if n == 5: return 24 8 | a,b,c = 5,11,24 #[a,b,c] => [b,c,a+c+c] => [b,c]+[2*c+a] 9 | for i in range(6,n+1): 10 | a,b,c = b,c,2*c+a 11 | return c % (10**9+7) -------------------------------------------------------------------------------- /0797-all-paths-from-source-to-target/0797-all-paths-from-source-to-target.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def allPathsSourceTarget(self, graph: List[List[int]]) -> List[List[int]]: 3 | res = [] 4 | stack = [(0,)] 5 | while stack: 6 | cur_path = stack.pop() 7 | cur = cur_path[-1] 8 | if cur == len(graph) - 1: 9 | res.append(cur_path) 10 | for nei in graph[cur]: 11 | stack.append(cur_path + (nei,)) 12 | return res -------------------------------------------------------------------------------- /0841-keys-and-rooms/0841-keys-and-rooms.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def canVisitAllRooms(self, rooms: List[List[int]]) -> bool: 3 | stack = [0] 4 | visited = {0} 5 | while stack: 6 | node = stack.pop() 7 | for k in rooms[node]: 8 | if k not in visited: 9 | visited.add(k) 10 | stack.append(k) 11 | return len(visited) == len(rooms) -------------------------------------------------------------------------------- /0841-keys-and-rooms/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0872-leaf-similar-trees/0872-leaf-similar-trees.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def leafSimilar(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool: 9 | def helper(node,leaf): 10 | 11 | if node: 12 | if not node.left and not node.right: 13 | leaf.append(node.val) 14 | helper(node.left,leaf) 15 | helper(node.right,leaf) 16 | return leaf 17 | 18 | return helper(root1,[]) == helper(root2,[]) -------------------------------------------------------------------------------- /0872-leaf-similar-trees/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0876-middle-of-the-linked-list/0876-middle-of-the-linked-list.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, val=0, next=None): 4 | # self.val = val 5 | # self.next = next 6 | class Solution: 7 | def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]: 8 | if head is None: return [] 9 | one = two = head 10 | while two and two.next: 11 | one = one.next 12 | two = two.next.next 13 | return one 14 | -------------------------------------------------------------------------------- /0876-middle-of-the-linked-list/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0931-minimum-falling-path-sum/0931-minimum-falling-path-sum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minFallingPathSum(self, matrix: List[List[int]]) -> int: 3 | l=len(matrix) 4 | # Iterating from 2nd row of matrix and creating matrix of minimum sum upto that point. 5 | for i in range(1,l): 6 | # For every cell, adding the minimum of three values above it. 7 | matrix[i][0]+=min(matrix[i-1][0:2]) 8 | for j in range(1,l): 9 | matrix[i][j]+=min(matrix[i-1][j-1:j+2]) 10 | # Returning minimum of last step. 11 | return min(matrix[l-1]) -------------------------------------------------------------------------------- /0931-minimum-falling-path-sum/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0938-range-sum-of-bst/0938-range-sum-of-bst.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def rangeSumBST(self, root: Optional[TreeNode], low: int, high: int) -> int: 9 | if not root: return 0 10 | if root.val < low: 11 | return self.rangeSumBST(root.right, low,high) 12 | if root.val > high: 13 | return self.rangeSumBST(root.left, low,high) 14 | else: 15 | return root.val + self.rangeSumBST(root.right,low,high) + self.rangeSumBST(root.left,low,high) -------------------------------------------------------------------------------- /0938-range-sum-of-bst/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /0980-unique-paths-iii/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1025-divisor-game/1025-divisor-game.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def divisorGame(self, n: int) -> bool: 3 | return n % 2 == 0 -------------------------------------------------------------------------------- /1025-divisor-game/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1026-maximum-difference-between-node-and-ancestor/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1114-print-in-order/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1143-longest-common-subsequence/1143-longest-common-subsequence.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def longestCommonSubsequence(self, text1: str, text2: str) -> int: 3 | n,m = len(text1),len(text2) 4 | dp = [0] * (m + 1) 5 | for i in range(1,n+1): 6 | for j in range(m,0,-1): 7 | if text1[i-1] == text2[j-1]: 8 | dp[j] = dp[j-1] + 1 9 | for j in range(1,m+1): 10 | dp[j] = max(dp[j],dp[j-1]) 11 | return dp[m] -------------------------------------------------------------------------------- /1143-longest-common-subsequence/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1207-unique-number-of-occurrences/1207-unique-number-of-occurrences.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def uniqueOccurrences(self, arr: List[int]) -> bool: 3 | dict_ = dict() 4 | for i in arr: 5 | dict_[i] = arr.count(i) 6 | return len(dict_.values()) == len(set(dict_.values())) -------------------------------------------------------------------------------- /1207-unique-number-of-occurrences/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1221-split-a-string-in-balanced-strings/1221-split-a-string-in-balanced-strings.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def balancedStringSplit(self, s: str) -> int: 3 | res = countL = 0 4 | for i in s: 5 | if i == "L": 6 | countL += 1 7 | if i == "R": 8 | countL -= 1 9 | if countL == 0: 10 | res += 1 11 | return res -------------------------------------------------------------------------------- /1221-split-a-string-in-balanced-strings/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1281-subtract-the-product-and-sum-of-digits-of-an-integer/1281-subtract-the-product-and-sum-of-digits-of-an-integer.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def subtractProductAndSum(self, n: int) -> int: 3 | # Присваивать 0 нельзя, так как при умножении на ноль результат будет нулевым. 4 | sum_, mult = 0, 1 5 | while n > 0: 6 | # Найти остаток от деления значения n на 10, то есть извлечь последнюю цифру числа. 7 | digit = n % 10 8 | # Добавить извлеченную цифру к сумме и увеличить на эту цифру произведение. 9 | sum_ = sum_ + digit 10 | mult = mult * digit 11 | # Избавиться от последнего разряда числа n путем деления нацело на 10. 12 | n = n // 10 13 | return mult - sum_ -------------------------------------------------------------------------------- /1281-subtract-the-product-and-sum-of-digits-of-an-integer/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1332-remove-palindromic-subsequences/1332-remove-palindromic-subsequences.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def removePalindromeSub(self, s: str) -> int: 3 | return 1 if s == s[::-1] else 2 -------------------------------------------------------------------------------- /1332-remove-palindromic-subsequences/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1339-maximum-product-of-splitted-binary-tree/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1342-number-of-steps-to-reduce-a-number-to-zero/1342-number-of-steps-to-reduce-a-number-to-zero.java: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public int numberOfSteps(int num) { 3 | int counter = 0; 4 | while (num > 0) { 5 | if (num % 2 == 0) { 6 | num /= 2; 7 | counter++; 8 | } else { num --; counter++;} 9 | } 10 | return counter; 11 | } 12 | } -------------------------------------------------------------------------------- /1342-number-of-steps-to-reduce-a-number-to-zero/1342-number-of-steps-to-reduce-a-number-to-zero.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} num 3 | * @return {number} 4 | */ 5 | var numberOfSteps = function(num) { 6 | let counter = 0 7 | while (num > 0) { 8 | if (num % 2 == 0) { 9 | num /= 2 10 | counter += 1 11 | } else { 12 | num-- 13 | counter += 1 14 | } 15 | } 16 | return counter 17 | }; -------------------------------------------------------------------------------- /1342-number-of-steps-to-reduce-a-number-to-zero/1342-number-of-steps-to-reduce-a-number-to-zero.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numberOfSteps(self, num: int) -> int: 3 | counter = 0 4 | while num > 0: 5 | if num % 2 == 0: 6 | num /= 2 7 | counter += 1 8 | else: 9 | num -= 1 10 | counter += 1 11 | return counter -------------------------------------------------------------------------------- /1342-number-of-steps-to-reduce-a-number-to-zero/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1393-capital-gain-loss/1393-capital-gain-loss.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | select stock_name, 4 | sell_total-buy_total as capital_gain_loss 5 | from 6 | （ 7 | select stock_name 8 | ,sum(case when upper(operation)='BUY' then price else 0 end) buy_total 9 | ,sum(case when upper(operation)='SELL' then price else 0 end) 10 | sell_total 11 | from Stocks 12 | GROUP BY stock_name 13 | ）; -------------------------------------------------------------------------------- /1393-capital-gain-loss/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1408-string-matching-in-an-array/1408-string-matching-in-an-array.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def stringMatching(self, words: List[str]) -> List[str]: 3 | res = [] 4 | for word in range(len(words)): 5 | for i in range(word, len(words)): 6 | if words[i] == words[word]: 7 | continue 8 | else: 9 | if words[word] in words[i]: 10 | res.append(words[word]) 11 | elif words[i] in words[word]: 12 | res.append(words[i]) 13 | else: 14 | continue 15 | return set(res) -------------------------------------------------------------------------------- /1431-kids-with-the-greatest-number-of-candies/1431-kids-with-the-greatest-number-of-candies.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]: 3 | max_, res = max(candies), [] 4 | for i in candies: 5 | if i + extraCandies >= max_: 6 | res.append(True) 7 | else: 8 | res.append(False) 9 | return res -------------------------------------------------------------------------------- /1431-kids-with-the-greatest-number-of-candies/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1491-average-salary-excluding-the-minimum-and-maximum-salary/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1657-determine-if-two-strings-are-close/1657-determine-if-two-strings-are-close.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def closeStrings(self, word1: str, word2: str) -> bool: 3 | if sorted(Counter(word1).values()) == sorted(Counter(word2).values()) and set(word1) == set(word2): return True 4 | return False -------------------------------------------------------------------------------- /1657-determine-if-two-strings-are-close/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1662-check-if-two-string-arrays-are-equivalent/1662-check-if-two-string-arrays-are-equivalent.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def arrayStringsAreEqual(self, word1: List[str], word2: List[str]) -> bool: 3 | if "".join(word1) == "".join(word2): return True 4 | return False -------------------------------------------------------------------------------- /1662-check-if-two-string-arrays-are-equivalent/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1672-richest-customer-wealth/1672-richest-customer-wealth.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maximumWealth(self, accounts: List[List[int]]) -> int: 3 | maxtotal = 0 4 | for i in range(len(accounts)): 5 | acc = sum(accounts[i]) 6 | maxtotal = max(maxtotal, acc) 7 | return maxtotal -------------------------------------------------------------------------------- /1672-richest-customer-wealth/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1678-goal-parser-interpretation/1678-goal-parser-interpretation.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def interpret(self, command: str) -> str: 3 | return command.replace("()", "o").replace("(al)", "al") -------------------------------------------------------------------------------- /1678-goal-parser-interpretation/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1688-count-of-matches-in-tournament/1688-count-of-matches-in-tournament.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numberOfMatches(self, n: int) -> int: 3 | return n - 1 -------------------------------------------------------------------------------- /1693-daily-leads-and-partners/1693-daily-leads-and-partners.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT TO_CHAR(date_id,'yyyy-mm-dd') date_id, make_name, 4 | COUNT(DISTINCT lead_id) unique_leads, 5 | COUNT(DISTINCT partner_id)unique_partners FROM DailySales 6 | GROUP BY TO_CHAR(date_id,'yyyy-mm-dd'),make_name -------------------------------------------------------------------------------- /1704-determine-if-string-halves-are-alike/1704-determine-if-string-halves-are-alike.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def halvesAreAlike(self, s: str) -> bool: 3 | vowels = "aeiouAEIOU" 4 | l = len(s) + 1 5 | a, b = s[0:l // 2], s[l // 2:] 6 | countA = sum(i in vowels for i in a) 7 | countB = sum(i in vowels for i in b) 8 | return countA == countB -------------------------------------------------------------------------------- /1704-determine-if-string-halves-are-alike/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1732-find-the-highest-altitude/1732-find-the-highest-altitude.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def largestAltitude(self, gain: List[int]) -> int: 3 | res = [0] 4 | for i in range(len(gain)): 5 | res.append(res[i] + gain[i]) 6 | return max(res) -------------------------------------------------------------------------------- /1732-find-the-highest-altitude/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1741-find-total-time-spent-by-each-employee/1741-find-total-time-spent-by-each-employee.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT 4 | TO_CHAR(event_day, 'YYYY-MM-DD') AS day, 5 | emp_id, 6 | SUM(out_time - in_time) total_time 7 | FROM Employees 8 | GROUP BY event_day, emp_id -------------------------------------------------------------------------------- /1768-merge-strings-alternately/1768-merge-strings-alternately.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def mergeAlternately(self, word1: str, word2: str) -> str: 3 | res = "" 4 | one, two = 0, 0 5 | while one < len(word1) and two < len(word2): 6 | res += word1[one]+word2[two] 7 | one += 1 8 | two += 1 9 | if one == len(word1): res += word2[two:] 10 | else: res += word1[one:] 11 | return res -------------------------------------------------------------------------------- /1768-merge-strings-alternately/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1773-count-items-matching-a-rule/1773-count-items-matching-a-rule.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def countMatches(self, items: List[List[str]], ruleKey: str, ruleValue: str) -> int: 3 | dic = {"type": 0, "color": 1, "name": 2} 4 | count = 0 5 | for item in items: 6 | if item[dic[ruleKey]] == ruleValue: 7 | count += 1 8 | return count -------------------------------------------------------------------------------- /1816-truncate-sentence/1816-truncate-sentence.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def truncateSentence(self, s: str, k: int) -> str: 3 | arr = list(s.split()) 4 | while len(arr) != k: 5 | arr.pop() 6 | return " ".join(arr) -------------------------------------------------------------------------------- /1816-truncate-sentence/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1832-check-if-the-sentence-is-pangram/1832-check-if-the-sentence-is-pangram.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def checkIfPangram(self, sentence: str) -> bool: 3 | return len(set(sentence)) == 26 -------------------------------------------------------------------------------- /1832-check-if-the-sentence-is-pangram/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1834-single-threaded-cpu/1834-single-threaded-cpu.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def getOrder(self, tasks: List[List[int]]) -> List[int]: 3 | for ix in range(len(tasks)): 4 | tasks[ix].append(ix) 5 | tasks = sorted(tasks, key=lambda ix:ix[0]) 6 | 7 | rst = [] 8 | heap = [] 9 | time = tasks[0][0] 10 | ix = 0 11 | 12 | while heap or ix < len(tasks): 13 | while ix < len(tasks) and time >= tasks[ix][0]: 14 | heapq.heappush(heap, [tasks[ix][1], tasks[ix][2]]) 15 | ix += 1 16 | if heap: 17 | t, index = heapq.heappop(heap) 18 | time += t 19 | rst.append(index) 20 | else: 21 | time = tasks[ix][0] 22 | 23 | return rst -------------------------------------------------------------------------------- /1834-single-threaded-cpu/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1877-minimize-maximum-pair-sum-in-array/1877-minimize-maximum-pair-sum-in-array.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minPairSum(self, nums: List[int]) -> int: 3 | nums.sort() 4 | one, max_, two = 0, 0, len(nums) - 1 5 | while one <= two: 6 | max_ = max(max_, nums[one] + nums[two]) 7 | one += 1 8 | two -= 1 9 | return max_ 10 | -------------------------------------------------------------------------------- /1877-minimize-maximum-pair-sum-in-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1926-nearest-exit-from-entrance-in-maze/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1941-check-if-all-characters-have-equal-number-of-occurrences/1941-check-if-all-characters-have-equal-number-of-occurrences.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def areOccurrencesEqual(self, s: str) -> bool: 3 | dic = {} 4 | for i in s: 5 | dic[i] = s.count(i) 6 | d=dic[s[0]] 7 | for i, j in enumerate(dic): 8 | if dic[j] != d: 9 | return False 10 | return True -------------------------------------------------------------------------------- /1941-check-if-all-characters-have-equal-number-of-occurrences/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /1962-remove-stones-to-minimize-the-total/1962-remove-stones-to-minimize-the-total.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minStoneSum(self, piles: List[int], k: int) -> int: 3 | bucket = [0 for _ in range(10001)] 4 | ans = sum(piles) 5 | for i in piles: 6 | bucket[i] += 1 7 | for i in range(10000, -1, -1): 8 | while bucket[i] > 0 and k > 0: 9 | k -= 1 10 | bucket[i] -= 1 11 | temp = i // 2 12 | ans -= temp 13 | bucket[i-temp] += 1 14 | if k == 0: 15 | return ans -------------------------------------------------------------------------------- /1971-find-if-path-exists-in-graph/1971-find-if-path-exists-in-graph.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def validPath(self, n: int, E: List[List[int]], src: int, dst: int) -> bool: 3 | if src == dst : return True 4 | 5 | G = defaultdict(set) 6 | for u,v in E : G[u].add(v), G[v].add(u) 7 | 8 | dq, seen = deque([src]), set({src}) 9 | while dq: 10 | v = dq.popleft() 11 | for u in G[v]: 12 | if u == dst : return True 13 | if u not in seen: 14 | seen.add(u) 15 | dq.append(u) 16 | 17 | return False -------------------------------------------------------------------------------- /1971-find-if-path-exists-in-graph/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2089-find-target-indices-after-sorting-array/2089-find-target-indices-after-sorting-array.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def targetIndices(self, nums: List[int], target: int) -> List[int]: 3 | arr = sorted(nums) 4 | res = [] 5 | for i in range(0, len(arr)): 6 | if arr[i] == target: 7 | res.append(i) 8 | return res -------------------------------------------------------------------------------- /2089-find-target-indices-after-sorting-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2114-maximum-number-of-words-found-in-sentences/2114-maximum-number-of-words-found-in-sentences.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def mostWordsFound(self, sentences: List[str]) -> int: 3 | ans = 0 4 | for i in sentences: 5 | count = i.count(" ") 6 | ans = max(ans, count) 7 | return ans + 1 -------------------------------------------------------------------------------- /2114-maximum-number-of-words-found-in-sentences/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2176-count-equal-and-divisible-pairs-in-an-array/2176-count-equal-and-divisible-pairs-in-an-array.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def countPairs(self, nums: List[int], k: int) -> int: 3 | count = 0 4 | for i in range(len(nums)): 5 | for j in range(i + 1, len(nums)): 6 | if nums[i] == nums[j] and (i * j) % k == 0: 7 | count += 1 8 | return count -------------------------------------------------------------------------------- /2176-count-equal-and-divisible-pairs-in-an-array/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2256-minimum-average-difference/2256-minimum-average-difference.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minimumAverageDifference(self, nums: List[int]) -> int: 3 | cur_min = tot = sum(nums) 4 | n = len(nums) 5 | idx = 0 6 | cur_tot = 0 7 | for i, v in enumerate(nums): 8 | cur_tot += v 9 | a = cur_tot // (i + 1) 10 | b = 0 if i == (n - 1) else (tot - cur_tot) // (n - i - 1) 11 | cur = abs(a - b) 12 | if cur < cur_min: 13 | idx = i 14 | cur_min = cur 15 | return idx -------------------------------------------------------------------------------- /2256-minimum-average-difference/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2259-remove-digit-from-number-to-maximize-result/2259-remove-digit-from-number-to-maximize-result.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def removeDigit(self, number: str, digit: str) -> str: 3 | arr = [] 4 | for i in range(len(number)): 5 | if number[i] == digit: 6 | arr.append(number[:i]+number[i+1:]) 7 | return max(arr) -------------------------------------------------------------------------------- /2259-remove-digit-from-number-to-maximize-result/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2279-maximum-bags-with-full-capacity-of-rocks/2279-maximum-bags-with-full-capacity-of-rocks.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maximumBags(self, capacity: List[int], rocks: List[int], additionalRocks: int) -> int: 3 | remaining = [0] * len(capacity) 4 | res = 0 5 | 6 | for i in range(len(capacity)): 7 | remaining[i] = capacity[i] - rocks[i] 8 | remaining.sort() 9 | 10 | for i in range(len(remaining)): 11 | if remaining[i] > additionalRocks: 12 | break 13 | 14 | additionalRocks -= remaining[i] 15 | res += 1 16 | 17 | return res -------------------------------------------------------------------------------- /2279-maximum-bags-with-full-capacity-of-rocks/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2309-greatest-english-letter-in-upper-and-lower-case/2309-greatest-english-letter-in-upper-and-lower-case.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def greatestLetter(self, s: str) -> str: 3 | s = set(s) 4 | upper, lower = ord("Z"), ord("z") 5 | for i in range(26): 6 | if chr(upper - i) in s and chr(lower - i) in s: 7 | return chr(upper - i) 8 | return "" -------------------------------------------------------------------------------- /2309-greatest-english-letter-in-upper-and-lower-case/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2315-count-asterisks/2315-count-asterisks.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def countAsterisks(self, s: str) -> int: 3 | arr = [] 4 | for i in s: 5 | if "|" not in arr: 6 | arr.append(i) 7 | elif "|" in arr and i == "|": 8 | arr.pop() 9 | return arr.count("*") -------------------------------------------------------------------------------- /2315-count-asterisks/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2363-merge-similar-items/2363-merge-similar-items.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]: 3 | d={} 4 | for i in items1: 5 | d[i[0]]=i[1] 6 | for i in items2: 7 | if i[0] in d.keys(): 8 | d[i[0]]+=i[1] 9 | else: 10 | d[i[0]]=i[1] 11 | l=list(d.keys()) 12 | l.sort() 13 | ans=[] 14 | for i in range(len(l)): 15 | if l[i] in d.keys(): 16 | ans.append([l[i],d[l[i]]]) 17 | return ans -------------------------------------------------------------------------------- /2363-merge-similar-items/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2367-number-of-arithmetic-triplets/2367-number-of-arithmetic-triplets.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def arithmeticTriplets(self, nums: List[int], diff: int) -> int: 3 | counter = 0 4 | hasht = set(nums) 5 | print(hasht) 6 | for i in nums: 7 | if i + diff in hasht and i + 2 * diff in hasht: 8 | counter += 1 9 | return counter -------------------------------------------------------------------------------- /2367-number-of-arithmetic-triplets/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2389-longest-subsequence-with-limited-sum/2389-longest-subsequence-with-limited-sum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def answerQueries(self, nums: List[int], queries: List[int]) -> List[int]: 3 | ans=[] 4 | nums.sort() 5 | for q in queries: 6 | s=0 #sum of subsequence 7 | l=0 #length of subsequence 8 | for i in nums: 9 | if s+i<=q: #check before adding the element. 10 | s=s+i 11 | l=l+1 12 | else: 13 | break 14 | ans.append(l) 15 | return ans -------------------------------------------------------------------------------- /2389-longest-subsequence-with-limited-sum/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2469-convert-the-temperature/2469-convert-the-temperature.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def convertTemperature(self, celsius: float) -> List[float]: 3 | return [celsius + 273.15, celsius * 1.80 + 32.00] -------------------------------------------------------------------------------- /2469-convert-the-temperature/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2506-count-pairs-of-similar-strings/2506-count-pairs-of-similar-strings.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def similarPairs(self, words: List[str]) -> int: 3 | count = 0 4 | for i in range(len(words)): 5 | for j in range(i): 6 | if set(words[i]) == set(words[j]): 7 | count += 1 8 | return count -------------------------------------------------------------------------------- /2506-count-pairs-of-similar-strings/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2574-left-and-right-sum-differences/2574-left-and-right-sum-differences.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def leftRigthDifference(self, nums: List[int]) -> List[int]: 3 | left, right = 0, sum(nums) 4 | for idx, val in enumerate(nums): 5 | left += val 6 | nums[idx] = abs(right - left) 7 | right -= val 8 | return nums 9 | 10 | -------------------------------------------------------------------------------- /2574-left-and-right-sum-differences/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2619-array-prototype-last/2619-array-prototype-last.js: -------------------------------------------------------------------------------- 1 | Array.prototype.last = function() { 2 | return this[this.length - 1] ?? -1 3 | }; 4 | 5 | /** 6 | * const arr = [1, 2, 3]; 7 | * arr.last(); // 3 8 | */ -------------------------------------------------------------------------------- /2619-array-prototype-last/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2620-counter/2620-counter.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {Function} counter 4 | */ 5 | var createCounter = function(n) { 6 | return function() { 7 | return n++ 8 | }; 9 | }; 10 | 11 | /** 12 | * const counter = createCounter(10) 13 | * counter() // 10 14 | * counter() // 11 15 | * counter() // 12 16 | */ -------------------------------------------------------------------------------- /2620-counter/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2621-sleep/2621-sleep.ts: -------------------------------------------------------------------------------- 1 | async function sleep(millis: number): Promise { 2 | return new Promise((resolve)=>{ 3 | setTimeout(resolve,millis); 4 | }); 5 | } 6 | 7 | 8 | /** 9 | * let t = Date.now() 10 | * sleep(100).then(() => console.log(Date.now() - t)) // 100 11 | */ -------------------------------------------------------------------------------- /2621-sleep/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2652-sum-multiples/2652-sum-multiples.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def sumOfMultiples(self, n: int) -> int: 3 | counter = 0 4 | for i in range(3, n + 1): 5 | if i % 3 == 0 or i % 5 == 0 or i % 7 == 0: 6 | counter += i 7 | return counter -------------------------------------------------------------------------------- /2652-sum-multiples/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /2703-return-length-of-arguments-passed/2703-return-length-of-arguments-passed.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @return {number} 3 | */ 4 | var argumentsLength = function(...args) { 5 | return args.length 6 | }; 7 | 8 | /** 9 | * argumentsLength(1, 2, 3); // 3 10 | */ -------------------------------------------------------------------------------- /2703-return-length-of-arguments-passed/NOTES.md: -------------------------------------------------------------------------------- 1 | ​ -------------------------------------------------------------------------------- /3Sum/3Sum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def threeSum(self, nums: List[int]) -> List[List[int]]: 3 | nums.sort() 4 | arr = [] 5 | for i in range(len(nums) - 1): 6 | left = i + 1 7 | right = len(nums) - 1 8 | while left < right: 9 | if nums[i] + nums[left] + nums[right] == 0: 10 | arr.append((nums[i], nums[left], nums[right])) 11 | left += 1 12 | right -= 1 13 | elif nums[i] + nums[left] + nums[right] > 0: 14 | right -= 1 15 | else: 16 | left += 1 17 | return set(arr) 18 | -------------------------------------------------------------------------------- /ActorsAndDirectorsWhoCooperatedAtLeastThreeTimes/ActorsAndDirectorsWhoCooperatedAtLeastThreeTimes.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT actor_id, director_id 4 | FROM ( 5 | SELECT actor_id, director_id, COUNT(1) 6 | FROM ActorDirector 7 | GROUP BY actor_id, director_id 8 | HAVING COUNT(1) >= 3 9 | ) -------------------------------------------------------------------------------- /AddDigits/AddDigits.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def addDigits(self, num: int) -> int: 3 | count = 0 4 | while len(str(num)) > 1: 5 | for i in str(num): 6 | count = count + int(i) 7 | num = count 8 | count = 0 9 | return num -------------------------------------------------------------------------------- /AddStrings/AddStrings.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} num1 3 | * @param {string} num2 4 | * @return {string} 5 | */ 6 | var addStrings = function (num1, num2) { 7 | let i = num1.length - 1; 8 | let j = num2.length - 1; 9 | let carry = 0; 10 | let sum = ""; 11 | for (; i >= 0 || j >= 0 || carry > 0; i--, j--) { 12 | const digit1 = i < 0 ? 0 : num1.charAt(i) - "0"; 13 | const digit2 = j < 0 ? 0 : num2.charAt(j) - "0"; 14 | const digitsSum = digit1 + digit2 + carry; 15 | sum = `${digitsSum % 10}${sum}`; 16 | carry = Math.floor(digitsSum / 10); 17 | } 18 | return sum; 19 | }; 20 | -------------------------------------------------------------------------------- /AddStrings/AddStrings.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def addStrings(self, num1: str, num2: str) -> str: 3 | return str(int(num1) + int(num2)) 4 | 5 | 6 | class Solution: 7 | def addStrings(self, num1: str, num2: str) -> str: 8 | def str_to_int(n): 9 | integer = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9} 10 | num = 0 11 | for i in n: 12 | num = num * 10 + integer[i] 13 | return num 14 | res = str_to_int(num1) + str_to_int(num2) 15 | return str(res) -------------------------------------------------------------------------------- /AddTwoIntegers/AddTwoIntegers.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def sum(self, num1: int, num2: int) -> int: 3 | arr = [] 4 | arr.append(num1) 5 | arr.append(num2) 6 | return sum(arr) 7 | 8 | # return num1 + num2 -------------------------------------------------------------------------------- /ArrayPartition/ArrayPartition.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var arrayPairSum = function (nums) { 6 | nums.sort((a, b) => a - b); 7 | let res = 0; 8 | for (let i = 0; i < nums.length; i += 2) { 9 | res += nums[i]; 10 | } 11 | return res; 12 | }; 13 | -------------------------------------------------------------------------------- /ArrayPartition/ArrayPartition.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def arrayPairSum(self, nums: List[int]) -> int: 3 | nums.sort() 4 | res = 0 5 | for i in range(0, len(nums), 2): 6 | res += nums[i] 7 | return res -------------------------------------------------------------------------------- /AssignCookies/AssignCookies.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findContentChildren(self, g: List[int], s: List[int]) -> int: 3 | g=sorted(g) 4 | s=sorted(s) 5 | count, i, j = 0,0,0 6 | while i < len(s) and j < len(g): 7 | if s[i] >= g[j]: 8 | count+=1 9 | i+=1 10 | j+=1 11 | else: 12 | i+=1 13 | return count 14 | 15 | 16 | class Solution: 17 | def findContentChildren(self, g: List[int], s: List[int]) -> int: 18 | g.sort() 19 | s.sort() 20 | i = 0 21 | for j in range(len(s)): 22 | if i < len(g) and g[i] <= s[j]: 23 | i += 1 24 | return i -------------------------------------------------------------------------------- /AverageSalaryExcludingTheMinimumAndMaximumSalary/AverageSalaryExcludingTheMinimumAndMaximumSalary.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def average(self, salary: List[int]) -> float: 3 | salary.remove(max(salary)) 4 | salary.remove(min(salary)) 5 | return sum(salary) / len(salary) -------------------------------------------------------------------------------- /BalancedBinaryTree/BalBinTree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def isBalanced(self, root: Optional[TreeNode]) -> bool: 9 | def balanced(root): 10 | if root == None: 11 | return True 12 | leftTree = balanced(root.left) 13 | if leftTree == - 1: 14 | return -1 15 | rightTree = balanced(root.right) 16 | if rightTree == - 1: 17 | return -1 18 | if abs(leftTree - rightTree) > 1: 19 | return -1 20 | return max(leftTree, rightTree) + 1 21 | return balanced(root) != -1 -------------------------------------------------------------------------------- /BaseballGame/BaseBallGame.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} ops 3 | * @return {number} 4 | */ 5 | var calPoints = function (ops) { 6 | let stack = []; 7 | ops.forEach((op) => { 8 | if (parseInt(op)) { 9 | stack.push(parseInt(op)); 10 | } else if (op === "+") { 11 | stack.push( 12 | (stack[stack.length - 1] || 0) + (stack[stack.length - 2] || 0) 13 | ); 14 | } else if (op === "D") { 15 | stack.push((stack[stack.length - 1] || 0) * 2); 16 | } else if (op === "C") { 17 | stack.pop(); 18 | } 19 | }); 20 | return stack.reduce((a, b) => a + b, 0); 21 | }; 22 | -------------------------------------------------------------------------------- /BaseballGame/BaseballGame.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def calPoints(self, ops: List[str]) -> int: 3 | stack = [] 4 | count = 0 5 | for i in ops: 6 | if i == "C": 7 | count -= stack.pop() 8 | elif i == "D": 9 | stack.append(stack[-1] * 2) 10 | count += stack[-1] 11 | elif i == "+": 12 | stack.append(stack[-1] + stack[-2]) 13 | count += stack[-1] 14 | else: 15 | stack.append(int(i)) 16 | count += stack[-1] 17 | return count 18 | 19 | 20 | -------------------------------------------------------------------------------- /BestTimeToBuyAndSellStock/BestTime.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} prices 3 | * @return {number} 4 | */ 5 | var maxProfit = function (prices) { 6 | if (prices.length === 0) return 0; 7 | let max_profit = 0; 8 | let min_price = prices[0]; 9 | for (let i = 0; i < prices.length; i++) { 10 | profit = prices[i] - min_price; 11 | max_profit = Math.max(profit, max_profit); 12 | min_price = Math.min(min_price, prices[i]); 13 | } 14 | return max_profit; 15 | }; 16 | -------------------------------------------------------------------------------- /BestTimeToBuyAndSellStock/BestTime.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxProfit(self, prices: List[int]) -> int: 3 | if len(prices) == 0: return 0 4 | max_profit = 0 5 | min_price = prices[0] 6 | for i in range(len(prices)): 7 | profit = prices[i] - min_price 8 | max_profit = max(profit, max_profit) 9 | min_price = min(min_price, prices[i]) 10 | return max_profit -------------------------------------------------------------------------------- /BigCountries/BigCountries.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT name, population, area 4 | FROM World 5 | WHERE population >= 25000000 OR area >= 3000000; 6 | 7 | -------------------------------------------------------------------------------- /BinarySearch/BinarySearch.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def search(self, nums: List[int], target: int) -> int: 3 | left = 0 4 | right = len(nums) - 1 5 | while left <= right: 6 | mid = int((left + right) / 2) 7 | if nums[mid] < target: 8 | left = mid + 1 9 | elif nums[mid] > target: 10 | right = mid - 1 11 | else: 12 | return mid 13 | return - 1 -------------------------------------------------------------------------------- /BinaryTreeInorderTraversal/BinTreeInTrav.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 stack = []; 15 | let now = root; 16 | let res = []; 17 | 18 | while (now || stack.length) { 19 | while (now) { 20 | stack.push(now); 21 | now = now.left; 22 | } 23 | now = stack.pop(); 24 | res.push(now.val); 25 | now = now.right; 26 | } 27 | 28 | return res; 29 | }; 30 | -------------------------------------------------------------------------------- /BinaryTreeInorderTraversal/BinTreeInTrav.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | 8 | # ! Итеративный подход, без рекурсии 9 | class Solution: 10 | def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]: 11 | stack = [root] 12 | res = [] 13 | while stack: 14 | node = stack.pop() 15 | if node: 16 | stack.append(node.right) 17 | stack.append(node) 18 | stack.append(node.left) 19 | else: 20 | if stack: 21 | node = stack.pop() 22 | res.append(node.val) 23 | return res -------------------------------------------------------------------------------- /BinaryTreePaths/BinaryTreePaths.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 {string[]} 12 | */ 13 | var binaryTreePaths = function (root) { 14 | if (!root) return []; 15 | let result = []; 16 | function path(root, str) { 17 | if (!root.left && !root.right) result.push(str + root.val); 18 | if (root.left) path(root.left, str + root.val + "->"); 19 | if (root.right) path(root.right, str + root.val + "->"); 20 | } 21 | path(root, ""); 22 | return result; 23 | }; 24 | -------------------------------------------------------------------------------- /BinaryTreePostorderTraversal/BinaryTreePostorderTraversal.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]: 9 | traversal, stack = [], [(root, False)] 10 | while stack: 11 | node, visit = stack.pop() 12 | if node: 13 | if visit: 14 | traversal.append(node.val) 15 | else: 16 | stack.append((node, True)) 17 | stack.append((node.right, False)) 18 | stack.append((node.left, False)) 19 | return traversal -------------------------------------------------------------------------------- /BinaryTreePreorderTraversal/BinaryTreePreorderTraversal.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]: 9 | arr = [] 10 | if root is None: 11 | return arr 12 | arr.append(root.val) 13 | arr += self.preorderTraversal(root.left) 14 | arr += self.preorderTraversal(root.right) 15 | return arr -------------------------------------------------------------------------------- /BinaryTreeWithFactors/BinaryTreeWithFactors.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numFactoredBinaryTrees(self, arr: List[int]) -> int: 3 | arr.sort() 4 | MOD = 10 ** 9 + 7 5 | dp = {} 6 | for n in arr: 7 | dp[n] = 1 8 | for i, n in enumerate(arr): 9 | for j in range(i): 10 | if not(n % arr[j]) and n // arr[j] in dp: 11 | dp[n] += dp[arr[j]] * dp[n//arr[j]] 12 | dp[n] %= MOD 13 | return sum(dp.values()) % MOD -------------------------------------------------------------------------------- /BuddyStrings/BuddyStrings.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def buddyStrings(self, s: str, goal: str) -> bool: 3 | arr = [] 4 | if len(s) != len(goal): return False 5 | if s == goal and len(set(s)) < len(s): 6 | return True 7 | for i in range(len(s)): 8 | if s[i] != goal[i]: 9 | arr.append(i) 10 | if len(arr)==2 and s[arr[0]]==goal[arr[1]] and s[arr[1]]==goal[arr[0]]: 11 | return True 12 | else: 13 | return False -------------------------------------------------------------------------------- /BuildArrayFromPermutation/BuildArrayFromPermutation.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def buildArray(self, nums: List[int]) -> List[int]: 3 | ans = [] 4 | 5 | for i in range(0, len(nums)): 6 | ans.append(nums[nums[i]]) 7 | 8 | return ans -------------------------------------------------------------------------------- /CanMakeArithmeticProgressionFromSequence/CanMakeArithmeticProgressionFromSequence.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def canMakeArithmeticProgression(self, arr: List[int]) -> bool: 3 | arr = sorted(arr) 4 | raz = arr[1] - arr[0] 5 | 6 | for i in range(1, len(arr)): 7 | if arr[i] - arr[i - 1] != raz: 8 | return False 9 | 10 | return True -------------------------------------------------------------------------------- /CanPlaceFlowers/CanPlaceFlowers.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 && n !== 0; i++) { 8 | if ( 9 | flowerbed[i] === 0 && 10 | flowerbed[i - 1] !== 1 && 11 | flowerbed[i + 1] !== 1 12 | ) { 13 | n--; 14 | i++; 15 | } 16 | } 17 | return n === 0; 18 | }; 19 | -------------------------------------------------------------------------------- /CanPlaceFlowers/CanPlaceFlowers.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool: 3 | flowerbed = [0] + flowerbed + [0] 4 | count = 0 5 | for i in range(1, len(flowerbed) - 1): 6 | if flowerbed[i-1] == flowerbed[i] == flowerbed[i+1] == 0: 7 | flowerbed[i] = 1 8 | count += 1 9 | return count >= n 10 | -------------------------------------------------------------------------------- /CheckIfNAndItsDoubleExist/CheckIfNAndItsDoubleExist.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} arr 3 | * @return {boolean} 4 | */ 5 | var checkIfExist = function (arr) { 6 | for (let i = 0; i < arr.length; i++) { 7 | for (let j = 0; j < arr.length; j++) { 8 | if (i !== j) { 9 | if (arr[i] === 2 * arr[j]) return true; 10 | } 11 | } 12 | } 13 | return false; 14 | }; 15 | -------------------------------------------------------------------------------- /CheckIfNAndItsDoubleExist/CheckIfNAndItsDoubleExist.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def checkIfExist(self, arr: List[int]) -> bool: 3 | dct = {} 4 | for i in arr: 5 | if i / 2 in dct or i * 2 in dct: 6 | return True 7 | else: 8 | dct[i] = 1 9 | return False 10 | 11 | 12 | class Solution: 13 | def checkIfExist(self, arr: List[int]) -> bool: 14 | for i in arr: 15 | if i * 2 in arr and i != 0: 16 | return True 17 | elif i == 0 and (arr.count(i) > 1): 18 | return True 19 | return False -------------------------------------------------------------------------------- /ClassesMoreThan5Students/ClassesMoreThan5Students.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT class 4 | FROM Courses 5 | GROUP BY class 6 | HAVING COUNT(student) >= 5 -------------------------------------------------------------------------------- /ClimbingStairs/CliSta.js: -------------------------------------------------------------------------------- 1 | var climbStairs = function(n) { 2 | let a = [0,1,2,3] 3 | for (let i = 4; i <= n; i++) { 4 | a.push(a[i - 1] + a[i - 2]); 5 | } 6 | 7 | return a[n]; 8 | }; -------------------------------------------------------------------------------- /CombinationSum/CombinationSum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]: 3 | res = [] 4 | def traver(cand, arr, sm): 5 | if sm == target: res.append(arr) 6 | if sm >= target: return 7 | for i in range(len(cand)): 8 | traver(cand[i:], arr + [cand[i]], sm+cand[i]) 9 | traver(candidates, [], 0) 10 | return res 11 | -------------------------------------------------------------------------------- /CombinationSumII/CombinationSumII.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: 3 | res = [] 4 | self.dfs(sorted(candidates), target, 0, [], res) 5 | return res 6 | 7 | def dfs(self, nums, target, idx, path, res): 8 | if target <= 0: 9 | if target == 0: 10 | res.append(path) 11 | return 12 | for i in range(idx, len(nums)): 13 | if i > idx and nums[i] == nums[i-1]: 14 | continue 15 | self.dfs(nums, target-nums[i], i+1, path+[nums[i]], res) -------------------------------------------------------------------------------- /CombinationSumIV/CombinationSumIV.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def combinationSum4(self, nums: List[int], target: int) -> int: 3 | dp = [0] * (target + 1) 4 | for i in range(1, target + 1): 5 | for n in nums: 6 | if n == i: 7 | dp[i] += 1 8 | if n < i: 9 | dp[i] += dp[i - n] 10 | return dp[-1] -------------------------------------------------------------------------------- /CombineTwoTables/CombineTwoTables.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | SELECT p.firstName, p.lastName, city, state 3 | FROM Person p 4 | LEFT JOIN Address ad on ad.PersonId = p.PersonId -------------------------------------------------------------------------------- /ConcatenationOfArray/ConcatenationOfArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def getConcatenation(self, nums: List[int]) -> List[int]: 3 | return nums + nums 4 | 5 | 6 | class Solution: 7 | def getConcatenation(self, nums: List[int]) -> List[int]: 8 | res = [] 9 | while len(res) != len(nums) * 2: 10 | res.extend(nums) 11 | return res -------------------------------------------------------------------------------- /ConstructStringFromBinaryTree/ConstructStringFromBinaryTree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def tree2str(self, root: Optional[TreeNode]) -> str: 9 | if root is None: return "" 10 | ans = str(root.val) 11 | if not root.left and root.right: ans += "()" 12 | if root.left: 13 | ans += "(" + self.tree2str(root.left) + ")" 14 | if root.right: 15 | ans += "(" + self.tree2str(root.right) + ")" 16 | return ans -------------------------------------------------------------------------------- /ContainerWithMostWater/ContainerWithMostWater.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxArea(self, height: List[int]) -> int: 3 | left, right = 0, len(height) - 1 4 | count = 0 5 | 6 | while left < right: 7 | count = max(count, (right - left) * min(height[left], height[right])) 8 | if height[left] < height[right]: 9 | left += 1 10 | else: 11 | right -= 1 12 | 13 | return count -------------------------------------------------------------------------------- /ContainsDublicate/ContainsDub.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def containsDuplicate(self, nums: List[int]) -> bool: 3 | set_ = set() 4 | for i in nums: 5 | if i not in set_: 6 | set_.add(i) 7 | else: 8 | return True 9 | return False 10 | 11 | 12 | class Solution: 13 | def containsDuplicate(self, nums: List[int]) -> bool: 14 | set_ = set(nums) 15 | if len(set_) == len(nums): 16 | return False 17 | return True 18 | 19 | 20 | class Solution: 21 | def containsDuplicate(self, nums: List[int]) -> bool: 22 | dupl = {} 23 | for i in nums: 24 | if i in dupl: 25 | return True 26 | else: 27 | dupl[i] = 1 28 | return False -------------------------------------------------------------------------------- /ConvertSortedArrayToBinarySearchTree/ConSortArrBinTree.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val) { 4 | * this.val = val; 5 | * this.left = this.right = null; 6 | * } 7 | */ 8 | /** 9 | * @param {number[]} nums 10 | * @return {TreeNode} 11 | // */ 12 | var sortedArrayToBST = function (nums) { 13 | return check(nums, 0, nums.length - 1); 14 | }; 15 | 16 | let check = function (nums, t1, t2) { 17 | if (t1 > t2) return null; 18 | let mid = Math.ceil((t1 + t2) / 2); 19 | let root = new TreeNode(nums[mid]); 20 | root.left = check(nums, t1, mid - 1); 21 | root.right = check(nums, mid + 1, t2); 22 | return root; 23 | }; 24 | -------------------------------------------------------------------------------- /CountAndSay/CountAndSay.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def countAndSay(self, n: int) -> str: 3 | if n==1: return "1" 4 | prev = self.countAndSay(n - 1) 5 | count = 1 6 | res = "" 7 | for i in range(len(prev)): 8 | if i == len(prev) - 1 or prev[i] != prev[i + 1]: 9 | res += str(count) 10 | res += prev[i] 11 | count = 1 12 | else: 13 | count += 1 14 | return res 15 | -------------------------------------------------------------------------------- /CountBinarySubstrings/CountBinarySubstrings.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def countBinarySubstrings(self, s: str) -> int: 3 | prev, cur = 0, 1 4 | res = 0 5 | for i in range(1, len(s)): 6 | if s[i] == s[i - 1]: 7 | cur += 1 8 | else: 9 | prev, cur = cur, 1 10 | if cur <= prev: 11 | res += 1 12 | return res -------------------------------------------------------------------------------- /CountVowelsPermutation/CountVowelsPermutation.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def countVowelPermutation(self, n: int) -> int: 3 | modul = 10 ** 9 + 7 4 | (a, e, i, o, u) = (1, 1, 1, 1, 1) 5 | length_permutation = 2 6 | while length_permutation <= n: 7 | end_with_a = e + i + u 8 | 9 | end_with_e = a + i 10 | 11 | end_with_i = e + o 12 | 13 | end_with_o = i 14 | 15 | end_with_u = i + o 16 | 17 | (a, e, i, o, u) = (end_with_a, end_with_e, end_with_i, end_with_o, end_with_u ) 18 | 19 | length_permutation += 1 20 | return (a + e + i + o + u) % modul 21 | -------------------------------------------------------------------------------- /CreateTargetArrayInTheGivenOrder/CreateTargetArrayInTheGivenOrder.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def createTargetArray(self, nums: List[int], index: List[int]) -> List[int]: 3 | arr = [] 4 | for i in range(len(nums)): 5 | arr.insert(index[i], nums[i]) 6 | return arr 7 | 8 | 9 | class Solution: 10 | def createTargetArray(self, nums: List[int], index: List[int]) -> List[int]: 11 | arr = [] 12 | for i, j in zip(nums, index): 13 | arr[j:j] = [i] 14 | return arr -------------------------------------------------------------------------------- /CustomerPlacingTheLargestNumberOfOrders/CustomerPlacingTheLargestNumberOfOrders.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT customer_number 4 | FROM ( 5 | SELECT customer_number, COUNT(order_number) as count 6 | FROM Orders 7 | GROUP BY customer_number 8 | ORDER BY COUNT(order_number) DESC 9 | ) 10 | WHERE ROWNUM = 1; -------------------------------------------------------------------------------- /CustomersWhoNeverOrder/CusWhoNevOrd.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT cu.name AS Customers 4 | FROM Customers cu 5 | LEFT JOIN Orders ord on cu.id = ord.customerId 6 | WHERE ord.customerId IS NULL -------------------------------------------------------------------------------- /DefangingAnIPAddress/DefangingAnIPAddress.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def defangIPaddr(self, address: str) -> str: 3 | return address.replace('.', '[.]') 4 | -------------------------------------------------------------------------------- /DegreeOfAnArray/DegreeOfAnArray.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findShortestSubArray = function (nums) { 6 | const counts = {}; 7 | const firstIndexes = {}; 8 | const lastIndexes = {}; 9 | let max = 0; 10 | for (let i = 0; i < nums.length; i++) { 11 | const k = nums[i]; 12 | counts[k] = (counts[k] || 0) + 1; 13 | max = Math.max(max, counts[k]); 14 | if (firstIndexes[k] === undefined) { 15 | firstIndexes[k] = i; 16 | } 17 | lastIndexes[k] = i; 18 | } 19 | let res = nums.length; 20 | for (const k in counts) { 21 | if (counts[k] === max) { 22 | res = Math.min(res, lastIndexes[k] - firstIndexes[k] + 1); 23 | } 24 | } 25 | return res; 26 | }; 27 | -------------------------------------------------------------------------------- /DegreeOfAnArray/DegreeOfAnArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findShortestSubArray(self, nums: List[int]) -> int: 3 | hasht = {} 4 | for i, n in enumerate(nums): 5 | if n in hasht: 6 | hasht[n].append(i) 7 | else: 8 | hasht[n] = [i] 9 | maxim = max([len(i) for i in hasht.values()]) 10 | return min([i[-1] - i[0] for i in hasht.values() if len(i) == maxim]) + 1 -------------------------------------------------------------------------------- /DeleteDublicateEmails/DeleteDublicateEmails.sql: -------------------------------------------------------------------------------- 1 | /* 2 | Please write a DELETE statement and DO NOT write a SELECT statement. 3 | Write your PL/SQL query statement below 4 | */ 5 | 6 | DELETE 7 | FROM Person 8 | WHERE id NOT IN ( 9 | SELECT min(id) 10 | FROM Person 11 | GROUP BY email 12 | ) -------------------------------------------------------------------------------- /DesignHashSet/DesignHashSet.py: -------------------------------------------------------------------------------- 1 | class MyHashSet: 2 | 3 | def __init__(self): 4 | self.hash = [] 5 | 6 | def add(self, key: int) -> None: 7 | if not self.contains(key): 8 | self.hash.append(key) 9 | 10 | def remove(self, key: int) -> None: 11 | for i in range(len(self.hash)): 12 | if self.hash[i] == key: 13 | self.hash.pop(i) 14 | break 15 | 16 | def contains(self, key: int) -> bool: 17 | if key in self.hash: 18 | return True 19 | else: return False 20 | 21 | # Your MyHashSet object will be instantiated and called as such: 22 | # obj = MyHashSet() 23 | # obj.add(key) 24 | # obj.remove(key) 25 | # param_3 = obj.contains(key) -------------------------------------------------------------------------------- /DesignHashmap/DesMap.py: -------------------------------------------------------------------------------- 1 | # Не забывать self, из за ООП в задаче 2 | class MyHashMap: 3 | def __init__(self): 4 | self.hash_table = [-1]*1000001 5 | def put(self, key: int, value: int) -> None: 6 | self.hash_table[key] = value 7 | def get(self, key: int) -> int: 8 | return self.hash_table[key] 9 | def remove(self, key: int) -> None: 10 | self.hash_table[key] = -1 11 | 12 | obj = MyHashMap() 13 | obj.put(5, 5) 14 | param_2 = obj.get(5) 15 | obj.remove(5) 16 | -------------------------------------------------------------------------------- /DetectCapital/DetectCapital.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} word 3 | * @return {boolean} 4 | */ 5 | var detectCapitalUse = function (word) { 6 | if (word === word.toUpperCase()) return true; 7 | if (word === word.toLowerCase()) return true; 8 | if (word[0] === word[0].toUpperCase()) { 9 | let leftOutStr = word.slice(1); 10 | if (leftOutStr === leftOutStr.toLowerCase()) return true; 11 | } 12 | return false; 13 | }; 14 | 15 | 16 | /** 17 | * @param {string} word 18 | * @return {boolean} 19 | */ 20 | var detectCapitalUse = function (word) { 21 | return ( 22 | word === word.toUpperCase() || 23 | word === word[0] + word.substr(1).toLowerCase() 24 | ); 25 | }; 26 | -------------------------------------------------------------------------------- /DistributeCandies/DisCan.js: -------------------------------------------------------------------------------- 1 | // Метод доступа size возвращает количество (уникальных) элементов в объекте Set 2 | 3 | /** 4 | * @param {number[]} candyType 5 | * @return {number} 6 | */ 7 | var distributeCandies = function(candyType) { 8 | let set = new Set(candyType); 9 | if (set.size >= candyType.length / 2) return candyType.length / 2; 10 | else return set.size; 11 | }; 12 | 13 | 14 | /** 15 | * @param {number[]} candyType 16 | * @return {number} 17 | */ 18 | var distributeCandies = function(candyType) { 19 | return Math.min(candyType.length/2, new Set(candyType).size) 20 | }; -------------------------------------------------------------------------------- /DistributeCandies/DisCan.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def distributeCandies(self, candyType: List[int]) -> int: 3 | n = len(candyType) 4 | maxim = n // 2 5 | m = set(candyType) 6 | i = len(m) 7 | if i > maxim: 8 | return maxim 9 | else: return i 10 | 11 | 12 | class Solution: 13 | def distributeCandies(self, candyType: List[int]) -> int: 14 | return min(len(candyType) // 2, len(set(candyType))) -------------------------------------------------------------------------------- /DuplicateEmails/DuplicateEmails.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT email AS Email 4 | FROM Person 5 | GROUP BY email 6 | HAVING COUNT(email) > 1; -------------------------------------------------------------------------------- /EmployeesEarningMoreThanTheirManagers/EmployessEarning.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT e1.name as Employee 4 | FROM Employee e1, Employee e2 5 | WHERE e1.managerId = e2.id and e1.salary > e2.salary -------------------------------------------------------------------------------- /ExcelSheetColumnNumber/ExcelSheetColumnNumber.js: -------------------------------------------------------------------------------- 1 | // Метод charCodeAt() возвращает числовое значение Юникода для символа по указанному индексу 2 | 3 | /** 4 | * @param {string} columnTitle 5 | * @return {number} 6 | */ 7 | var titleToNumber = function (columnTitle) { 8 | let res = 0; 9 | for (let i = 0; i < columnTitle.length; i++) { 10 | res = res * 26 + columnTitle.charCodeAt(i) - "A".charCodeAt(0) + 1; 11 | } 12 | return res; 13 | }; 14 | -------------------------------------------------------------------------------- /ExcelSheetColumnNumber/ExcelSheetColumnNumber.py: -------------------------------------------------------------------------------- 1 | """ 2 | ORD() => Возвращает числовое представление для указанного символа. 3 | """ 4 | 5 | class Solution: 6 | def titleToNumber(self, columnTitle: str) -> int: 7 | res = 0 8 | for i, c in enumerate(reversed(columnTitle.upper())): 9 | res += (26 ** i) * (ord(c) - ord("A") + 1) 10 | return res -------------------------------------------------------------------------------- /ExcelSheetColumnTitle/ExcelSheetColumnTitle.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} columnNumber 3 | * @return {string} 4 | */ 5 | var convertToTitle = function (columnNumber) { 6 | let res = ""; 7 | while (columnNumber > 0) { 8 | let r = columnNumber % 26; 9 | let d = parseInt(columnNumber / 26); 10 | if (r == 0) { 11 | r = 26; 12 | d -= 1; 13 | } 14 | res += String.fromCharCode(64 + r); 15 | columnNumber = d; 16 | } 17 | return res.split("").reverse().join(""); 18 | }; 19 | -------------------------------------------------------------------------------- /ExcelSheetColumnTitle/ExcelSheetColumnTitle.py: -------------------------------------------------------------------------------- 1 | """ 2 | ORD() => Возвращает числовое представление для указанного символа. 3 | CHR() => возвращает символ, представляющий указанный юникод. 4 | """ 5 | 6 | class Solution: 7 | def convertToTitle(self, columnNumber: int) -> str: 8 | arr = [] 9 | while columnNumber > 0: 10 | arr.append(chr((columnNumber - 1) % 26 + ord("A"))) 11 | columnNumber = (columnNumber - 1) // 26 12 | arr.reverse() 13 | return "".join(arr) 14 | 15 | 16 | class Solution: 17 | def convertToTitle(self, columnNumber: int) -> str: 18 | s = "" 19 | while columnNumber > 0: 20 | columnNumber,rem = divmod(columnNumber-1,26) 21 | s += chr(65+rem) 22 | return s[::-1] -------------------------------------------------------------------------------- /FairCandySwap/FairCandySwap.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def fairCandySwap(self, aliceSizes: List[int], bobSizes: List[int]) -> List[int]: 3 | answer = [] 4 | sumAlice = sum(aliceSizes) 5 | sumBob = sum(bobSizes) 6 | mid = (sumBob - sumAlice) // 2 7 | sumSetAlice = set(aliceSizes) 8 | for bob in bobSizes: 9 | if bob - mid in sumSetAlice: 10 | answer.append(int(bob - mid)) 11 | answer.append(bob) 12 | return answer 13 | return answer -------------------------------------------------------------------------------- /Fibonacci/Fibo.js: -------------------------------------------------------------------------------- 1 | var fib = function(n) { 2 | // Тупо решаю тернарным оператором и рекурсией 3 | return n <= 1 ? n : fib(n - 1) + fib(n - 2) 4 | }; -------------------------------------------------------------------------------- /Fibonacci/Fibo.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # Тупо решаю тернарным оператором и рекурсией 3 | # Нельзя забывать прописывать self, из за ООП на самом сайте 4 | def fib(self, n: int) -> int: 5 | if n <= 1: return n 6 | return self.fib(n-1) + self.fib(n-2) 7 | -------------------------------------------------------------------------------- /FinalValueOfVariableAfterPerformingOperations/FinalValueOfVariableAfterPerformingOperations.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def finalValueAfterOperations(self, operations: List[str]) -> int: 3 | count = 0 4 | for i in operations: 5 | if i == "--X" or i == "X--": 6 | count -= 1 7 | else: 8 | count += 1 9 | return count -------------------------------------------------------------------------------- /FindAllNumbersDisappearedInAnArray/FindAllNumDis.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var findDisappearedNumbers = function (nums) { 6 | let arr = []; 7 | let set = new Set(nums); 8 | for (let i = 1; i <= nums.length; i++) { 9 | if (!set.has(i)) { 10 | arr.push(i); 11 | } 12 | } 13 | return arr; 14 | }; 15 | -------------------------------------------------------------------------------- /FindAllNumbersDisappearedInAnArray/FindAllNumDis.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findDisappearedNumbers(self, nums: List[int]) -> List[int]: 3 | length = len(nums) 4 | num_set = set(range(1, length + 1)) 5 | for i in nums: 6 | if i in num_set: 7 | num_set.remove(i) 8 | return list(num_set) -------------------------------------------------------------------------------- /FindCommonCharacters/FindCommonCharacters.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def commonChars(self, words: List[str]) -> List[str]: 3 | dict_ = {} 4 | for c in set(words[0]): 5 | dict_[c] = min([word.count(c) for word in words]) 6 | arr = [] 7 | for key, value in dict_.items(): 8 | if value > 0: 9 | for _ in range(value): 10 | arr.append(key) 11 | return arr 12 | -------------------------------------------------------------------------------- /FindCustomerReferee/FindCustomerReferee.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT cus.name 4 | FROM Customer cus 5 | WHERE cus.referee_id != 2 OR cus.referee_id IS NULL; -------------------------------------------------------------------------------- /FindFirstAndLastPositionOfElementInSortedArray/FindFirstAndLastPositionOfElementInSortedArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def searchRange(self, nums: List[int], target: int) -> List[int]: 3 | res=[] 4 | 5 | if nums.count(target) == 0: 6 | return [-1,-1] 7 | 8 | res.append(nums.index(target)) 9 | for x in range(len(nums) -1 , -1 , -1 ): 10 | if nums[x] == target: 11 | res.append(x) 12 | break 13 | 14 | return res -------------------------------------------------------------------------------- /FindLuckyIntegerInAnArray/FindLuckyIntegerInAnArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findLucky(self, arr: List[int]) -> int: 3 | dc = {} 4 | for i in range(len(arr)): 5 | if arr[i] not in dc: 6 | dc[arr[i]] = 1 7 | else: 8 | dc[arr[i]] = dc[arr[i]] + 1 9 | max_ = -1 10 | for key, value in dc.items(): 11 | if key == value: 12 | max_ = max(key, max_) 13 | return max_ -------------------------------------------------------------------------------- /FindTheDifference/FindTheDifference.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findTheDifference(self, s: str, t: str) -> str: 3 | for i in set(t): 4 | if s.count(i) != t.count(i): return i 5 | 6 | 7 | class Solution: 8 | def findTheDifference(self, s: str, t: str) -> str: 9 | s, t = sorted(s), sorted(t) 10 | for i, j in enumerate(s): 11 | if j != t[i]: return t[i] 12 | return t[-1] 13 | 14 | 15 | # ! Побитовый метод 16 | class Solution: 17 | def findTheDifference(self, s: str, t: str) -> str: 18 | x = 0 19 | for c in s+t: 20 | x ^= ord(c) 21 | return chr(x) -------------------------------------------------------------------------------- /FindTheDistanceValueBetweenTwoArrays/FindTheDistanceValueBetweenTwoArrays.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findTheDistanceValue(self, arr1: List[int], arr2: List[int], d: int) -> int: 3 | set_ = set() 4 | for i in range(len(arr1)): 5 | for j in range(len(arr2)): 6 | if abs(arr1[i] - arr2[j]) <= d: 7 | set_.add(i) 8 | return len(arr1) - len(set_) -------------------------------------------------------------------------------- /FindTheTownJudge/FindTheTownJudge.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findJudge(self, n: int, trust: List[List[int]]) -> int: 3 | arr = [0] * n 4 | trust_count = [0] * n 5 | 6 | for person in trust: 7 | arr[person[0] - 1] = 1 8 | trust_count[person[1] - 1] += 1 9 | 10 | for i in range(n): 11 | if arr[i]==0 and trust_count[i]==n-1: return i+1 12 | 13 | return -1 -------------------------------------------------------------------------------- /FindTotalTimeSpentByEachEmployee/FindTotalTimeSpentByEachEmployee.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT 4 | TO_CHAR(event_day, 'YYYY-MM-DD') AS day, 5 | emp_id, 6 | SUM(out_time - in_time) total_time 7 | FROM Employees 8 | GROUP BY event_day, emp_id -------------------------------------------------------------------------------- /FirstUniqueCharacterInString/FirstUnCharStr.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def firstUniqChar(self, s: str) -> int: 3 | for i in s: 4 | if s.count(i) == 1: 5 | return s.index(i) 6 | return -1 7 | 8 | 9 | class Solution: 10 | def firstUniqChar(self, s: str) -> int: 11 | dict = Counter(s) 12 | for i, char in enumerate(s): 13 | if dict[char] == 1: 14 | return i 15 | return -1 16 | 17 | 18 | class Solution: 19 | def firstUniqChar(self, s: str) -> int: 20 | for i in range(len(s)): 21 | if s[i] not in s[:i] and s[i] not in s[i+1:]: 22 | return i 23 | return -1 -------------------------------------------------------------------------------- /FizzBuzz/FizzBuzz.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {string[]} 4 | */ 5 | var fizzBuzz = function (n) { 6 | let arr = []; 7 | for (let i = 1; i <= n; i++) { 8 | if (i % 5 === 0 && i % 3 === 0) arr.push("FizzBuzz"); 9 | else if (i % 5 === 0) arr.push("Buzz"); 10 | else if (i % 3 === 0) arr.push("Fizz"); 11 | else arr.push(i.toString()); 12 | } 13 | return arr; 14 | }; 15 | 16 | 17 | /** 18 | * @param {number} n 19 | * @return {string[]} 20 | */ 21 | var fizzBuzz = function (n) { 22 | return new Array(n) 23 | .fill(0) 24 | .map((a, i) => (++i % 3 ? "" : "Fizz") + (i % 5 ? "" : "Buzz") || "" + i); 25 | }; 26 | -------------------------------------------------------------------------------- /GamePlayAnalysisI/GamePlayAnalysisI.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT ac.player_id, TO_CHAR(MIN(TO_DATE(event_date, 'yyyy-mm-dd'))) AS first_login 4 | FROM Activity ac 5 | GROUP BY player_id -------------------------------------------------------------------------------- /GenerateParentheses/GenerateParentheses.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # ! dfs 3 | def generateParenthesis(self, n: int) -> List[str]: 4 | res = [] 5 | def dfs(left, right, s): 6 | if len(s) == n * 2: 7 | res.append(s) 8 | return 9 | 10 | if left < n: 11 | dfs(left + 1, right, s + "(") 12 | 13 | if right < left: 14 | dfs(left, right + 1, s + ")") 15 | 16 | dfs(0, 0, '') 17 | return res 18 | -------------------------------------------------------------------------------- /GroupAnagrams/GroupAnagrams.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def groupAnagrams(self, strs: List[str]) -> List[List[str]]: 3 | table = {} 4 | for i in strs: 5 | ele = "".join(sorted(list(i))) 6 | if ele not in table: 7 | table[ele] = [] 8 | table[ele].append(i) 9 | return list(table.values()) -------------------------------------------------------------------------------- /GroupThePeopleGivenTheGroupSizeTheyBelongTo/GroupThePeopleGivenTheGroupSizeTheyBelongTo.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def groupThePeople(self, groupSizes: List[int]) -> List[List[int]]: 3 | arr = [] 4 | hashmap = {} 5 | for idx, i in enumerate(groupSizes): 6 | if i not in hashmap: 7 | hashmap[i]=[idx] 8 | else: 9 | hashmap[i].append(idx) 10 | for key, value in hashmap.items(): 11 | count = 0 12 | for i in value: 13 | if count == 0: 14 | arr.append([i]) 15 | else: 16 | arr[-1].append(i) 17 | count+=1 18 | count = count % key 19 | return arr -------------------------------------------------------------------------------- /HappyNumber/HappyNumber.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isHappy(self, n: int) -> bool: 3 | set_ = set() 4 | while n not in set_: 5 | set_.add(n) 6 | n = sum([int(x) ** 2 for x in str(n)]) 7 | return n == 1 -------------------------------------------------------------------------------- /HeightChecker/HeightChecker.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def heightChecker(self, heights: List[int]) -> int: 3 | expected = sorted(heights) 4 | count = 0 5 | for i in range(len(heights)): 6 | if expected[i] != heights[i]: 7 | count += 1 8 | return count -------------------------------------------------------------------------------- /ImageSmoother/ImageSmoother.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} img 3 | * @return {number[][]} 4 | */ 5 | var imageSmoother = function (img) { 6 | return img.map((arr, i) => 7 | arr.map((_, j) => { 8 | var sum = 0; 9 | var count = 0; 10 | for (let l = i - 1; l <= i + 1; l++) { 11 | for (let m = j - 1; m <= j + 1; m++) { 12 | if (img[l] && img[l][m] > -1) { 13 | sum += img[l][m]; 14 | count++; 15 | } 16 | } 17 | } 18 | return Math.floor(sum / count); 19 | }) 20 | ); 21 | }; 22 | -------------------------------------------------------------------------------- /ImageSmoother/ImageSmoother.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def imageSmoother(self, img: List[List[int]]) -> List[List[int]]: 3 | m = len(img) 4 | n = len(img[0]) 5 | res = [[0] * n for i in range(m)] 6 | for i in range(m): 7 | for j in range(n): 8 | t = 0 9 | c = 0 10 | for dx in range(-1, 2): 11 | for dy in range(-1, 2): 12 | if 0 <= i + dx < m and 0 <= j + dy < n: 13 | t += img[i + dx][j + dy] 14 | c += 1 15 | res[i][j] = t // c 16 | return res -------------------------------------------------------------------------------- /ImplementStr/ImplStr.js: -------------------------------------------------------------------------------- 1 | var strStr = function(haystack, needle) { 2 | if (!needle) {return 0} 3 | return haystack.indexOf(needle) 4 | }; -------------------------------------------------------------------------------- /IncreasingTripletSubsequence/IncreasingTripletSubsequence.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {boolean} 4 | */ 5 | var increasingTriplet = function (nums) { 6 | let one = Infinity; 7 | let two = Infinity; 8 | for (let i of nums) { 9 | if (i <= one) { 10 | one = i; 11 | } else if (i <= two) { 12 | two = i; 13 | } else { 14 | return true; 15 | } 16 | } 17 | return false; 18 | }; 19 | -------------------------------------------------------------------------------- /IncreasingTripletSubsequence/IncreasingTripletSubsequence.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def increasingTriplet(self, nums: List[int]) -> bool: 3 | first = second = float('inf') 4 | for n in nums: 5 | if n <= first: 6 | first = n 7 | elif n <= second: 8 | second = n 9 | else: 10 | return True 11 | return False -------------------------------------------------------------------------------- /IntegerToRoman/IntegerToRoman.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} num 3 | * @return {string} 4 | */ 5 | var intToRoman = function (num) { 6 | const val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]; 7 | const rom = [ 8 | "M", 9 | "CM", 10 | "D", 11 | "CD", 12 | "C", 13 | "XC", 14 | "L", 15 | "XL", 16 | "X", 17 | "IX", 18 | "V", 19 | "IV", 20 | "I", 21 | ]; 22 | let ans = ""; 23 | for (let i = 0; num; i++) 24 | while (num >= val[i]) (ans += rom[i]), (num -= val[i]); 25 | return ans; 26 | }; 27 | -------------------------------------------------------------------------------- /IntegerToRoman/IntegerToRoman.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def intToRoman(self, num: int) -> str: 3 | hash_ = {"M": 1000, "CM": 900, "D": 500, "CD": 400, 4 | "C": 100, "XC": 90, "L": 50, "XL": 40, "X": 10, 5 | "IX": 9, "V": 5, "IV": 4, "I": 1} 6 | str_ = "" 7 | for key, value in hash_.items(): 8 | str_ += key * (num // value) 9 | if num // value != 0: 10 | num -= (value * (num // value)) 11 | return str_ -------------------------------------------------------------------------------- /InterSectionOfTwoArraysII/InsecOfTwoArrII.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]: 3 | arr = [] 4 | for i in nums1: 5 | if i in nums2: 6 | arr.append(i) 7 | nums2.remove(i) 8 | return arr 9 | 10 | 11 | class Solution(object): 12 | def intersect(self, nums1, nums2): 13 | nums1.sort() 14 | nums2.sort() 15 | arr = [] 16 | i, j = 0, 0 17 | while i < len(nums1) and j < len(nums2): 18 | if nums1[i] < nums2[j]: 19 | i += 1 20 | elif nums2[j] < nums1[i]: 21 | j += 1 22 | else: 23 | arr.append(nums1[i]) 24 | i += 1 25 | j += 1 26 | return arr -------------------------------------------------------------------------------- /IntersectionOfTwoLinkedLists/IntersectionOfTwoLinkedLists.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]: 9 | a, b = headA, headB 10 | while (a != b): 11 | a = headB if not a else a.next 12 | b = headA if not b else b.next 13 | return a -------------------------------------------------------------------------------- /InvertBinaryTree/InvertBinaryTree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def helper(self, root): 9 | if not root: return 10 | 11 | root.right, root.left = root.left, root.right 12 | self.helper(root.left) 13 | self.helper(root.right) 14 | 15 | return root 16 | 17 | def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]: 18 | return self.helper(root) -------------------------------------------------------------------------------- /IsSubsequence/IsSubsequence.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @param {string} t 4 | * @return {boolean} 5 | */ 6 | var isSubsequence = function (s, t) { 7 | let counter = 0; 8 | for (let i of t) { 9 | if (i === s[counter]) { 10 | counter++; 11 | } 12 | } 13 | return counter === s.length; 14 | }; 15 | 16 | 17 | /** 18 | * @param {string} s 19 | * @param {string} t 20 | * @return {boolean} 21 | */ 22 | var isSubsequence = function (s, t) { 23 | let i = 0, 24 | j = 0; 25 | while (j < t.length) { 26 | if (s[i] === t[j]) { 27 | i++; 28 | } 29 | j++; 30 | } 31 | return i === s.length; 32 | }; 33 | -------------------------------------------------------------------------------- /IsSubsequence/IsSubsequence.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isSubsequence(self, s: str, t: str) -> bool: 3 | counter = 0 4 | for i in t: 5 | if counter == len(s): 6 | break 7 | elif s[counter] == i: 8 | counter += 1 9 | return counter == len(s) 10 | 11 | 12 | class Solution: 13 | def isSubsequence(self, s: str, t: str) -> bool: 14 | i, j = 0, 0 15 | while i < len(s) and j < len(t): 16 | if s[i] == t[j]: 17 | i += 1 18 | j += 1 19 | return i == len(s) -------------------------------------------------------------------------------- /IslandPerimeter/IslandPerimeter.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} grid 3 | * @return {number} 4 | */ 5 | var islandPerimeter = function (grid) { 6 | let rows = grid.length; 7 | let cols = grid[0].length; 8 | let perimeter = 0; 9 | for (let row = 0; row < rows; row++) { 10 | for (let col = 0; col < cols; col++) { 11 | if (!grid[row][col]) continue; 12 | perimeter += 4; 13 | if (row > 0 && grid[row - 1][col]) perimeter--; 14 | if (col > 0 && grid[row][col - 1]) perimeter--; 15 | if (row < rows - 1 && grid[row + 1][col]) perimeter--; 16 | if (col < cols - 1 && grid[row][col + 1]) perimeter--; 17 | } 18 | } 19 | return perimeter; 20 | }; 21 | -------------------------------------------------------------------------------- /IslandPerimeter/IslandPerimeter.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def islandPerimeter(self, grid: List[List[int]]) -> int: 3 | m, n = len(grid), len(grid[0]) 4 | land, nei = 0, 0 5 | for i in range(m): 6 | for j in range(n): 7 | if grid[i][j] == 1: 8 | land += 1 9 | if i < m-1 and grid[i+1][j]==1: 10 | nei+=1 11 | if j < n-1 and grid[i][j+1]==1: 12 | nei+=1 13 | return land * 4 - 2 * nei 14 | -------------------------------------------------------------------------------- /JumpGame/JumpGame.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def canJump(self, nums: List[int]) -> bool: 3 | max_ = 0 4 | for i, j in enumerate(nums): 5 | if i > max_: 6 | return False 7 | max_ = max(max_, i + j) 8 | return True -------------------------------------------------------------------------------- /JumpGameII/JumpGameII.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def jump(self, nums: List[int]) -> int: 3 | count = 0 4 | farthest = 0 5 | end = 0 6 | for i in range(len(nums) - 1): 7 | cur = i + nums[i] 8 | farthest = max(farthest, cur) 9 | if i == end: 10 | end = farthest 11 | count += 1 12 | return count -------------------------------------------------------------------------------- /LargestNumberAtLeastTwiceOfOthers/LargestNumberAtLeastTwiceOfOthers.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def dominantIndex(self, nums: List[int]) -> int: 3 | sort = sorted(nums) 4 | for i in range(len(sort) - 1): 5 | if max(nums) >= sort[i] * 2: 6 | continue 7 | else: 8 | return -1 9 | return nums.index(max(nums)) -------------------------------------------------------------------------------- /LargestPerimeterTriangle/LargestPerimeterTriangle.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def largestPerimeter(self, nums: List[int]) -> int: 3 | nums = sorted(nums, reverse = True) 4 | for i in range(len(nums) - 2): 5 | if nums[i] < nums[i + 1] + nums[i + 2]: 6 | return nums[i] + nums[i + 1] + nums[i + 2] 7 | return 0 -------------------------------------------------------------------------------- /LengthOfLastWord/LenLastWors.js: -------------------------------------------------------------------------------- 1 | var lengthOfLastWord = function(s) { 2 | // Переменная для последнего слова, trim - убирает пробелы с обоих концов, split разделяет строку по пробелу и возвращает массив из слов которые были в строке 3 | let word = s.trim().split(" "); 4 | // Если длина слова равна нулю, возвратить 0 5 | if (word.length === 0) { 6 | return 0; 7 | } else { 8 | // Возвращаю длину последнего элемента в массиве, то есть длину последней строки 9 | return word[word.length - 1].length; 10 | } 11 | }; 12 | 13 | var lengthOfLastWord = function(s) { 14 | // Тоже самое что сверху, только в тернарном операторе 15 | let word = s.trim().split(" "); 16 | return word.length > 0 ? word[word.length - 1].length : 0; 17 | }; -------------------------------------------------------------------------------- /LicenseKeyFormatting/LicenseKeyFormat.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def licenseKeyFormatting(self, s: str, k: int) -> str: 3 | S = s.replace("-", "").upper() 4 | each = len(S) % k 5 | arr = [] 6 | if each: 7 | arr.append(S[:each]) 8 | for i in range(each, len(S), k): 9 | arr.append(S[i : i + k]) 10 | return "-".join(arr) 11 | 12 | 13 | class Solution: 14 | def licenseKeyFormatting(self, s: str, k: int) -> str: 15 | S = s.replace("-", "").upper()[::-1] 16 | return '-'.join(S[i:i+k] for i in range(0, len(S), k))[::-1] -------------------------------------------------------------------------------- /LinkedListCycle/LinkedListCycle.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | def hasCycle(self, head: Optional[ListNode]) -> bool: 9 | slow = head 10 | fast = head 11 | while fast != None and fast.next != None: 12 | fast = fast.next.next 13 | slow = slow.next 14 | if fast == slow: 15 | return True 16 | return False -------------------------------------------------------------------------------- /LongestCommonPrefix/LonComPref.js: -------------------------------------------------------------------------------- 1 | var longestCommonPrefix = function (strs) { 2 | if (!strs.length) return ""; 3 | for (let i = 0; i <= strs[0].length; i++) { 4 | for (let j = 1; j < strs.length; j++) { 5 | if (strs[0][i] !== strs[j][i]) { 6 | return strs[0].slice(0, i); 7 | } 8 | } 9 | } 10 | return strs[0]; 11 | }; 12 | 13 | 14 | // ! Второе решение 15 | var longestCommonPrefix = function (strs) { 16 | if (!strs.length) return ''; 17 | for (let i = 0; i <= strs[0].length; i++) { 18 | if (!strs.every((string) => string[i] === strs[0][i])) { 19 | return strs[0].slice(0, i); 20 | } 21 | } 22 | return strs[0]; 23 | }; -------------------------------------------------------------------------------- /LongestCommonPrefix/LonComPref.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def longestCommonPrefix(self, strs: List[str]) -> str: 3 | short_str = min(strs, key=len) 4 | for i,x in enumerate(short_str): 5 | for other_str in strs: 6 | if other_str[i] != x: 7 | return short_str[:i] 8 | return short_str 9 | -------------------------------------------------------------------------------- /LongestContinuousIncreasingSubsequence/LonConIncSub.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findLengthOfLCIS = function (nums) { 6 | let count = 1, 7 | long = 0; 8 | for (let i = 0; i < nums.length; i++) { 9 | if (nums[i] < nums[i + 1]) count++; 10 | else count = 1; 11 | long = Math.max(count, long); 12 | } 13 | return long; 14 | }; 15 | -------------------------------------------------------------------------------- /LongestContinuousIncreasingSubsequence/LonConIncSub.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findLengthOfLCIS(self, nums: List[int]) -> int: 3 | long, count = 0, 1 4 | for i in range(len(nums) - 1): 5 | if nums[i + 1] > nums[i]: 6 | count += 1 7 | else: 8 | count, long = 1, max(long, count) 9 | return max(long, count) 10 | 11 | 12 | class Solution: 13 | def findLengthOfLCIS(self, nums: List[int]) -> int: 14 | if not nums: 15 | return 0 16 | dp = [1] * len(nums) 17 | for i in range(1, len(nums)): 18 | if nums[i] > nums[i-1]: 19 | dp[i] = dp[i - 1] + 1 20 | return max(dp) -------------------------------------------------------------------------------- /LongestHarmoniousSubsequence/LonHarSub.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findLHS(self, nums: List[int]) -> int: 3 | mp={} 4 | for i in nums: 5 | if i not in mp: 6 | mp[i]=1 7 | else: mp[i]+=1 8 | ln=0; 9 | for i in mp: 10 | if mp.get(i+1): 11 | ln=max(ln,mp[i]+mp[i+1]) 12 | return ln -------------------------------------------------------------------------------- /LongestHarmoniousSubsequence/LonHurSub.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findLHS = function (nums) { 6 | let res = 0, 7 | map = new Map(); 8 | nums.forEach((n) => 9 | map.has(n) ? map.set(n, map.get(n) + 1) : map.set(n, 1) 10 | ); 11 | for (let key of map.keys()) { 12 | if (map.has(key - 1)) { 13 | res = Math.max(res, map.get(key) + map.get(key - 1)); 14 | } 15 | } 16 | return res; 17 | }; 18 | -------------------------------------------------------------------------------- /LongestIncreasingSubsequence/LongestIncreasingSubsequence.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def lengthOfLIS(self, nums: List[int]) -> int: 3 | tails = [0] * len(nums) 4 | size = 0 5 | for num in nums: 6 | left, right = 0, size 7 | while left != right: 8 | middle = (left + right) // 2 9 | if tails[middle] < num: 10 | left = middle + 1 11 | else: 12 | right = middle 13 | tails[left] = num 14 | size = max(left + 1, size) 15 | return size -------------------------------------------------------------------------------- /LongestPalindrome/LongestPalindrome.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var longestPalindrome = function (s) { 6 | let ans = 0; 7 | let obj = {}; 8 | for (let i of s) { 9 | obj[i] = (obj[i] || 0) + 1; 10 | if (obj[i] % 2 == 0) ans += 2; 11 | } 12 | return s.length > ans ? ans + 1 : ans; 13 | }; 14 | -------------------------------------------------------------------------------- /LongestPalindrome/LongestPalindrome.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def longestPalindrome(self, s: str) -> int: 3 | hasht = set() 4 | for i in s: 5 | if i not in hasht: 6 | hasht.add(i) 7 | else: 8 | hasht.remove(i) 9 | return len(s) - len(hasht) + 1 if len(hasht) > 1 else len(s) -------------------------------------------------------------------------------- /LongestUncommonSubsequenceI/LongestUncommonSubsequenceI.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findLUSlength(self, a: str, b: str) -> int: 3 | if a == b: return -1 4 | return max(len(a), len(b)) 5 | 6 | 7 | class Solution: 8 | def findLUSlength(self, a: str, b: str) -> int: 9 | if a == b: return -1 10 | l=[a[i:] for i in range(len(a))] 11 | for i in l: 12 | if i != b: 13 | return len(i) if len(i)>len(b) else len(b) -------------------------------------------------------------------------------- /MakeTheStringGreat/MakeTheStringGreat.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def makeGood(self, s: str) -> str: 3 | i = 0 4 | while i < len(s)-1: 5 | if s[i] == s[i+1]: 6 | i += 1 7 | elif s[i].lower() == s[i+1] or s[i].upper() == s[i+1]: 8 | s = s[:i] + s[i+2:] 9 | i = 0 10 | else: 11 | i += 1 12 | return s -------------------------------------------------------------------------------- /MakeTwoArraysEqualByReversingSubarrays/MakeTwoArraysEqualByReversingSubarrays.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def canBeEqual(self, target: List[int], arr: List[int]) -> bool: 3 | target.sort() 4 | arr.sort() 5 | if target == arr: 6 | return True 7 | return False 8 | 9 | 10 | class Solution: 11 | def canBeEqual(self, target: List[int], arr: List[int]) -> bool: 12 | return sorted(target) == sorted(arr) 13 | 14 | 15 | class Solution: 16 | def canBeEqual(self, target: List[int], arr: List[int]) -> bool: 17 | for i in target: 18 | if (i not in arr) or (arr.count(i) != target.count(i)): 19 | return False 20 | return True -------------------------------------------------------------------------------- /MatrixCellsInDistanceOrder/MatrixCellsInDistanceOrder.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def allCellsDistOrder(self, rows: int, cols: int, rCenter: int, cCenter: int) -> List[List[int]]: 3 | arr = [] 4 | for i in range(rows): 5 | for j in range(cols): 6 | arr.append([i, j]) 7 | arr = sorted(arr, key=lambda x: abs(x[0]-rCenter) + abs(x[1]-cCenter)) 8 | return arr -------------------------------------------------------------------------------- /MaxConsecutiveOnes/MaxConOne.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var findMaxConsecutiveOnes = function (nums) { 6 | let maxim = 0; 7 | let count = 0; 8 | for (let i of nums) { 9 | if (i == 1) { 10 | count++; 11 | } else { 12 | maxim = Math.max(count, maxim); 13 | count = 0; 14 | } 15 | } 16 | return Math.max(count, maxim); 17 | }; 18 | -------------------------------------------------------------------------------- /MaxConsecutiveOnes/MaxConOne.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findMaxConsecutiveOnes(self, nums: List[int]) -> int: 3 | maxim = 0 4 | count = 0 5 | for i in nums: 6 | if i == 1: 7 | count+=1 8 | else: 9 | maxim = max(count, maxim) 10 | count = 0 11 | return max(count, maxim) -------------------------------------------------------------------------------- /MaximizeSumOfArrayAfterKNegations/MaximizeSumOfArrayAfterKNegations.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def largestSumAfterKNegations(self, nums: List[int], k: int) -> int: 3 | while k: 4 | nums.sort() 5 | nums[0] = - nums[0] 6 | k = k - 1 7 | return sum(nums) -------------------------------------------------------------------------------- /Maximum69Number/Maximum69Number.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maximum69Number (self, num: int) -> int: 3 | return str(num).replace('6', '9', 1) -------------------------------------------------------------------------------- /MaximumAverageSubarrayI/MaxAverSubArrI.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {number} 5 | */ 6 | var findMaxAverage = function (nums, k) { 7 | let sum = 0; 8 | for (let i = 0; i < k; i++) { 9 | sum += nums[i]; 10 | } 11 | let max = sum; 12 | for (let i = k; i < nums.length; i++) { 13 | sum = sum - nums[i - k] + nums[i]; 14 | max = Math.max(max, sum); 15 | } 16 | return max / k; 17 | }; 18 | -------------------------------------------------------------------------------- /MaximumAverageSubarrayI/MaxAverSubArrI.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findMaxAverage(self, nums: List[int], k: int) -> float: 3 | g = sum(nums[:k]) 4 | m = g 5 | for i in range(len(nums) - k): 6 | g = g - nums[i] + nums[i + k] 7 | m = max(m, g) 8 | return m / k -------------------------------------------------------------------------------- /MaximumDepthOfBinaryTree/MaximumDepthOfBinaryTree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def maxDepth(self, root: Optional[TreeNode]) -> int: 9 | def dfs(root, depth): 10 | if not root: 11 | return depth 12 | return max(dfs(root.left, depth + 1), dfs(root.right, depth + 1)) 13 | return dfs(root, 0) -------------------------------------------------------------------------------- /MaximumProductDifferenceBetweenTwoPairs/MaximumProductDifferenceBetweenTwoPairs.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxProductDifference(self, nums: List[int]) -> int: 3 | nums = sorted(nums) 4 | w, x, y, z = nums[-1], nums[-2], nums[0], nums[1] 5 | return (w * x) - (y * z) -------------------------------------------------------------------------------- /MaximumProductOfThreeNumbers/MaxProdOfThreeNum.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var maximumProduct = function (nums) { 6 | nums = nums.sort((a, b) => b - a); 7 | return Math.max( 8 | nums[0] * nums[1] * nums[2], 9 | nums[nums.length - 1] * nums[nums.length - 2] * nums[0] 10 | ); 11 | }; 12 | -------------------------------------------------------------------------------- /MaximumProductOfThreeNumbers/MaxProdOfThreeNum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maximumProduct(self, nums: List[int]) -> int: 3 | nums.sort() 4 | return max(nums[0]*nums[1]*nums[-1], nums[-3]*nums[-2]*nums[-1]) -------------------------------------------------------------------------------- /MaximumProductOfTwoElementsInAnArray/MaximumProductOfTwoElementsInAnArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxProduct(self, nums: List[int]) -> int: 3 | nums = sorted(nums, reverse = True) 4 | return (nums[0]-1)*(nums[1]-1) -------------------------------------------------------------------------------- /MaximumSubarray/MaxSubArr.js: -------------------------------------------------------------------------------- 1 | // Метод Math.max() возвращает наибольшее из нуля или более чисел. 2 | var maxSubArray = function(nums) { 3 | // Переменная для максимального подмассива, 0 потому что идет с начала и массив точно не пустой 4 | let maxSubArr = nums[0] 5 | // Цикл для итераций массива 6 | for (let i = 1; i < nums.length; i++) { 7 | // Переменная для наибольшего числа из подмассивов с первого и последнего индекса 8 | nums[i] = Math.max(nums[i], nums[i] + nums[i-1]) 9 | // Максимальный подмассив 10 | maxSubArr = Math.max(maxSubArr, nums[i]); 11 | } 12 | // Возврат по условию 13 | return maxSubArr 14 | }; 15 | -------------------------------------------------------------------------------- /MaximumUnitsOnTruck/MaximumUnitsOnTruck.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maximumUnits(self, boxTypes: List[List[int]], truckSize: int) -> int: 3 | boxTypes.sort(key= lambda x: x[1], reverse=True) 4 | i=0 5 | unit_count=0 6 | while i < len(boxTypes) and truckSize > 0 : 7 | unit_count += min(boxTypes[i][0],truckSize)*boxTypes[i][1] 8 | truckSize -= boxTypes[i][0] 9 | i += 1 10 | return unit_count 11 | -------------------------------------------------------------------------------- /MeanOfArrayAfterRemovingSomeElements/MeanOfArrayAfterRemovingSomeElements.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def trimMean(self, arr: List[int]) -> float: 3 | arr = sorted(arr) 4 | x = int(0.05*len(arr)) 5 | arr = arr[x:] 6 | arr = arr[:-x] 7 | return sum(arr)/len(arr) -------------------------------------------------------------------------------- /MergeTwoSortedLists/Merge.js: -------------------------------------------------------------------------------- 1 | // ! Рекурсия 2 | var mergeTwoLists = function (l1, l2) { 3 | if (l1 == null) return l2; 4 | if (l2 == null) return l1; 5 | if (l1.val < l2.val) { 6 | l1.next = mergeTwoLists(l1.next, l2); 7 | return l1; 8 | } 9 | else { 10 | l2.next = mergeTwoLists(l1, l2.next); 11 | return l2; 12 | } 13 | }; -------------------------------------------------------------------------------- /MinimumAbsoluteDifference/MinimumAbsoluteDifference.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minimumAbsDifference(self, arr: List[int]) -> List[List[int]]: 3 | arr.sort() 4 | 5 | result = [] 6 | min_diff = float("inf") 7 | 8 | for i in range(len(arr) - 1): 9 | diff = abs(arr[i+1] - arr[i]) 10 | 11 | if diff < min_diff: 12 | min_diff = diff 13 | result.clear() 14 | 15 | if diff == min_diff: 16 | result.append((arr[i], arr[i+1])) 17 | 18 | return result -------------------------------------------------------------------------------- /MinimumDifferenceBetweenHighestAndLowest0fKScores/MinimumDifferenceBetweenHighestAndLowestOfKScores.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minimumDifference(self, nums: List[int], k: int) -> int: 3 | nums = sorted(nums) 4 | if len(nums) == 1: return 0 5 | res = nums[k - 1] - nums[0] 6 | for i in range(k, len(nums)): 7 | res = min(res, nums[i] - nums[i - k + 1]) 8 | return res -------------------------------------------------------------------------------- /MinimumIndexSumOfTwoLists/MinIndSumOfTwoLists.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} list1 3 | * @param {string[]} list2 4 | * @return {string[]} 5 | */ 6 | var findRestaurant = function (list1, list2) { 7 | const map = new Map(); 8 | let ret = []; 9 | let min = Infinity; 10 | for (let i = 0; i < list1.length; ++i) { 11 | map.set(list1[i], i); 12 | } 13 | for (let i = 0; i < list2.length; ++i) { 14 | if (map.has(list2[i])) { 15 | let index1 = map.get(list2[i]); 16 | let index2 = i; 17 | ret.push({ val: list2[i], index: index1 + index2 }); 18 | min = Math.min(min, index1 + index2); 19 | } 20 | } 21 | return ret.filter((item) => item.index === min).map((item) => item.val); 22 | }; 23 | -------------------------------------------------------------------------------- /MinimumIndexSumOfTwoLists/MinIndSumOfTwoLists.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findRestaurant(self, list1: List[str], list2: List[str]) -> List[str]: 3 | hasht = set(list1) & set(list2) 4 | res = {} 5 | for i in hasht: 6 | sumIndex = list1.index(i) + list2.index(i) 7 | res[i] = sumIndex 8 | temp = min(res.values()) 9 | return [key for key in res if res[key] == temp] -------------------------------------------------------------------------------- /MinimumNumberOfRefuelingStops/MinimumNumberOfRefuelingStops.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minRefuelStops(self, target: int, startFuel: int, stations: List[List[int]]) -> int: 3 | stations.append([target, 0]) 4 | fuel = startFuel 5 | cnt, prev = 0, 0 6 | miss = [] 7 | 8 | for pos, gas in stations: 9 | dis, prev = pos - prev, pos 10 | if fuel < dis: 11 | while miss and fuel < dis: 12 | fuel += -heapq.heappop(miss) 13 | cnt += 1 14 | if fuel < dis: 15 | return -1 16 | fuel -= dis 17 | # Метод кучи 18 | heapq.heappush(miss, -gas) 19 | 20 | return cnt -------------------------------------------------------------------------------- /MinimumOperationsToMakeArrayEqual/MinimumOperationsToMakeArrayEqual.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minOperations(self, n: int) -> int: 3 | return ((n + 1) // 2) * (n // 2) -------------------------------------------------------------------------------- /MinimumSubsequenceInNon-IncreasingOrder/MinimumSubsequenceInNon-IncreasingOrder.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minSubsequence(self, nums: List[int]) -> List[int]: 3 | nums.sort(reverse=True) 4 | total, rem = 0, sum(nums) 5 | for i in range(len(nums)): 6 | total += nums[i] 7 | rem -= nums[i] 8 | if total > rem: 9 | return nums[:i + 1] -------------------------------------------------------------------------------- /MostCommonWord/MostCommonWord.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def mostCommonWord(self, paragraph: str, banned: List[str]) -> str: 3 | # re-sub -> Возвращает новую строку, полученную в результате замены по указанному шаблону. 4 | paragraph=re.sub(r'[,.!?;\']',' ',paragraph) 5 | paragraph=paragraph.lower() 6 | a=paragraph.split() 7 | count=0 8 | word="" 9 | for i in list(set(a)): 10 | if a.count(i)>count and i not in banned: 11 | count=a.count(i) 12 | word=i 13 | return word -------------------------------------------------------------------------------- /MoveZeroes/MoveZeroes.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {void} Do not return anything, modify nums in-place instead. 4 | */ 5 | var moveZeroes = function (nums) { 6 | for (let i = nums.length; i--; ) { 7 | if (nums[i] === 0) { 8 | nums.splice(i, 1) && nums.push(0); 9 | } 10 | } 11 | }; 12 | 13 | 14 | /** 15 | * @param {number[]} nums 16 | * @return {void} Do not return anything, modify nums in-place instead. 17 | */ 18 | var moveZeroes = function (nums) { 19 | let index = 0; 20 | for(let i=0; i < nums.length; i++){ 21 | if(nums[i] != 0) { 22 | nums[index] = nums[i]; 23 | index ++; 24 | } 25 | } 26 | for(let j = index; j < nums.length; j++) { 27 | nums[j] = 0; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /MoveZeroes/MoveZeroes.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def moveZeroes(self, nums: List[int]) -> None: 3 | """ 4 | Do not return anything, modify nums in-place instead. 5 | """ 6 | l = len(nums) 7 | i = 0 8 | while i < l: 9 | if nums[i] == 0: 10 | nums.append(nums.pop(i)) 11 | l -= 1 12 | else: 13 | i += 1 14 | return nums 15 | 16 | 17 | class Solution: 18 | def moveZeroes(self, nums: List[int]) -> None: 19 | """ 20 | Do not return anything, modify nums in-place instead. 21 | """ 22 | for i in nums: 23 | if i == 0: 24 | nums.remove(i) 25 | nums.append(i) -------------------------------------------------------------------------------- /MyCalendarI/MyCalendarI.py: -------------------------------------------------------------------------------- 1 | class MyCalendar: 2 | 3 | def __init__(self): 4 | self.arr = [] 5 | 6 | def book(self, start: int, end: int) -> bool: 7 | if end < start: 8 | return False 9 | 10 | i = bisect.bisect_right(self.arr, start) 11 | if i % 2: 12 | return False 13 | 14 | j = bisect.bisect_left(self.arr, end) 15 | if i != j: 16 | return False 17 | 18 | self.arr[i:i] = [start, end] 19 | return True 20 | 21 | 22 | # Your MyCalendar object will be instantiated and called as such: 23 | # obj = MyCalendar() 24 | # param_1 = obj.book(start,end) -------------------------------------------------------------------------------- /N-RepeatedElementInSize2NArray/N-RepeatedElementInSize2NArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def repeatedNTimes(self, nums: List[int]) -> int: 3 | for i in nums: 4 | if nums.count(i) > 1: 5 | return i 6 | 7 | 8 | class Solution: 9 | def repeatedNTimes(self, nums: List[int]) -> int: 10 | d={} 11 | res=0 12 | c=0 13 | for i in nums: 14 | d[i]=1+d.get(i,0) 15 | res=max(d[i],res) 16 | if res==d[i]: 17 | c=i 18 | return c -------------------------------------------------------------------------------- /NextGreaterElementI/NextGreatEl.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums1 3 | * @param {number[]} nums2 4 | * @return {number[]} 5 | */ 6 | var nextGreaterElement = function (nums1, nums2) { 7 | return nums1.map((n) => { 8 | let next = nums2.indexOf(n) + 1; 9 | while (next < nums2.length && nums2[next] < n) { 10 | next++; 11 | } 12 | return next >= nums2.length ? -1 : nums2[next]; 13 | }); 14 | }; 15 | -------------------------------------------------------------------------------- /NextGreaterElementI/NextGreatEl.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]: 3 | output = [] 4 | for n in nums1: 5 | idx = nums2.index(n) 6 | for m in nums2[idx+1:]: 7 | if m > n: 8 | output.append(m) 9 | break 10 | else: 11 | output.append(-1) 12 | return output -------------------------------------------------------------------------------- /NimGame/NimGame.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def canWinNim(self, n: int) -> bool: 3 | return n % 4 -------------------------------------------------------------------------------- /NotBoringMovies/NotBoringMovies.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT * 4 | FROM Cinema 5 | -- MOD в oracle возвращает остаток от деления 6 | WHERE mod(id,2) != 0 7 | AND description != 'boring' 8 | ORDER BY rating desc; -------------------------------------------------------------------------------- /NumberOfCommonFactors/NumberOfCommonFactors.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def commonFactors(self, a: int, b: int) -> int: 3 | count = 0 4 | for x in range(1, min(a, b) + 1): 5 | if a % x == 0 and b % x == 0: 6 | count += 1 7 | return count -------------------------------------------------------------------------------- /NumberOfGoodPairs/NumberOfGoodPairs.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numIdenticalPairs(self, nums: List[int]) -> int: 3 | count = 0 4 | hashmap = {} 5 | for i in nums: 6 | if i in hashmap: 7 | count += hashmap[i] 8 | hashmap[i] += 1 9 | else: 10 | hashmap[i] = 1 11 | return count -------------------------------------------------------------------------------- /NumberOfIslands/NumberOfIslands.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numIslands(self, grid: List[List[str]]) -> int: 3 | if not grid: return 0 4 | def dfs(grid, i, j): 5 | if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]) or grid[i][j] != "1": return 6 | grid[i][j] = '#' 7 | dfs(grid, i+1, j) 8 | dfs(grid, i-1, j) 9 | dfs(grid, i, j+1) 10 | dfs(grid, i, j-1) 11 | count = 0 12 | for i in range(len(grid)): 13 | for j in range(len(grid[0])): 14 | if grid[i][j] == "1": 15 | dfs(grid, i, j) 16 | count += 1 17 | return count -------------------------------------------------------------------------------- /NumberOfLinesToWriteString/NumberOfLinesToWriteString.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numberOfLines(self, widths: List[int], s: str) -> List[int]: 3 | newLine = 1 4 | width = 0 5 | for char in s: 6 | charWidth = widths[ord(char) - ord('a')] 7 | if charWidth + width > 100: 8 | newLine += 1 9 | width = 0 10 | width += charWidth 11 | return [newLine, width] -------------------------------------------------------------------------------- /NumberOfSegmentsInString/NumOfSegInStr.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def countSegments(self, s: str) -> int: 3 | return len(s.split()) 4 | 5 | 6 | class Solution: 7 | def countSegments(self, s: str) -> int: 8 | return len([i for i in s.split(" ") if i!=""]) 9 | 10 | 11 | class Solution: 12 | def countSegments(self, s: str) -> int: 13 | word=0 14 | count=True 15 | for i in range(0,len(s)): 16 | if s[i]!=" " and count==True: 17 | word+=1 18 | count=False 19 | if s[i]==" ": 20 | count=True 21 | return word -------------------------------------------------------------------------------- /NumberOfSegmentsInString/NumOfSenInStr.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {number} 4 | */ 5 | var countSegments = function (s) { 6 | return s.split(" ").filter((x) => x !== "").length; 7 | }; 8 | 9 | 10 | /** 11 | * @param {string} s 12 | * @return {number} 13 | */ 14 | var countSegments = function (s) { 15 | let a = s.split(" "); 16 | let count = 0; 17 | for (i = 0; i < a.length; i++) { 18 | if (a[i] != "") { 19 | count++; 20 | } 21 | } 22 | return count; 23 | }; 24 | -------------------------------------------------------------------------------- /OnlineStockSpan/OnlineStockSpan.py: -------------------------------------------------------------------------------- 1 | class StockSpanner: 2 | 3 | def __init__(self): 4 | self.arr = [] 5 | self.lst = [] 6 | 7 | def next(self, price: int) -> int: 8 | if self.arr == []: 9 | self.arr.append(price) 10 | self.lst.append(1) 11 | return 1 12 | 13 | count = 1 14 | while self.arr: 15 | if self.arr[-1] <= price: 16 | count += self.lst.pop() 17 | self.arr.pop() 18 | else: 19 | break 20 | 21 | self.arr.append(price) 22 | self.lst.append(count) 23 | return count 24 | 25 | # Your StockSpanner object will be instantiated and called as such: 26 | # obj = StockSpanner() 27 | # param_1 = obj.next(price) -------------------------------------------------------------------------------- /PalindromeNumber/Palindrome.py: -------------------------------------------------------------------------------- 1 | # ! Полиндром для числа 2 | class Solution: 3 | def isPalindrome(self, x: int) -> bool: 4 | temp=x 5 | rev=0 6 | while(x>0): 7 | dig=x%10 8 | rev=rev*10+dig 9 | x=x//10 10 | if(temp==rev): 11 | return True 12 | else: 13 | return False 14 | 15 | 16 | # ! Палиндром для строки 17 | string=input(("Enter a string:")) 18 | if(string==string[::-1]): 19 | print("The string is a palindrome") 20 | else: 21 | print("Not a palindrome") -------------------------------------------------------------------------------- /PartitioningIntoMinimumNumberOfDeci-BinaryNumbers/PartitioningIntoMinimumNumberOfDeci-BinaryNumbers.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minPartitions(self, n: str) -> int: 3 | # return max(n) 4 | 5 | n = list(n) 6 | for i in range(len(n)): 7 | n[i] = int(n[i]) 8 | return max(n) -------------------------------------------------------------------------------- /PascalsTriangle/PasTri.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} numRows 3 | * @return {number[][]} 4 | */ 5 | var generate = function (numRows) { 6 | let res = []; 7 | for (let i = 0; i < numRows; i++) { 8 | res[i] = []; 9 | res[i][0] = res[i][i] = 1; 10 | for (let j = 1; j < i; j++) { 11 | res[i][j] = res[i - 1][j] + res[i - 1][j - 1]; 12 | } 13 | } 14 | return res; 15 | }; 16 | -------------------------------------------------------------------------------- /PascalsTriangle/PasTri.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def generate(self, numRows: int) -> List[List[int]]: 3 | res = [[1]] 4 | for i in range(numRows - 1): 5 | temp = [0] + res[-1] + [0] 6 | row = [] 7 | for j in range(len(res[-1]) + 1): 8 | row.append(temp[j] + temp[j + 1]) 9 | res.append(row) 10 | return res -------------------------------------------------------------------------------- /PascalsTriangleII(2)/PasTriTwo.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} rowIndex 3 | * @return {number[]} 4 | */ 5 | var getRow = function (rowIndex) { 6 | let res = []; 7 | for (let i = 0; i <= rowIndex; i++) { 8 | res.unshift(1); 9 | for (let j = 1; j < i; j++) { 10 | res[j] += res[j + 1]; 11 | } 12 | } 13 | return res; 14 | }; 15 | -------------------------------------------------------------------------------- /PascalsTriangleII(2)/PasTriTwo.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def getRow(self, rowIndex: int) -> List[int]: 3 | result = [1]*(rowIndex + 1) 4 | for i in range(1, rowIndex): 5 | for j in range(i, 0, -1): 6 | result[j] += result[j-1] 7 | return result 8 | 9 | 10 | # ! Solution 2 11 | class Solution: 12 | def getRow(self, rowIndex): 13 | row = [1] 14 | for _ in range(rowIndex): 15 | row = [x + y for x, y in zip([0]+row, row+[0])] 16 | return row -------------------------------------------------------------------------------- /PathSum/PathSum.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool: 9 | if root is None: 10 | return False 11 | 12 | sum_ = targetSum - root.val 13 | 14 | if sum_ == 0 and root.right == None and root.left == None: 15 | return True 16 | 17 | if self.hasPathSum(root.left, sum_): return True 18 | if self.hasPathSum(root.right, sum_): return True 19 | 20 | return False -------------------------------------------------------------------------------- /Permutations/Permutations.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def permute(self, nums: List[int]) -> List[List[int]]: 3 | def recursive(nums, perm=[], res=[]): 4 | if not nums: 5 | res.append(perm[::]) 6 | for i in range(len(nums)): 7 | newNums = nums[:i] + nums[i+1:] 8 | perm.append(nums[i]) 9 | recursive(newNums, perm, res) 10 | perm.pop() 11 | return res 12 | return recursive(nums) -------------------------------------------------------------------------------- /PermutationsII/PermutationsII.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def permuteUnique(self, nums: List[int]) -> List[List[int]]: 3 | arr = [] 4 | def recursive(pointer): 5 | if pointer == len(nums): 6 | arr.append(nums[:]) 7 | return 8 | hasht = set() 9 | for i in range(pointer, len(nums)): 10 | if nums[i] not in hasht: 11 | hasht.add(nums[i]) 12 | nums[i], nums[pointer] = nums[pointer], nums[i] 13 | recursive(pointer + 1) 14 | nums[i], nums[pointer] = nums[pointer], nums[i] 15 | recursive(0) 16 | return arr -------------------------------------------------------------------------------- /PoorPigs/PoorPigs.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def poorPigs(self, buckets: int, minutesToDie: int, minutesToTest: int) -> int: 3 | minimum = 0 4 | while (minutesToTest / minutesToDie + 1) ** minimum < buckets: 5 | minimum += 1 6 | return minimum 7 | 8 | 9 | class Solution: 10 | def poorPigs(self, buckets: int, minutesToDie: int, minutesToTest: int) -> int: 11 | return ceil(log(buckets)/log(minutesToTest//minutesToDie + 1)) -------------------------------------------------------------------------------- /PowerOfFour/PowerOfFour.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isPowerOfFour(self, n: int) -> bool: 3 | if n & n - 1 == 0 and n % 10 in (1,4,6): 4 | return True 5 | return False -------------------------------------------------------------------------------- /PowerOfThree/PowerOfThree.py: -------------------------------------------------------------------------------- 1 | # Recursion 2 | 3 | class Solution: 4 | def isPowerOfThree(self, n: int) -> bool: 5 | while n % 3 == 0 and n > 0: 6 | return self.isPowerOfThree(n / 3) 7 | return n == 1 8 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # MorgLeetCode 2 | 3 | Training for myself 4 | 5 | ![image](https://user-images.githubusercontent.com/88595595/173184083-da10a9f4-520d-4293-82b3-7e1af2244d3b.png) 6 | -------------------------------------------------------------------------------- /RangeAdditionII/RangeAddition.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} m 3 | * @param {number} n 4 | * @param {number[][]} ops 5 | * @return {number} 6 | */ 7 | var maxCount = function (m, n, ops) { 8 | let len = ops.length; 9 | if (len === 0) return m * n; 10 | let result = [ops[0][0], ops[0][1]]; 11 | for (let i = 1; i < len; i++) { 12 | result[0] = Math.min(result[0], ops[i][0]); 13 | result[1] = Math.min(result[1], ops[i][1]); 14 | } 15 | return result[0] * result[1]; 16 | }; 17 | -------------------------------------------------------------------------------- /RangeAdditionII/RangeAdditionII.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxCount(self, m: int, n: int, ops: List[List[int]]) -> int: 3 | length = len(ops) 4 | if length == 0: 5 | return m*n 6 | result = [ops[0][0], ops[0][1]] 7 | for i in range(1, length): 8 | result[0] = min(result[0], ops[i][0]) 9 | result[1] = min(result[1], ops[i][1]) 10 | return result[0] * result[1] 11 | -------------------------------------------------------------------------------- /RangeSumQuery/RanSumQue.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | */ 4 | var NumArray = function (nums) { 5 | this.arr = []; 6 | this.arr[0] = 0; 7 | for (let num = 1; num <= nums.length; num++) { 8 | this.arr[num] = this.arr[num - 1] + nums[num - 1]; 9 | } 10 | }; 11 | 12 | /** 13 | * @param {number} left 14 | * @param {number} right 15 | * @return {number} 16 | */ 17 | NumArray.prototype.sumRange = function (left, right) { 18 | return this.arr[right + 1] - this.arr[left]; 19 | }; 20 | 21 | /** 22 | * Your NumArray object will be instantiated and called as such: 23 | * var obj = new NumArray(nums) 24 | * var param_1 = obj.sumRange(left,right) 25 | */ 26 | 27 | 28 | -------------------------------------------------------------------------------- /RankTransformOfAnArray/RankTransformOfAnArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def arrayRankTransform(self, arr: List[int]) -> List[int]: 3 | rank = 1 4 | ranklst = list() 5 | sortedarr = sorted(arr) 6 | dic = dict() 7 | if len(arr) == 0: 8 | return [] 9 | dic[sortedarr[0]] = 1 10 | for i in range(1, len(sortedarr)): 11 | if sortedarr[i] != sortedarr[i-1]: 12 | rank += 1 13 | dic[sortedarr[i]] = rank 14 | for num in arr: 15 | ranklst.append(dic[num]) 16 | return ranklst -------------------------------------------------------------------------------- /RansomNote/RansomNote.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} ransomNote 3 | * @param {string} magazine 4 | * @return {boolean} 5 | */ 6 | var canConstruct = function (ransomNote, magazine) { 7 | const map = {}; 8 | for (let letter of magazine) { 9 | if (!map[letter]) { 10 | map[letter] = 0; 11 | } 12 | map[letter]++; 13 | } 14 | for (let letter of ransomNote) { 15 | if (!map[letter]) { 16 | return false; 17 | } 18 | map[letter]--; 19 | } 20 | return true; 21 | }; 22 | -------------------------------------------------------------------------------- /RearrangeArrayElementsBySign/RearrangeArrayElementsBySign.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def rearrangeArray(self, nums: List[int]) -> List[int]: 3 | pos, neg, res = [], [], [] 4 | for i in nums: 5 | if i > 0: 6 | pos.append(i) 7 | else: 8 | neg.append(i) 9 | for i in range(0, len(neg)): 10 | res.append(pos[i]) 11 | res.append(neg[i]) 12 | return res -------------------------------------------------------------------------------- /RecyclableAndLowFatProducts/RecyclableAndLowFatProducts.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT product_id 4 | FROM products 5 | WHERE low_fats = 'Y' AND recyclable = 'Y'; 6 | -------------------------------------------------------------------------------- /ReduceArraySizeToTheHalf/ReduceArraySizeToTheHalf.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def minSetSize(self, arr: List[int]) -> int: 3 | dict_ = {} 4 | for i in arr: 5 | if i not in dict_: 6 | dict_[i] = 1 7 | else: 8 | dict_[i] += 1 9 | list_ = sorted(dict_.values()) 10 | length = len(arr) // 2 11 | res = 0 12 | while length > 0: 13 | length -= list_[-res-1] 14 | res += 1 15 | return res 16 | -------------------------------------------------------------------------------- /RelativeRanks/RelativeRanks.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} score 3 | * @return {string[]} 4 | */ 5 | var findRelativeRanks = function (score) { 6 | let ranks = score.slice(0).sort((a, b) => b - a); 7 | return score.map((num, i) => { 8 | if (num === ranks[0]) return "Gold Medal"; 9 | else if (num === ranks[1]) return "Silver Medal"; 10 | else if (num === ranks[2]) return "Bronze Medal"; 11 | else return (ranks.indexOf(num) + 1).toString(); 12 | }); 13 | }; 14 | -------------------------------------------------------------------------------- /RelativeRanks/RelativeRanks.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findRelativeRanks(self, score: List[int]) -> List[str]: 3 | arr = sorted(score, reverse=True) 4 | l = len(arr) 5 | dict_ = {} 6 | dict_[arr[0]] = "Gold Medal" 7 | if l > 1: 8 | dict_[arr[1]] = "Silver Medal" 9 | if l > 2: 10 | dict_[arr[2]] = "Bronze Medal" 11 | for i in range(3, len(arr)): 12 | dict_[arr[i]] = str(i + 1) 13 | answer = [dict_[k] for k in score] 14 | return answer 15 | 16 | -------------------------------------------------------------------------------- /RelativeSortArray/RelativeSortArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def relativeSortArray(self, arr1: List[int], arr2: List[int]) -> List[int]: 3 | l1 = [] 4 | l2 = [] 5 | for i in arr2: 6 | for j in range(arr1.count(i)): 7 | l1.append(i) 8 | for x in arr1: 9 | if x not in l1: 10 | l2.append(x) 11 | l2.sort() 12 | return l1 + l2 -------------------------------------------------------------------------------- /RemoveDublicates/RemDub.js: -------------------------------------------------------------------------------- 1 | var removeDuplicates = function(nums) { 2 | // Cоздаю переменную для сравнения 3 | let i = 0 4 | // Создаю цикл и новую вторую переменную для сравнения элементов в массиве 5 | for (let j = 1; j < nums.length; j++) { 6 | // Если элементы не равны, то передвигаю первый вперед по итерации 7 | if (nums[j] !== nums[i]) { 8 | i+=1 9 | // Ставлю их вместе 10 | nums[i] = nums[j] 11 | } 12 | } 13 | return i + 1 14 | }; -------------------------------------------------------------------------------- /RemoveDublicatesFromSortedList/RemDubSortList.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * function ListNode(val, next) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.next = (next===undefined ? null : next) 6 | * } 7 | */ 8 | /** 9 | * @param {ListNode} head 10 | * @return {ListNode} 11 | */ 12 | var deleteDuplicates = function (head) { 13 | let curr = head; 14 | while (curr && curr.next) { 15 | if (curr && curr.next && curr.val === curr.next.val) { 16 | curr.next = curr.next.next; 17 | } else if (curr && curr.next && curr.val !== curr.next.val) { 18 | curr = curr.next; 19 | } 20 | } 21 | return head; 22 | }; 23 | -------------------------------------------------------------------------------- /RemoveDublicatesFromSortedList/RemDubSortList.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, val=0, next=None): 4 | # self.val = val 5 | # self.next = next 6 | class Solution: 7 | def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]: 8 | curr = head 9 | while curr and curr.next: 10 | if (curr and curr.next) and curr.val == curr.next.val: 11 | curr.next = curr.next.next 12 | if (curr and curr.next) and curr.val != curr.next.val: 13 | curr = curr.next 14 | return head -------------------------------------------------------------------------------- /RemoveDuplicatesFromSortedArrayII/RemoveDuplicatesFromSortedArrayII.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def removeDuplicates(self, nums: List[int]) -> int: 3 | count = 0 4 | for i in nums: 5 | if count < 2 or i != nums[count - 2]: 6 | nums[count] = i 7 | count += 1 8 | return count -------------------------------------------------------------------------------- /RemoveElement/RemoveElement.js: -------------------------------------------------------------------------------- 1 | var removeElement = function(nums, val) { 2 | // Создаю переменную для сравнения в массиве 3 | let j = 0; 4 | // Цикл для итераций и еще одна переменная 5 | for (let i = 0; i < nums.length; i++) { 6 | // Если переменная i не равна заданному значению, то 7 | if (nums[i] !== val) { 8 | // Инкремент приравниваю к элементу в массиве 9 | nums[j++] = nums[i]; 10 | } 11 | } 12 | // Возвращаю длину единственных чисел 13 | return j; 14 | }; -------------------------------------------------------------------------------- /RemoveElement/RemoveElement.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def removeElement(self, nums: List[int], val: int) -> int: 3 | # Переменная для проверки 4 | i = 0 5 | # Цикл для итераций 6 | while i < len(nums): 7 | # Условие, если i равно заданному значению val, то оно удаляется из списка 8 | if nums[i] == val: nums.pop(i) 9 | # Либо инкрементация элемента 10 | else: i += 1 11 | # По условию возвращаю длину мутированного списка 12 | return len(nums) 13 | -------------------------------------------------------------------------------- /ReorderedPowerOf2/ReorderedPowerOf2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reorderedPowerOf2(self, n: int) -> bool: 3 | length = len(str(n)) 4 | c = sorted(str(n)) 5 | for i in range((length-1) * 3 + length // 3, length * 3 + length // 3 + 1): 6 | if c == sorted(str(1 << i)): 7 | return True 8 | return False -------------------------------------------------------------------------------- /RepeatedSubstringPattern/RepeatedSubstringPattern.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {boolean} 4 | */ 5 | var repeatedSubstringPattern = function (s) { 6 | return s.repeat(2).slice(1, -1).includes(s); 7 | }; 8 | 9 | 10 | /** 11 | * @param {string} s 12 | * @return {boolean} 13 | */ 14 | var repeatedSubstringPattern = function (s) { 15 | let pattern = ""; 16 | for (let i = 0; i < Math.floor(s.length / 2); i++) { 17 | pattern += s[i]; 18 | if (pattern.repeat(s.length / pattern.length) === s) return true; 19 | } 20 | return false; 21 | }; 22 | -------------------------------------------------------------------------------- /RepeatedSubstringPattern/RepeatedSubstringPattern.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def repeatedSubstringPattern(self, s: str) -> bool: 3 | return s in (s + s)[1 : -1] 4 | 5 | 6 | class Solution: 7 | def repeatedSubstringPattern(self, s: str) -> bool: 8 | length = len(s) 9 | for i in range(1, length // 2 + 1): 10 | if length % i == 0 and s[:i] * (length // i) == s: 11 | return True 12 | return False 13 | -------------------------------------------------------------------------------- /ReserveStringII/ReserveStringII.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverseStr(self, s: str, k: int) -> str: 3 | s = [s[i:i+k] for i in range(0, len(s), k)] 4 | for i in range(0, len(s), 2): 5 | s[i] = s[i][::-1] 6 | return "".join(s) -------------------------------------------------------------------------------- /ReshapeTheMatrix/ReshTheMat.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} mat 3 | * @param {number} r 4 | * @param {number} c 5 | * @return {number[][]} 6 | */ 7 | var matrixReshape = function (mat, r, c) { 8 | let arr = mat.flat(); 9 | if (r * c != arr.length) return mat; 10 | let res = []; 11 | while (arr.length) res.push(arr.splice(0, c)); 12 | return res; 13 | }; 14 | -------------------------------------------------------------------------------- /ReshapeTheMatrix/ReshTheMat.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]: 3 | m, n = len(mat), len(mat[0]) 4 | if r * c != m * n: 5 | return mat 6 | res = [[0] * c for k in range(r)] 7 | for i in range(m * n): 8 | res[i // c][i % c] = mat[i // n][i % n] 9 | return res -------------------------------------------------------------------------------- /ReverseLinkedList/ReverseLinkedList.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * function ListNode(val, next) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.next = (next===undefined ? null : next) 6 | * } 7 | */ 8 | /** 9 | * @param {ListNode} head 10 | * @return {ListNode} 11 | */ 12 | var reverseList = function (head) { 13 | if (!head || !head.next) { 14 | return head; 15 | } 16 | let newHead = reverseList(head.next); 17 | head.next.next = head; 18 | head.next = null; 19 | return newHead; 20 | }; 21 | -------------------------------------------------------------------------------- /ReverseVowelsOfaString/ReverseVowels.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {string} 4 | */ 5 | var reverseVowels = function (s) { 6 | let vowels = ["a", "A", "e", "E", "i", "I", "o", "O", "u", "U"]; 7 | let stack = []; 8 | for (let i = 0; i < s.length; i++) { 9 | if (vowels.indexOf(s[i]) !== -1) { 10 | stack.push(s[i]); 11 | } 12 | } 13 | let ans = []; 14 | for (let i = 0; i < s.length; i++) { 15 | if (vowels.indexOf(s[i]) !== -1) { 16 | ans.push(stack.pop()); 17 | } else { 18 | ans.push(s[i]); 19 | } 20 | } 21 | return ans.join(""); 22 | }; 23 | -------------------------------------------------------------------------------- /ReverseVowelsOfaString/ReverseVowels.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverseVowels(self, s: str) -> str: 3 | vowels = set("aeiouAEIOU") 4 | s = list(s) 5 | pointer1 = 0 6 | pointer2 = len(s) - 1 7 | while pointer1 < pointer2: 8 | if s[pointer1] in vowels and s[pointer2] in vowels: 9 | s[pointer1], s[pointer2] = s[pointer2], s[pointer1] 10 | elif s[pointer1] not in vowels: 11 | pointer1 += 1 12 | continue 13 | elif s[pointer2] not in vowels: 14 | pointer2 -= 1 15 | continue 16 | pointer1 += 1 17 | pointer2 -= 1 18 | return ''.join(s) -------------------------------------------------------------------------------- /ReverseWordsInString/ReverseWordsInString.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverseWords(self, s: str) -> str: 3 | return " ".join(s.split()[::-1]) -------------------------------------------------------------------------------- /RisingTemperature/RisingTemperature.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT w1.id 4 | FROM Weather w1, Weather w2 5 | WHERE w1.recordDate-w2.recordDate=1 6 | AND w1.temperature > w2.temperature; -------------------------------------------------------------------------------- /RobotReturnToOrigin/RobotReturnToOrigin.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def judgeCircle(self, moves: str) -> bool: 3 | if moves.count("L") == moves.count("R") and moves.count("U") == moves.count("D"): 4 | return True 5 | return False 6 | 7 | 8 | class Solution: 9 | def judgeCircle(self, moves: str) -> bool: 10 | d = {'R':[1,0], 11 | 'L':[-1,0], 12 | 'U':[0,1], 13 | 'D':[0,-1]} 14 | p = [0,0] 15 | for w in moves: 16 | m = d[w] 17 | p[0]+=m[0] 18 | p[1]+=m[1] 19 | return p == [0,0] 20 | -------------------------------------------------------------------------------- /RomanToInteger/RomToInt.js: -------------------------------------------------------------------------------- 1 | var romanToInt = function (s) { 2 | const roman = { 3 | I: 1, 4 | V: 5, 5 | X: 10, 6 | L: 50, 7 | C: 100, 8 | D: 500, 9 | M: 1000, 10 | }; 11 | let result = 0; 12 | for (let i = 0; i < s.length; i++) { 13 | if (roman[s[i]] < roman[s[i + 1]]) { 14 | result -= roman[s[i]]; 15 | } else { 16 | result += roman[s[i]]; 17 | } 18 | } 19 | return result; 20 | }; 21 | -------------------------------------------------------------------------------- /RomanToInteger/RomToInt.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def romanToInt(self, s: str) -> int: 3 | roman = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000} 4 | summ= 0 5 | for i in range(len(s)-1,-1,-1): 6 | num = roman[s[i]] 7 | if 3*num < summ: 8 | summ = summ-num 9 | else: 10 | summ = summ+num 11 | return summ 12 | -------------------------------------------------------------------------------- /RotateImage/RotateImage.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def rotate(self, matrix: List[List[int]]) -> None: 3 | """ 4 | Do not return anything, modify matrix in-place instead. 5 | """ 6 | n = len(matrix) 7 | for i in range(n): 8 | for j in range(i): 9 | matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j] 10 | for i in range(n): 11 | l,r=0,n-1 12 | while l bool: 3 | for i in range(len(s)): 4 | s = s[1:] + s[:1] 5 | if s == goal: 6 | return True 7 | return False -------------------------------------------------------------------------------- /RunningSumOf1dArray/RunningSumOf1dArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def runningSum(self, nums: List[int]) -> List[int]: 3 | for i in range(1, len(nums)): 4 | nums[i] = nums[i - 1] + nums[i] 5 | return nums -------------------------------------------------------------------------------- /SalesAnalysisIII/SalesAnalysisIII.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT product_id, product_name 4 | FROM PRODUCT 5 | WHERE product_id IN ( 6 | SELECT product_id 7 | FROM SALES 8 | MINUS 9 | SELECT product_id 10 | FROM SALES 11 | WHERE sale_date NOT BETWEEN TO_DATE('2019-01-01') 12 | AND TO_DATE('2019-03-31') 13 | ) -------------------------------------------------------------------------------- /SalesPerson/SalesPerson.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | Select s.name 4 | FROM SalesPerson s 5 | WHERE s.sales_id not in ( 6 | SELECT o.sales_id 7 | FROM Orders o 8 | INNER JOIN Company c 9 | ON o.com_id = c.com_id 10 | where c.name = 'RED' 11 | ); -------------------------------------------------------------------------------- /SearchInsertPosition/Search.js: -------------------------------------------------------------------------------- 1 | var searchInsert = function(nums, target) { 2 | // Перебираю массив в поисках таргета 3 | for (let i = 0; i < nums.length; i++) { 4 | // Если нахожу, вовращаю индекс 5 | if (nums[i] >= target) { 6 | return i; 7 | } 8 | } 9 | return nums.length; 10 | }; 11 | 12 | // ! Бинарный поиск 13 | var searchInsert = function (nums, target) { 14 | let left = 0; 15 | let right = nums.length; 16 | 17 | while (left < right) { 18 | const middle = Math.floor((left + right) / 2); 19 | 20 | if (nums[middle] < target) { 21 | left = middle + 1; 22 | } else { 23 | right = middle; 24 | } 25 | } 26 | 27 | return left; 28 | }; -------------------------------------------------------------------------------- /SetMismatch/SetMismatch.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[]} 4 | */ 5 | var findErrorNums = function (nums) { 6 | let map = new Map(); 7 | let len = nums.length; 8 | let sum = (len * (len + 1)) / 2; 9 | let s = 0, 10 | a = 0; 11 | for (let i = 0; i < len; i++) { 12 | if (map.has(nums[i])) a = nums[i]; 13 | else { 14 | map.set(nums[i], true); 15 | s += nums[i]; 16 | } 17 | } 18 | return [a, sum - s]; 19 | }; 20 | -------------------------------------------------------------------------------- /SetMismatch/SetMismatch.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findErrorNums(self, nums: List[int]) -> List[int]: 3 | n = len(nums) 4 | s = n * (n + 1) // 2 5 | miss = s - sum(set(nums)) 6 | duplicate = sum(nums) + miss - s 7 | return [duplicate, miss] 8 | 9 | 10 | class Solution: 11 | def findErrorNums(self, nums: List[int]) -> List[int]: 12 | return [sum(nums) - sum(set(nums)), sum(range(1, len(nums)+1)) - sum(set(nums))] -------------------------------------------------------------------------------- /ShortestCompletingWord/ShortestCompletingWord.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def shortestCompletingWord(self, licensePlate: str, words: List[str]) -> str: 3 | licensePlate = "".join(letter.lower() for letter in licensePlate if letter.isalpha()) 4 | # sort words by length. 5 | words.sort(key = len) 6 | for word in words: 7 | check = True 8 | for ch in set(licensePlate): 9 | if ch not in word or licensePlate.count(ch) > word.count(ch): 10 | check = False 11 | break 12 | if check == True: 13 | return word -------------------------------------------------------------------------------- /ShortestDistanceToCharacter/ShortestDistanceToCharacter.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def shortestToChar(self, s: str, c: str) -> List[int]: 3 | ans = [] 4 | ind = s.index(c) 5 | for i in range(len(s)): 6 | if abs(ind-i)>abs(s.find(c,i)-i): 7 | ind = s.index(c,i) 8 | if s[i]!=c: 9 | ans.append(abs(ind-i)) 10 | else: 11 | ans.append(0) 12 | return ans -------------------------------------------------------------------------------- /ShuffleString/ShuffleString.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def restoreString(self, s: str, indices: List[int]) -> str: 3 | res = list(s) 4 | for i, j in enumerate(indices): 5 | res[j] = s[i] 6 | return ''.join(res) -------------------------------------------------------------------------------- /ShuffleTheArray/ShuffleTheArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def shuffle(self, nums: List[int], n: int) -> List[int]: 3 | arr = [] 4 | for i in range(n): 5 | arr.append(nums[i]) 6 | arr.append(nums[i + n]) 7 | return arr -------------------------------------------------------------------------------- /SingleNumber/SingleNum.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var singleNumber = function (nums) { 6 | if (nums.length === 1) { 7 | return nums[0]; 8 | } 9 | let result = 0; 10 | nums.forEach((element) => { 11 | // ^ -> Проводит побитовую операцию xor (исключающее или) на двух значениях. x = x ^ i 12 | result = result ^ element; 13 | }); 14 | return result; 15 | }; 16 | 17 | 18 | // ! Solution 2 19 | /** 20 | * @param {number[]} nums 21 | * @return {number} 22 | */ 23 | var singleNumber = function (nums) { 24 | let i = 0; 25 | nums.forEach((e) => { 26 | if (nums.filter((n) => n === e).length === 1) i = e; 27 | }); 28 | return i; 29 | }; 30 | -------------------------------------------------------------------------------- /SingleNumber/SingleNum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def singleNumber(self, nums: List[int]) -> int: 3 | # if len(nums) == 1: return int(''.join(map(str, nums))) -> Эта строка необязательна, она делает из списка число 4 | x = 0 5 | for i in nums: 6 | # ^ -> Проводит побитовую операцию xor (исключающее или) на двух значениях. x = x ^ i 7 | x ^= i 8 | return x 9 | 10 | 11 | class Solution: 12 | def singleNumber(self, nums: List[int]) -> int: 13 | return reduce(lambda total, el: total ^ el, nums) 14 | 15 | 16 | class Solution: 17 | def singleNumber(self, nums: List[int]) -> int: 18 | for i in nums: 19 | if nums.count(i) == 1: 20 | return i -------------------------------------------------------------------------------- /SmallestEvenMultiple/SmallestEvenMultiple.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def smallestEvenMultiple(self, n: int) -> int: 3 | if n % 2 == 0: 4 | return n 5 | return n * 2 -------------------------------------------------------------------------------- /SortArrayByIncreasingFrequency/SortArrayByIncreasingFrequency.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def frequencySort(self, nums: List[int]) -> List[int]: 3 | nums = sorted(nums, reverse = True) 4 | 5 | ans = sorted(nums, key = nums.count) 6 | 7 | return ans -------------------------------------------------------------------------------- /SortArrayByParity/SortArrayByParity.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def sortArrayByParity(self, nums: List[int]) -> List[int]: 3 | arr = [] 4 | for i in nums: 5 | if i % 2 == 0: 6 | arr.insert(0, i) 7 | else: 8 | arr.append(i) 9 | return arr -------------------------------------------------------------------------------- /SortArrayByParityII/SortArrayByParityII.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def sortArrayByParityII(self, nums: List[int]) -> List[int]: 3 | even_arr = [] 4 | odd_arr = [] 5 | for i in nums: 6 | if i % 2 == 0: 7 | even_arr.append(i) 8 | else: 9 | odd_arr.append(i) 10 | nums.clear() 11 | for j in range(len(even_arr)): 12 | nums.append(even_arr[j]) 13 | nums.append(odd_arr[j]) 14 | return nums -------------------------------------------------------------------------------- /SortColors/SortColors.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def sortColors(self, nums: List[int]) -> None: 3 | """ 4 | Do not return anything, modify nums in-place instead. 5 | """ 6 | # ! Пузырьковая сортировка, задача решается одной ф-ей sort() 7 | for i in range(len(nums)): 8 | for j in range(0, len(nums) - i - 1): 9 | if nums[j] > nums[j + 1]: 10 | nums[j], nums[j + 1] = nums[j + 1], nums[j] -------------------------------------------------------------------------------- /SortIntegersByTheNumberOf1Bits/SortIntegersByTheNumberOf1Bits.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def sortByBits(self, arr: List[int]) -> List[int]: 3 | arr_list = [] 4 | for a in arr: 5 | arr_list.append((bin(a).count('1'), a)) 6 | arr_list.sort() 7 | return [k[1] for k in arr_list] -------------------------------------------------------------------------------- /SortTheMatrixDiagonally/SortTheMatrixDiagonally.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def diagonalSort(self, mat: List[List[int]]) -> List[List[int]]: 3 | mat_cols = len(mat[0]) 4 | mat_rows = len(mat) 5 | unsorted = True 6 | 7 | while unsorted: 8 | unsorted = False 9 | for col in range(mat_cols - 1): 10 | for row in range(mat_rows - 1): 11 | if mat[row][col] > mat[row + 1][col + 1]: 12 | unsorted = True 13 | mat[row][col], mat[row + 1][col + 1] = mat[row + 1][col + 1], mat[row][col] 14 | 15 | return mat -------------------------------------------------------------------------------- /SortingTheSentence/SortingTheSentence.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def sortSentence(self, s: str) -> str: 3 | split_ = s[::-1].split(" ") 4 | split_ = sorted(split_) 5 | res = [] 6 | for i in split_: 7 | res.append(i[1:][::-1]) 8 | return " ".join(res) 9 | -------------------------------------------------------------------------------- /SpecialArrayWithXElementsGreaterThanOrEqualX/SpecialArrayWithXElementsGreaterThanOrEqualX.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def specialArray(self, nums: List[int]) -> int: 3 | l = len(nums) 4 | while l > 0: 5 | count = 0 6 | for i in nums: 7 | if i >= l: 8 | count += 1 9 | if count == l: 10 | return count 11 | else: 12 | l -= 1 13 | return -1 -------------------------------------------------------------------------------- /Sqrt/Sqrt.js: -------------------------------------------------------------------------------- 1 | var mySqrt = function(x) { 2 | let left = 0 3 | let right = x 4 | if(x < 2) return x; 5 | while (left < right) { 6 | let mid = Math.floor((left + right) / 2) 7 | if (mid * mid > x) right = mid 8 | else if (mid * mid < x) left = mid + 1 9 | else return mid 10 | } 11 | return left - 1 12 | }; -------------------------------------------------------------------------------- /Sqrt/Sqrt.py: -------------------------------------------------------------------------------- 1 | # ! Бинарный поиск 2 | class Solution: 3 | def mySqrt(self, x: int) -> int: 4 | left, right = 0, x 5 | while left <= right: 6 | mid = left + (right - left) // 2 7 | if mid * mid > x: 8 | right = mid - 1 9 | elif mid * mid < x: 10 | left = mid + 1 11 | else: 12 | return mid 13 | return right 14 | 15 | 16 | # ! Это метод Ньютона 17 | class Solution: 18 | def mySqrt(self, x: int) -> int: 19 | result = x 20 | while not result * result - x < 1: 21 | result = (result + x / result) / 2 22 | return int(result) -------------------------------------------------------------------------------- /SquaresOfSortedArray/SquaresOfSortedArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def sortedSquares(self, nums: List[int]) -> List[int]: 3 | arr = [] 4 | for i in range(len(nums)): 5 | sq = nums[i] * nums[i] 6 | arr.append(sq) 7 | arr.sort() 8 | return arr -------------------------------------------------------------------------------- /StampingTheSequence/StampingTheSequence.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def movesToStamp(self, stamp: str, target: str) -> List[int]: 3 | n, m, t, s, res = len(target), len(stamp), list(target), list(stamp), [] 4 | 5 | def check(i): 6 | changed = False 7 | for j in range(m): 8 | if t[i + j] == '?': continue 9 | if t[i + j] != s[j]: return False 10 | changed = True 11 | if changed: 12 | t[i:i + m] = ['?'] * m 13 | res.append(i) 14 | return changed 15 | 16 | changed = True 17 | while changed: 18 | changed = False 19 | for i in range(n - m + 1): 20 | changed |= check(i) 21 | return res[::-1] if t == ['?'] * n else [] -------------------------------------------------------------------------------- /StrictlyPalindromicNumber/StrictlyPalindromicNumber.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isStrictlyPalindromic(self, n: int) -> bool: 3 | for b in range(2, n - 1): 4 | arr = [] 5 | num = n 6 | while num: 7 | arr.append(num % b) 8 | num = num // b 9 | if arr != arr[::-1]: 10 | return False 11 | return True -------------------------------------------------------------------------------- /SubrectangleQueries/SubrectangleQueries.py: -------------------------------------------------------------------------------- 1 | class SubrectangleQueries: 2 | rectangle = [[]] 3 | def __init__(self, rectangle: List[List[int]]): 4 | self.rectangle = rectangle 5 | 6 | def updateSubrectangle(self, row1: int, col1: int, row2: int, col2: int, newValue: int) -> None: 7 | for i in range(row1, row2 + 1): 8 | for j in range(col1, col2 + 1): 9 | self.rectangle[i][j] = newValue 10 | 11 | def getValue(self, row: int, col: int) -> int: 12 | return self.rectangle[row][col] 13 | 14 | 15 | # Your SubrectangleQueries object will be instantiated and called as such: 16 | # obj = SubrectangleQueries(rectangle) 17 | # obj.updateSubrectangle(row1,col1,row2,col2,newValue) 18 | # param_2 = obj.getValue(row,col) -------------------------------------------------------------------------------- /Subsets/Subsets.py: -------------------------------------------------------------------------------- 1 | # ! Iterative 2 | class Solution: 3 | def subsets(self, nums: List[int]) -> List[List[int]]: 4 | arr = [[]] 5 | for i in nums: 6 | for j in range(len(arr)): 7 | x = arr[j][:] 8 | x.append(i) 9 | arr.append(x) 10 | return arr 11 | 12 | 13 | # ! Recursion 14 | class Solution: 15 | def subsets(self, nums: List[int]) -> List[List[int]]: 16 | n, result = len(nums), [] 17 | def powerSet(nums, i, subSet): 18 | if i==n: 19 | result.append(subSet) 20 | return 21 | powerSet(nums, i+1, subSet) 22 | powerSet(nums, i+1, subSet + [nums[i]]) 23 | powerSet(nums, 0, []) 24 | return result -------------------------------------------------------------------------------- /SummaryRanges/SumRanges.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {string[]} 4 | */ 5 | var summaryRanges = function (nums) { 6 | let index = 0; 7 | let ranges = []; 8 | for (let num = 0; num < nums.length; num++) { 9 | if (num + 1 < nums.length && nums[num] + 1 == nums[num + 1]) { 10 | continue; 11 | } else if (index == num) { 12 | ranges.push(`${nums[index]}`); 13 | } else { 14 | ranges.push(`${nums[index]}->${nums[num]}`); 15 | } 16 | index = num + 1; 17 | } 18 | return ranges; 19 | }; 20 | -------------------------------------------------------------------------------- /SummaryRanges/SumRanges.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def summaryRanges(self, nums: List[int]) -> List[str]: 3 | ranges = [] 4 | index = 0 5 | for num in range(len(nums)): 6 | if num + 1 < len(nums) and nums[num] + 1 == nums[num + 1]: 7 | continue 8 | elif index == num: 9 | ranges.append(f"{nums[index]}") 10 | else: 11 | ranges.append(f"{nums[index]}->{nums[num]}") 12 | index = num + 1 13 | return ranges -------------------------------------------------------------------------------- /SwapNodesInPairs/SwapNodesInPairs.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, val=0, next=None): 4 | # self.val = val 5 | # self.next = next 6 | class Solution: 7 | def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]: 8 | node = ListNode(0) 9 | node.next = head 10 | curr = node 11 | while curr.next is not None and curr.next.next is not None: 12 | first = curr.next 13 | second = curr.next.next 14 | first.next = second.next 15 | curr.next = second 16 | curr.next.next = first 17 | curr = curr.next.next 18 | return node.next -------------------------------------------------------------------------------- /SwapSalary/SwapSalary.sql: -------------------------------------------------------------------------------- 1 | # Write your MySQL query statement below 2 | 3 | UPDATE Salary 4 | SET sex = CASE 5 | WHEN sex = 'm' 6 | THEN 'f' 7 | ELSE 'm' 8 | END; -------------------------------------------------------------------------------- /TeemoAttacking/TeemoAttacking.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} timeSeries 3 | * @param {number} duration 4 | * @return {number} 5 | */ 6 | var findPoisonedDuration = function (timeSeries, duration) { 7 | let bro = 0; 8 | for (i = 0; i < timeSeries.length - 1; i++) { 9 | bro += Math.min(timeSeries[i + 1] - timeSeries[i], duration); 10 | } 11 | return bro + duration; 12 | }; 13 | -------------------------------------------------------------------------------- /TeemoAttacking/TeemoAttacking.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int: 3 | var = 0 4 | for i in range(0, len(timeSeries) - 1): 5 | var += min(timeSeries[i + 1] - timeSeries[i], duration) 6 | return var + duration -------------------------------------------------------------------------------- /TheKWeakestRowsInMatrix/TheKWeakestRowsInMatrix.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def kWeakestRows(self, mat: List[List[int]], k: int) -> List[int]: 3 | soldiers = list() 4 | for i in range(len(mat)): 5 | s = sum(mat[i]) 6 | soldiers.append((s,i)) 7 | soldiers = sorted(soldiers, key= lambda x: x[0]) 8 | return [s[1] for s in soldiers[:k]] -------------------------------------------------------------------------------- /ThirdMaximumNumber/ThirdMaxNum.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | var thirdMax = function (nums) { 6 | let arr = new Set(nums); 7 | if (arr.size < 3) return Math.max(...arr); 8 | arr.delete(Math.max(...arr)); 9 | arr.delete(Math.max(...arr)); 10 | return Math.max(...arr); 11 | }; 12 | 13 | 14 | var thirdMax = function (nums) { 15 | nums = [...new Set(nums)].sort((a, b) => b - a); 16 | return nums.length >= 3 ? nums[2] : nums[0]; 17 | }; 18 | -------------------------------------------------------------------------------- /ThirdMaximumNumber/ThirdMaxNum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def thirdMax(self, nums: List[int]) -> int: 3 | el = sorted(set(nums)) 4 | if len(el) == 3: 5 | return min(nums) 6 | elif len(el) < 3: 7 | return max(nums) 8 | else: 9 | return el[-3] 10 | 11 | 12 | -------------------------------------------------------------------------------- /ToLowerCase/ToLowerCase.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def toLowerCase(self, s: str) -> str: 3 | return s.lower() 4 | 5 | 6 | class Solution: 7 | def toLowerCase(self, s: str) -> str: 8 | ans = "" 9 | for c in s: 10 | n = ord(c) 11 | ans += chr(n+32) if n > 64 and n < 91 else c 12 | return ans 13 | 14 | 15 | class Solution: 16 | def toLowerCase(self, s: str) -> str: 17 | return "".join(chr(ord(c) + 32) if "A" <= c <= "Z" else c for c in s) -------------------------------------------------------------------------------- /TopKFrequentWords/TopKFrequentWords.py: -------------------------------------------------------------------------------- 1 | # TODO import heapq 2 | 3 | class Solution: 4 | def topKFrequent(self, words: List[str], k: int) -> List[str]: 5 | dc = {} 6 | res = [] 7 | heap = [] 8 | for i in words: 9 | if i in dc: 10 | dc[i] += 1 11 | else: 12 | dc[i] = 1 13 | for i in dc: 14 | heapq.heappush(heap,(-1 * dc[i],i)) 15 | for i in range(k): 16 | if heapq: 17 | x = heapq.heappop(heap) 18 | res.append(x[1]) 19 | return res -------------------------------------------------------------------------------- /TwoSum/TwoSum.js: -------------------------------------------------------------------------------- 1 | // ! Брутфорс, полное прохождение не бро 2 | var twoSum = function (nums, target) { 3 | for (let i = 0; i < nums.length; i++) { 4 | for (let j = i + 1; j < nums.length; j++) { 5 | if (nums[i] + nums[j] == target) { 6 | return [i, j]; 7 | } 8 | } 9 | } 10 | }; 11 | 12 | // ! Хэш-таблица бро 13 | var twoSum = function (nums, target) { 14 | const indices = new Map(); 15 | 16 | for (let index = 0; index < nums.length; index++) { 17 | const complement = target - nums[index]; 18 | 19 | if (indices.has(complement)) { 20 | return [indices.get(complement), index]; 21 | } 22 | 23 | indices.set(nums[index], index); 24 | } 25 | }; 26 | -------------------------------------------------------------------------------- /TwoSum/TwoSum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def twoSum(self, nums: List[int], target: int) -> List[int]: 3 | required = {} 4 | for i in range(len(nums)): 5 | if target - nums[i] in required: 6 | return [required[target - nums[i]],i] 7 | else: 8 | required[nums[i]]=i 9 | input_list = [2,8,12,15] 10 | ob1 = Solution() 11 | print(ob1.twoSum(input_list, 20)) -------------------------------------------------------------------------------- /TwoSumIV-InputIsBST/TwoSumIV-InputIsBST.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def findTarget(self, root: Optional[TreeNode], k: int) -> bool: 9 | set_ = set() 10 | stack = [root] 11 | 12 | while stack: 13 | node = stack.pop() 14 | if k - node.val in set_: 15 | return True 16 | set_.add(node.val) 17 | if node.left: 18 | stack.append(node.left) 19 | if node.right: 20 | stack.append(node.right) 21 | 22 | return False -------------------------------------------------------------------------------- /UglyNumber/UglyNumber.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isUgly(self, n: int) -> bool: 3 | if n <= 0: return False 4 | for i in [2, 3, 5]: 5 | while n % i == 0: 6 | n = n // i 7 | return n == 1 -------------------------------------------------------------------------------- /UncommonWordsFromTwoSentences/UncommonWordsFromTwoSentences.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def uncommonFromSentences(self, s1: str, s2: str) -> List[str]: 3 | lst1_ = s1.split() 4 | lst2_ = s2.split() 5 | arr = [] 6 | for i in lst1_: 7 | if i not in lst2_ and lst1_.count(i) == 1: 8 | arr.append(i) 9 | for j in lst2_: 10 | if j not in lst1_ and lst2_.count(j) == 1: 11 | arr.append(j) 12 | return arr 13 | -------------------------------------------------------------------------------- /UniqueEmailAddresses/UniqueEmailAddresses.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numUniqueEmails(self, emails: List[str]) -> int: 3 | set_ = set() 4 | for email in emails: 5 | local, domain = email.split("@") 6 | local = local.split('+')[0] 7 | local = local.replace('.', '') 8 | set_.add(local + '@' + domain) 9 | return len(set_) 10 | -------------------------------------------------------------------------------- /UniqueMorseCodeWords/UniqueMorseCodeWords.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def uniqueMorseRepresentations(self, words: List[str]) -> int: 3 | morze = [".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."] 4 | res = set() 5 | for word in words: 6 | val = "" 7 | for i in word: 8 | val += morze[ord(i)- ord("a")] 9 | res.add(val) 10 | return len(res) -------------------------------------------------------------------------------- /UserActivityForThePast30DaysI/UserActivityForThePast30DaysI.sql: -------------------------------------------------------------------------------- 1 | /* Write your PL/SQL query statement below */ 2 | 3 | SELECT 4 | SUBSTR(ac.activity_date, 0, 10) AS day, 5 | COUNT(DISTINCT ac.user_id) AS active_users 6 | FROM 7 | activity ac 8 | WHERE 9 | ac.activity_date >= TO_DATE('2019-07-27') - 29 10 | AND 11 | ac.activity_date <= TO_DATE('2019-07-27') 12 | GROUP BY 13 | ac.activity_date; -------------------------------------------------------------------------------- /Valid Parentheses/Valid.js: -------------------------------------------------------------------------------- 1 | // Почти такая же логика как на питоне 2 | const isValid = (s) => { 3 | // Создаю массив куда буду пушить скобки 4 | const arr = []; 5 | // Массив со скобками 6 | const map = new Map([ 7 | ["(", ")"], 8 | ["[", "]"], 9 | ["{", "}"], 10 | ]); 11 | // Цикл для перебора 12 | for (let i = 0; i < s.length; i += 1) { 13 | // Has по сути тоже самое что и includes 14 | if (map.has(s[i])) { 15 | // Пушу в массив 16 | arr.push(map.get(s[i])); 17 | // Если нет в массиве 18 | } else if (s[i] !== arr.pop()) { 19 | return false; 20 | } 21 | } 22 | 23 | return arr.length === 0; 24 | }; 25 | -------------------------------------------------------------------------------- /ValidAnagram/ValidAnagram.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @param {string} t 4 | * @return {boolean} 5 | */ 6 | var isAnagram = function (s, t) { 7 | if (t.length != s.length) return false; 8 | const counts = {}; 9 | for (let c of s) { 10 | counts[c] = (counts[c] || 0) + 1; 11 | } 12 | for (let c of t) { 13 | if (!counts[c]) return false; 14 | counts[c]--; 15 | } 16 | return true; 17 | }; 18 | 19 | 20 | /** 21 | * @param {string} s 22 | * @param {string} t 23 | * @return {boolean} 24 | */ 25 | var isAnagram = function (s, t) { 26 | return s.split("").sort().join("") == t.split("").sort().join(""); 27 | }; 28 | -------------------------------------------------------------------------------- /ValidAnagram/ValidAnagram.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isAnagram(self, s: str, t: str) -> bool: 3 | dct1, dct2 = {}, {} 4 | for i in s: 5 | dct1[i] = dct1.get(i, 0) + 1 6 | for i in t: 7 | dct2[i] = dct2.get(i, 0) + 1 8 | return dct1 == dct2 9 | 10 | 11 | class Solution: 12 | def isAnagram(self, s: str, t: str) -> bool: 13 | return sorted(s) == sorted(t) -------------------------------------------------------------------------------- /ValidPalindrome/ValidPalindrome.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {boolean} 4 | */ 5 | var isPalindrome = function (s) { 6 | // turn string to lowercase and use regex to remove non-alphanumeric 7 | s = s.toLowerCase().replace(/[^a-z0-9]/g, ""); 8 | return s.split("").reverse().join("") == s; 9 | }; 10 | 11 | 12 | /** 13 | * @param {string} s 14 | * @return {boolean} 15 | */ 16 | var isPalindrome = function (s) { 17 | s = s.toLowerCase(); 18 | s = s.replace(/[^A-Za-z0-9]/g, ""); 19 | let start = 0; 20 | let end = s.length - 1; 21 | while (start < end) { 22 | if (s[start] != s[end]) return false; 23 | start++; 24 | end--; 25 | } 26 | return true; 27 | }; 28 | -------------------------------------------------------------------------------- /ValidPalindrome/ValidPalindrome.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isPalindrome(self, s: str) -> bool: 3 | s = [c.lower() for c in s if c.isalnum()] 4 | return s == s[::-1] 5 | 6 | 7 | class Solution: 8 | def isPalindrome(self, s: str) -> bool: 9 | l, r = 0, len(s)-1 10 | while l < r: 11 | while l < r and not s[l].isalnum(): 12 | l += 1 13 | while l bool: 3 | left, right = 0, len(s) - 1 4 | while left < right: 5 | if s[left] != s[right]: 6 | one, two = s[left:right], s[left + 1:right + 1] 7 | return one == one[::-1] or two == two[::-1] 8 | left += 1 9 | right -= 1 10 | return True -------------------------------------------------------------------------------- /ValidPhoneNumbers/ValidPhoneNumbers.bash: -------------------------------------------------------------------------------- 1 | # Read from the file file.txt and output all valid phone numbers to stdout. 2 | 3 | grep -e "^[0-9]\{3\}\-[0-9]\{3\}\-[0-9]\{4\}$" -e "^([0-9]\{3\}) [0-9]\{3\}\-[0-9]\{4\}$" file.txt -------------------------------------------------------------------------------- /ValidateBinarySearchTree/ValidateBinarySearchTree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, val=0, left=None, right=None): 4 | # self.val = val 5 | # self.left = left 6 | # self.right = right 7 | class Solution: 8 | def isValidBST(self, root: Optional[TreeNode]) -> bool: 9 | arr = [] 10 | self.inArr(root, arr) 11 | for i in range(1, len(arr)): 12 | if arr[i] <= arr[i - 1]: 13 | return False 14 | return True 15 | 16 | def inArr(self, root, arr): 17 | if root is None: 18 | return True 19 | self.inArr(root.left, arr) 20 | arr.append(root.val) 21 | self.inArr(root.right, arr) 22 | 23 | 24 | -------------------------------------------------------------------------------- /VerifyingAnAlienDictionary/VerifyingAnAlienDictionary.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isAlienSorted(self, words: List[str], order: str) -> bool: 3 | alpha = {c : i for i,c in enumerate(order)} 4 | for i in range(len(words) - 1): 5 | w1, w2 = words[i], words[i + 1] 6 | for j in range(len(w1)): 7 | if j == len(w2): 8 | return False 9 | if w1[j] != w2[j]: 10 | if alpha[w2[j]] < alpha[w1[j]]: 11 | return False 12 | break 13 | return True 14 | -------------------------------------------------------------------------------- /WordPattern/WordPattern.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} pattern 3 | * @param {string} s 4 | * @return {boolean} 5 | */ 6 | var wordPattern = function (pattern, s) { 7 | const words = s.split(" "); 8 | const map = new Map(); 9 | 10 | if (words.length !== pattern.length) return false; 11 | if (new Set(words).size !== new Set(pattern).size) return false; 12 | 13 | for (let i = 0; i < pattern.length; i++) { 14 | if (map.has(pattern[i]) && map.get(pattern[i]) !== words[i]) return false; 15 | map.set(pattern[i], words[i]); 16 | } 17 | return true; 18 | }; 19 | -------------------------------------------------------------------------------- /WordPattern/WordPattern.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def wordPattern(self, pattern: str, s: str) -> bool: 3 | words, w_to_p = s.split(' '), dict() 4 | if len(pattern) != len(words): return False 5 | if len(set(pattern)) != len(set(words)): return False 6 | for i in range(len(words)): 7 | if words[i] not in w_to_p: 8 | w_to_p[words[i]] = pattern[i] 9 | elif w_to_p[words[i]] != pattern[i]: 10 | return False 11 | return True 12 | -------------------------------------------------------------------------------- /XOfKindInDeckOfCards/XOfKindInDeckOfCards.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def hasGroupsSizeX(self, deck: List[int]) -> bool: 3 | hash = {} 4 | for num in deck: 5 | if num not in hash: 6 | hash[num] = 0 7 | hash[num] += 1 8 | 9 | countArr = list(hash.values()) 10 | minCount = min(countArr) 11 | 12 | if minCount < 2: return False 13 | 14 | for i in range(2, minCount + 1): 15 | divisible = [a % i == 0 for a in countArr] 16 | if all(divisible): 17 | return True 18 | return False --------------------------------------------------------------------------------