Full Code of haoel/leetcode for AI

gitextract_9q_nrc1i/

├── .gitignore
├── README.md
├── algorithms/
│   ├── cpp/
│   │   ├── 3Sum/
│   │   │   └── 3Sum.cpp
│   │   ├── 3SumClosest/
│   │   │   └── 3SumClosest.cpp
│   │   ├── 4Sum/
│   │   │   └── 4Sum.cpp
│   │   ├── FindValidMatrixGivenRowAndColumnSums/
│   │   │   └── FindValidMatrixGivenRowAndColumnSums.cpp
│   │   ├── LRUCache/
│   │   │   └── LRUCache.cpp
│   │   ├── NumberOfWaysToSplitString/
│   │   │   └── NumberOfWaysToSplitString.cpp
│   │   ├── UTF8Validation/
│   │   │   └── UTF8Validation.cpp
│   │   ├── accountsMerge/
│   │   │   └── AccountsMerge.cpp
│   │   ├── addAndSearchWord/
│   │   │   └── AddAndSearchWord.cpp
│   │   ├── addBinary/
│   │   │   └── addBinary.cpp
│   │   ├── addDigits/
│   │   │   └── addDigits.cpp
│   │   ├── addStrings/
│   │   │   └── AddStrings.cpp
│   │   ├── addToArrayFormOfInteger/
│   │   │   └── AddToArrayFormOfInteger.cpp
│   │   ├── addTwoNumbers/
│   │   │   └── addTwoNumbers.cpp
│   │   ├── additiveNumber/
│   │   │   └── AdditiveNumber.cpp
│   │   ├── anagrams/
│   │   │   ├── GroupAnagrams.cpp
│   │   │   └── ValidAnagram.cpp
│   │   ├── arithmeticSlices/
│   │   │   └── ArithmeticSlices.cpp
│   │   ├── backspaceStringCompare/
│   │   │   └── BackspaceStringCompare.cpp
│   │   ├── balancedBinaryTree/
│   │   │   └── balancedBinaryTree.cpp
│   │   ├── basicCalculator/
│   │   │   ├── BasicCalculator.II.cpp
│   │   │   └── BasicCalculator.cpp
│   │   ├── bestTimeToBuyAndSellStock/
│   │   │   ├── BestTimeToBuyAndSellStockWithCooldown.cpp
│   │   │   ├── BestTimeToBuyAndSellStockWithTransactionFee.cpp
│   │   │   ├── bestTimeToBuyAndSellStock.II.cpp
│   │   │   ├── bestTimeToBuyAndSellStock.III.cpp
│   │   │   ├── bestTimeToBuyAndSellStock.IV.cpp
│   │   │   └── bestTimeToBuyAndSellStock.cpp
│   │   ├── binarySearchTreeIterator/
│   │   │   └── binarySearchTreeIterator.cpp
│   │   ├── binaryTreeInorderTraversal/
│   │   │   └── binaryTreeInorderTraversal.cpp
│   │   ├── binaryTreeLevelOrderTraversal/
│   │   │   ├── binaryTreeLevelOrderTraversal.II.cpp
│   │   │   └── binaryTreeLevelOrderTraversal.cpp
│   │   ├── binaryTreeMaximumPathSum/
│   │   │   └── binaryTreeMaximumPathSum.cpp
│   │   ├── binaryTreePaths/
│   │   │   └── binaryTreePaths.cpp
│   │   ├── binaryTreePostorderTraversal/
│   │   │   └── binaryTreePostorderTraversal.cpp
│   │   ├── binaryTreePreorderTraversal/
│   │   │   └── binaryTreePreorderTraversal.cpp
│   │   ├── binaryTreeRightSideView/
│   │   │   └── binaryTreeRightSideView.cpp
│   │   ├── binaryTreeUpsideDown/
│   │   │   └── binaryTreeUpsideDown.cpp
│   │   ├── binaryTreeZigzagLevelOrderTraversal/
│   │   │   └── binaryTreeZigzagLevelOrderTraversal.cpp
│   │   ├── binaryWatch/
│   │   │   └── BinaryWatch.cpp
│   │   ├── bitwiseANDOfNumbersRange/
│   │   │   └── BitwiseAndOfNumbersRange.cpp
│   │   ├── brokenCalculator/
│   │   │   └── BrokenCalculator.cpp
│   │   ├── buddyStrings/
│   │   │   └── BuddyStrings.cpp
│   │   ├── buildingBoxes/
│   │   │   └── BuildingBoxes.cpp
│   │   ├── bulbSwitcher/
│   │   │   ├── BulbSwitcher.II.cpp
│   │   │   ├── BulbSwitcher.III.cpp
│   │   │   ├── BulbSwitcher.IV.cpp
│   │   │   └── bulbSwitcher.cpp
│   │   ├── bullsAndCows/
│   │   │   └── bullsAndCows.cpp
│   │   ├── burstBalloons/
│   │   │   └── BurstBalloons.cpp
│   │   ├── calculateMoneyInLeetcodeBank/
│   │   │   └── CalculateMoneyInLeetcodeBank.cpp
│   │   ├── candy/
│   │   │   └── candy.cpp
│   │   ├── checkIfArrayIsSortedAndRotated/
│   │   │   └── CheckIfArrayIsSortedAndRotated.cpp
│   │   ├── checkIfBinaryStringHasAtMostOneSegmentOfOnes/
│   │   │   └── CheckIfBinaryStringHasAtMostOneSegmentOfOnes.cpp
│   │   ├── checkIfNumberIsASumOfPowersOfThree/
│   │   │   └── CheckIfNumberIsASumOfPowersOfThree.cpp
│   │   ├── checkIfOneStringSwapCanMakeStringsEqual/
│   │   │   └── CheckIfOneStringSwapCanMakeStringsEqual.cpp
│   │   ├── checkIfTheSentenceIsPangram/
│   │   │   └── CheckIfTheSentenceIsPangram.cpp
│   │   ├── checkIfWordEqualsSummationOfTwoWords/
│   │   │   └── CheckIfWordEqualsSummationOfTwoWords.cpp
│   │   ├── climbStairs/
│   │   │   └── climbStairs.cpp
│   │   ├── cloneGraph/
│   │   │   └── cloneGraph.cpp
│   │   ├── closestDessertCost/
│   │   │   └── ClosestDessertCost.cpp
│   │   ├── closestRoom/
│   │   │   └── ClosestRoom.cpp
│   │   ├── closestSubsequenceSum/
│   │   │   └── ClosestSubsequenceSum.cpp
│   │   ├── coinChange/
│   │   │   ├── CoinChange2.cpp
│   │   │   └── coinChange.cpp
│   │   ├── combinationSum/
│   │   │   ├── combinationSum.II.cpp
│   │   │   ├── combinationSum.III.cpp
│   │   │   └── combinationSum.cpp
│   │   ├── combinationSumIV/
│   │   │   └── combinationSumIV.cpp
│   │   ├── combinations/
│   │   │   └── combinations.cpp
│   │   ├── compareStringsByFrequencyOfTheSmallestCharacter/
│   │   │   └── CompareStringsByFrequencyOfTheSmallestCharacter.cpp
│   │   ├── compareVersionNumbers/
│   │   │   └── compareVersionNumbers.cpp
│   │   ├── constructBinaryTreeFromInorderAndPostorderTraversal/
│   │   │   └── constructBinaryTreeFromInorderAndPostorderTraversal.cpp
│   │   ├── constructBinaryTreeFromPreorderAndInorderTraversal/
│   │   │   └── constructBinaryTreeFromPreorderAndInorderTraversal.cpp
│   │   ├── constructTheLexicographicallyLargestValidSequence/
│   │   │   └── ConstructTheLexicographicallyLargestValidSequence.cpp
│   │   ├── containerWithMostWater/
│   │   │   └── containerWithMostWater.cpp
│   │   ├── containsDuplicate/
│   │   │   ├── ContainsDuplicate.II.cpp
│   │   │   ├── ContainsDuplicate.III.cpp
│   │   │   └── ContainsDuplicate.cpp
│   │   ├── convertANumberToHexadecimal/
│   │   │   └── ConvertANumberToHexadecimal.cpp
│   │   ├── convertSortedArrayToBinarySearchTree/
│   │   │   └── convertSortedArrayToBinarySearchTree.cpp
│   │   ├── convertSortedListToBinarySearchTree/
│   │   │   └── convertSortedListToBinarySearchTree.cpp
│   │   ├── copyListWithRandomPointer/
│   │   │   └── copyListWithRandomPointer.cpp
│   │   ├── countAndSay/
│   │   │   └── countAndSay.cpp
│   │   ├── countCompleteTreeNodes/
│   │   │   └── CountCompleteTreeNodes.cpp
│   │   ├── countGoodMeals/
│   │   │   └── CountGoodMeals.cpp
│   │   ├── countItemsMatchingARule/
│   │   │   └── CountItemsMatchingARule.cpp
│   │   ├── countNicePairsInAnArray/
│   │   │   └── CountNicePairsInAnArray.cpp
│   │   ├── countNumberOfHomogenousSubstrings/
│   │   │   └── CountNumberOfHomogenousSubstrings.cpp
│   │   ├── countNumbersWithUniqueDigits/
│   │   │   └── CountNumbersWithUniqueDigits.cpp
│   │   ├── countOddNumbersInAnIntervalRange/
│   │   │   └── CountOddNumbersInAnIntervalRange.cpp
│   │   ├── countOfRangeSum/
│   │   │   └── CountOfRangeSum.cpp
│   │   ├── countOfSmallerNumbersAfterSelf/
│   │   │   └── countOfSmallerNumbersAfterSelf.cpp
│   │   ├── countPairsOfNodes/
│   │   │   └── CountPairsOfNodes.cpp
│   │   ├── countPairsWithXorInARange/
│   │   │   └── CountPairsWithXorInARange.cpp
│   │   ├── countPrimes/
│   │   │   └── CountPrimes.cpp
│   │   ├── countingBits/
│   │   │   └── CountingBits.cpp
│   │   ├── courseSchedule/
│   │   │   ├── CourseSchedule.II.cpp
│   │   │   ├── CourseSchedule.cpp
│   │   │   └── non-recursive/
│   │   │       ├── course_schedule.cpp
│   │   │       └── main.cpp
│   │   ├── cousinsInBinaryTree/
│   │   │   └── CousinsInBinaryTree.cpp
│   │   ├── createMaximumNumber/
│   │   │   └── CreateMaximumNumber.cpp
│   │   ├── decodeString/
│   │   │   └── DecodeString.cpp
│   │   ├── decodeWays/
│   │   │   └── decodeWays.cpp
│   │   ├── decodeXORedPermutation/
│   │   │   └── DecodeXoredPermutation.cpp
│   │   ├── deleteNodeInALinkedList/
│   │   │   └── DeleteNodeInALinkedList.cpp
│   │   ├── designAuthenticationManager/
│   │   │   └── DesignAuthenticationManager.cpp
│   │   ├── detectCapital/
│   │   │   └── DetectCapital.cpp
│   │   ├── determineColorOfAChessboardSquare/
│   │   │   └── DetermineColorOfAChessboardSquare.cpp
│   │   ├── diameterOfBinaryTree/
│   │   │   └── diameterOfBinaryTree.cpp
│   │   ├── differentWaysToAddParentheses/
│   │   │   └── DifferentWaysToAddParentheses.cpp
│   │   ├── distinctSubsequences/
│   │   │   └── distinctSubsequences.cpp
│   │   ├── distributeCoinsInBinaryTree/
│   │   │   └── DistributeCoinsInBinaryTree.cpp
│   │   ├── divideTwoInt/
│   │   │   └── divideTwoInt.cpp
│   │   ├── dungeonGame/
│   │   │   └── dungeonGame.cpp
│   │   ├── editDistance/
│   │   │   └── editDistance.cpp
│   │   ├── eggDropWith2EggsAndNFloors/
│   │   │   └── EggDropWith2EggsAndNFloors.cpp
│   │   ├── eliminationGame/
│   │   │   └── EliminationGame.cpp
│   │   ├── equalSumArraysWithMinimumNumberOfOperations/
│   │   │   └── EqualSumArraysWithMinimumNumberOfOperations.cpp
│   │   ├── evaluateDivision/
│   │   │   └── EvaluateDivision.cpp
│   │   ├── evaluateReversePolishNotation/
│   │   │   └── evaluateReversePolishNotation.cpp
│   │   ├── evaluateTheBracketPairsOfAString/
│   │   │   └── EvaluateTheBracketPairsOfAString.cpp
│   │   ├── excelSheetColumnNumber/
│   │   │   └── excelSheetColumnNumber.cpp
│   │   ├── excelSheetColumnTitle/
│   │   │   └── excelSheetColumnTitle.cpp
│   │   ├── expressionAddOperators/
│   │   │   └── ExpressionAddOperators.cpp
│   │   ├── factorialTrailingZeroes/
│   │   │   └── factorialTrailingZeroes.cpp
│   │   ├── fibonacciNumber/
│   │   │   └── FibonacciNumber.cpp
│   │   ├── filterRestaurantsByVeganFriendlyPriceAndDistance/
│   │   │   └── FilterRestaurantsByVeganFriendlyPriceAndDistance.cpp
│   │   ├── findAllAnagramsInAString/
│   │   │   └── Find-All-Anagrams-in-a-String.cpp
│   │   ├── findCenterOfStarGraph/
│   │   │   └── FindCenterOfStarGraph.cpp
│   │   ├── findKthLargestXorCoordinateValue/
│   │   │   └── FindKthLargestXorCoordinateValue.cpp
│   │   ├── findMedianFromDataStream/
│   │   │   └── FindMedianFromDataStream.cpp
│   │   ├── findMinimumInRotatedSortedArray/
│   │   │   ├── findMinimumInRotatedSortedArray.II.cpp
│   │   │   └── findMinimumInRotatedSortedArray.cpp
│   │   ├── findNearestPointThatHasTheSameXOrYCoordinate/
│   │   │   └── FindNearestPointThatHasTheSameXOrYCoordinate.cpp
│   │   ├── findPeakElement/
│   │   │   └── findPeakElement.cpp
│   │   ├── findTheDifference/
│   │   │   └── FindTheDifference.cpp
│   │   ├── findTheDuplicateNumber/
│   │   │   └── findTheDuplicateNumber.cpp
│   │   ├── findTheHighestAltitude/
│   │   │   └── FindTheHighestAltitude.cpp
│   │   ├── findTheWinnerOfAnArrayGame/
│   │   │   └── FindTheWinnerOfAnArrayGame.cpp
│   │   ├── findTheWinnerOfTheCircularGame/
│   │   │   └── FindTheWinnerOfTheCircularGame.cpp
│   │   ├── findXorSumOfAllPairsBitwiseAnd/
│   │   │   └── FindXorSumOfAllPairsBitwiseAnd.cpp
│   │   ├── findingMkAverage/
│   │   │   └── FindingMkAverage.cpp
│   │   ├── findingTheUsersActiveMinutes/
│   │   │   └── FindingTheUsersActiveMinutes.cpp
│   │   ├── firstBadVersion/
│   │   │   └── FirstBadVersion.cpp
│   │   ├── firstMissingPositive/
│   │   │   └── firstMissingPositive.cpp
│   │   ├── firstUniqueCharacterInAString/
│   │   │   └── FirstUniqueCharacterInAString.cpp
│   │   ├── fizzBuzz/
│   │   │   └── FizzBuzz.cpp
│   │   ├── flattenBinaryTreeToLinkedList/
│   │   │   └── flattenBinaryTreeToLinkedList.cpp
│   │   ├── flattenNestedListIterator/
│   │   │   └── FlattenNestedListIterator.cpp
│   │   ├── formArrayByConcatenatingSubarraysOfAnotherArray/
│   │   │   └── FormArrayByConcatenatingSubarraysOfAnotherArray.cpp
│   │   ├── fractionToRecurringDecimal/
│   │   │   └── fractionToRecurringDecimal.cpp
│   │   ├── frequencyOfTheMostFrequentElement/
│   │   │   └── FrequencyOfTheMostFrequentElement.cpp
│   │   ├── friendCircles/
│   │   │   └── FriendCircles.cpp
│   │   ├── frogJump/
│   │   │   └── FrogJump.cpp
│   │   ├── gameOfLife/
│   │   │   └── GameOfLife.cpp
│   │   ├── gasStation/
│   │   │   └── gasStation.cpp
│   │   ├── generateParentheses/
│   │   │   └── generateParentheses.cpp
│   │   ├── grayCode/
│   │   │   └── grayCode.cpp
│   │   ├── greatestCommonDivisorOfStrings/
│   │   │   └── GreatestCommonDivisorOfStrings.cpp
│   │   ├── h-Index/
│   │   │   ├── h-Index.II.cpp
│   │   │   └── h-Index.cpp
│   │   ├── happyNumber/
│   │   │   └── HappyNumber.cpp
│   │   ├── houseRobber/
│   │   │   ├── houseRobber.II.cpp
│   │   │   ├── houseRobber.cpp
│   │   │   └── houseRobberIII.cpp
│   │   ├── implementQueueUsingStacks/
│   │   │   └── ImplementQueueUsingStacks.cpp
│   │   ├── implementStackUsingQueues/
│   │   │   └── ImplementStackUsingQueues.cpp
│   │   ├── implementTriePrefixTree/
│   │   │   └── ImplementTriePrefixTree.cpp
│   │   ├── increasingTripletSubsequence/
│   │   │   └── increasingTripletSubsequence.cpp
│   │   ├── incrementalMemoryLeak/
│   │   │   └── IncrementalMemoryLeak.cpp
│   │   ├── insertDeleteGetRandom/
│   │   │   ├── InsertDeleteGetrandomO1.cpp
│   │   │   └── InsertDeleteGetrandomO1DuplicatesAllowed.cpp
│   │   ├── insertInterval/
│   │   │   └── insertInterval.cpp
│   │   ├── insertionSortList/
│   │   │   └── insertionSortList.cpp
│   │   ├── integerBreak/
│   │   │   └── IntegerBreak.cpp
│   │   ├── integerReplacement/
│   │   │   └── IntegerReplacement.cpp
│   │   ├── integerToEnglishWords/
│   │   │   └── IntegerToEnglishWords.cpp
│   │   ├── integerToRoman/
│   │   │   └── integerToRoman.cpp
│   │   ├── interleavingString/
│   │   │   └── interleavingString.cpp
│   │   ├── intersectionOfTwoArrays/
│   │   │   ├── intersectionOfTwoArrays.cpp
│   │   │   └── intersectionOfTwoArraysII.cpp
│   │   ├── intersectionOfTwoLinkedLists/
│   │   │   └── intersectionOfTwoLinkedLists.cpp
│   │   ├── intervalListIntersectons/
│   │   │   └── IntervalListIntersections.cpp
│   │   ├── invertBinaryTree/
│   │   │   └── InvertBinaryTree.cpp
│   │   ├── isSubsequence/
│   │   │   └── IsSubsequence.cpp
│   │   ├── islandPerimeter/
│   │   │   └── IslandPerimeter.cpp
│   │   ├── isomorphicStrings/
│   │   │   └── IsomorphicStrings.cpp
│   │   ├── jewelsAndStones/
│   │   │   └── JewelsAndStones.cpp
│   │   ├── jumpGame/
│   │   │   ├── jumpGame.II.cpp
│   │   │   ├── jumpGame.VII.cpp
│   │   │   └── jumpGame.cpp
│   │   ├── kthLargestElementInAnArray/
│   │   │   └── KthLargestElementInAnArray.cpp
│   │   ├── kthSmallestElementInaBST/
│   │   │   └── KthSmallestElementInABst.cpp
│   │   ├── largestColorValueInADirectedGraph/
│   │   │   └── LargestColorValueInADirectedGraph.cpp
│   │   ├── largestMergeOfTwoStrings/
│   │   │   └── LargestMergeOfTwoStrings.cpp
│   │   ├── largestNumber/
│   │   │   └── largestNumber.cpp
│   │   ├── largestNumberAfterMutatingSubstring/
│   │   │   └── LargestNumberAfterMutatingSubstring.cpp
│   │   ├── largestPerimeterTriangle/
│   │   │   └── largestPerimeterTriangle.cpp
│   │   ├── largestRectangleInHistogram/
│   │   │   └── largestRectangleInHistogram.cpp
│   │   ├── largestSubmatrixWithRearrangements/
│   │   │   └── LargestSubmatrixWithRearrangements.cpp
│   │   ├── largestSubstringBetweenTwoEqualCharacters/
│   │   │   └── LargestSubstringBetweenTwoEqualCharacters.cpp
│   │   ├── latestTimeByReplacingHiddenDigits/
│   │   │   └── LatestTimeByReplacingHiddenDigits.cpp
│   │   ├── lengthOfLastWord/
│   │   │   └── lengthOfLastWord.cpp
│   │   ├── letterCombinationsOfAPhoneNumber/
│   │   │   └── letterCombinationsOfAPhoneNumber.cpp
│   │   ├── lexicographicalNumbers/
│   │   │   └── LexicographicalNumbers.cpp
│   │   ├── lexicographicallySmallestStringAfterApplyingOperations/
│   │   │   └── LexicographicallySmallestStringAfterApplyingOperations.cpp
│   │   ├── linkedListCycle/
│   │   │   ├── linkedListCycle.II.cpp
│   │   │   └── linkedListCycle.cpp
│   │   ├── linkedListRandomNode/
│   │   │   └── LinkedListRandomNode.cpp
│   │   ├── longerContiguousSegmentsOfOnesThanZeros/
│   │   │   └── LongerContiguousSegmentsOfOnesThanZeros.cpp
│   │   ├── longestAbsoluteFilePath/
│   │   │   └── LongestAbsoluteFilePath.cpp
│   │   ├── longestCommonPrefix/
│   │   │   └── longestCommonPrefix.cpp
│   │   ├── longestConsecutiveSequence/
│   │   │   └── longestConsecutiveSequence.cpp
│   │   ├── longestIncreasingPathInAMatrix/
│   │   │   └── LongestIncreasingPathInAMatrix.cpp
│   │   ├── longestIncreasingSubsequence/
│   │   │   └── longestIncreasingSubsequence.cpp
│   │   ├── longestNiceSubstring/
│   │   │   └── LongestNiceSubstring.cpp
│   │   ├── longestPalindrome/
│   │   │   └── LongestPalindrome.cpp
│   │   ├── longestPalindromicSubsequence/
│   │   │   └── LongestPalindromicSubsequence.cpp
│   │   ├── longestPalindromicSubstring/
│   │   │   └── longestPalindromicSubstring.cpp
│   │   ├── longestSubstringOfAllVowelsInOrder/
│   │   │   └── LongestSubstringOfAllVowelsInOrder.cpp
│   │   ├── longestSubstringWithAtLeastKRepeatingCharacters/
│   │   │   └── LongestSubstringWithAtLeastKRepeatingCharacters.cpp
│   │   ├── longestSubstringWithAtMostTwoDistinctCharacters/
│   │   │   └── longestSubstringWithAtMostTwoDistinctCharacters.cpp
│   │   ├── longestSubstringWithoutRepeatingCharacters/
│   │   │   └── longestSubstringWithoutRepeatingCharacters.cpp
│   │   ├── longestTurbulentSubarray/
│   │   │   └── LongestTurbulentSubarray.cpp
│   │   ├── longestValidParentheses/
│   │   │   └── longestValidParentheses.cpp
│   │   ├── lowestCommonAncestorOfABinarySearchTree/
│   │   │   └── LowestCommonAncestorOfABinarySearchTree.cpp
│   │   ├── lowestCommonAncestorOfABinaryTree/
│   │   │   └── LowestCommonAncestorOfABinaryTree.cpp
│   │   ├── majorityElement/
│   │   │   ├── majorityElement.II.cpp
│   │   │   └── majorityElement.cpp
│   │   ├── makeTheXorOfAllSegmentsEqualToZero/
│   │   │   └── MakeTheXorOfAllSegmentsEqualToZero.cpp
│   │   ├── mapOfHighestPeak/
│   │   │   └── MapOfHighestPeak.cpp
│   │   ├── matrixCellsInDistanceOrder/
│   │   │   └── MatrixCellsInDistanceOrder.cpp
│   │   ├── maxAreaOfIsland/
│   │   │   └── MaxAreaOfIsland.cpp
│   │   ├── maxPointsOnALine/
│   │   │   └── maxPointsOnALine.cpp
│   │   ├── maximalRectangle/
│   │   │   └── maximalRectangle.cpp
│   │   ├── maximalSquare/
│   │   │   └── MaximalSquare.cpp
│   │   ├── maximizeNumberOfNiceDivisors/
│   │   │   └── MaximizeNumberOfNiceDivisors.cpp
│   │   ├── maximizePalindromeLengthFromSubsequences/
│   │   │   └── MaximizePalindromeLengthFromSubsequences.cpp
│   │   ├── maximizeScoreAfterNOperations/
│   │   │   └── MaximizeScoreAfterNOperations.cpp
│   │   ├── maximumAbsoluteSumOfAnySubarray/
│   │   │   └── MaximumAbsoluteSumOfAnySubarray.cpp
│   │   ├── maximumAscendingSubarraySum/
│   │   │   └── MaximumAscendingSubarraySum.cpp
│   │   ├── maximumAveragePassRatio/
│   │   │   └── MaximumAveragePassRatio.cpp
│   │   ├── maximumAverageSubarray/
│   │   │   └── MaximumAverageSubarray.I.cpp
│   │   ├── maximumBuildingHeight/
│   │   │   └── MaximumBuildingHeight.cpp
│   │   ├── maximumDepthOfBinaryTree/
│   │   │   └── maximumDepthOfBinaryTree.cpp
│   │   ├── maximumDistanceBetweenAPairOfValues/
│   │   │   └── MaximumDistanceBetweenAPairOfValues.cpp
│   │   ├── maximumElementAfterDecreasingAndRearranging/
│   │   │   └── MaximumElementAfterDecreasingAndRearranging.cpp
│   │   ├── maximumErasureValue/
│   │   │   └── MaximumErasureValue.cpp
│   │   ├── maximumGap/
│   │   │   └── maximumGap.cpp
│   │   ├── maximumIceCreamBars/
│   │   │   └── MaximumIceCreamBars.cpp
│   │   ├── maximumNumberOfBallsInABox/
│   │   │   └── MaximumNumberOfBallsInABox.cpp
│   │   ├── maximumNumberOfConsecutiveValuesYouCanMake/
│   │   │   └── MaximumNumberOfConsecutiveValuesYouCanMake.cpp
│   │   ├── maximumNumberOfEventsThatCanBeAttended/
│   │   │   ├── MaximumNumberOfEventsThatCanBeAttended.II.cpp
│   │   │   └── MaximumNumberOfEventsThatCanBeAttended.cpp
│   │   ├── maximumNumberOfGroupsGettingFreshDonuts/
│   │   │   └── MaximumNumberOfGroupsGettingFreshDonuts.cpp
│   │   ├── maximumNumberOfWordsYouCanType/
│   │   │   └── MaximumNumberOfWordsYouCanType.cpp
│   │   ├── maximumPopulationYear/
│   │   │   └── MaximumPopulationYear.cpp
│   │   ├── maximumProductOfTwoElementsInAnArray/
│   │   │   └── MaximumProductOfTwoElementsInAnArray.cpp
│   │   ├── maximumProductOfWordLengths/
│   │   │   └── MaximumProductOfWordLengths.cpp
│   │   ├── maximumProductSubarray/
│   │   │   └── maximumProductSubarray.cpp
│   │   ├── maximumScoreFromPerformingMultiplicationOperations/
│   │   │   └── MaximumScoreFromPerformingMultiplicationOperations.cpp
│   │   ├── maximumScoreFromRemovingStones/
│   │   │   └── MaximumScoreFromRemovingStones.cpp
│   │   ├── maximumScoreFromRemovingSubstrings/
│   │   │   └── MaximumScoreFromRemovingSubstrings.cpp
│   │   ├── maximumScoreOfAGoodSubarray/
│   │   │   └── MaximumScoreOfAGoodSubarray.cpp
│   │   ├── maximumSubArray/
│   │   │   └── maximumSubArray.cpp
│   │   ├── maximumSubarrayMinProduct/
│   │   │   └── MaximumSubarrayMinProduct.cpp
│   │   ├── maximumUnitsOnATruck/
│   │   │   └── MaximumUnitsOnATruck.cpp
│   │   ├── maximumValueAfterInsertion/
│   │   │   └── MaximumValueAfterInsertion.cpp
│   │   ├── maximumValueAtAGivenIndexInABoundedArray/
│   │   │   └── MaximumValueAtAGivenIndexInABoundedArray.cpp
│   │   ├── maximumXorForEachQuery/
│   │   │   └── MaximumXorForEachQuery.cpp
│   │   ├── medianOfTwoSortedArrays/
│   │   │   └── medianOfTwoSortedArrays.cpp
│   │   ├── mergeIntervals/
│   │   │   └── mergeIntervals.cpp
│   │   ├── mergeKSortedLists/
│   │   │   └── mergeKSortedLists.cpp
│   │   ├── mergeStringsAlternately/
│   │   │   └── MergeStringsAlternately.cpp
│   │   ├── mergeTwoSortedArray/
│   │   │   └── mergeTwoSortedArray.cpp
│   │   ├── mergeTwoSortedList/
│   │   │   └── mergeTwoSortedList.cpp
│   │   ├── minCostClimbingStairs/
│   │   │   └── MinCostClimbingStairs.cpp
│   │   ├── minStack/
│   │   │   └── minStack.cpp
│   │   ├── miniParser/
│   │   │   └── MiniParser.cpp
│   │   ├── minimizeMaximumPairSumInArray/
│   │   │   └── MinimizeMaximumPairSumInArray.cpp
│   │   ├── minimumASCIIDeleteSumForTwoStrings/
│   │   │   └── MinimumAsciiDeleteSumForTwoStrings.cpp
│   │   ├── minimumAbsoluteSumDifference/
│   │   │   └── MinimumAbsoluteSumDifference.cpp
│   │   ├── minimumAdjacentSwapsToReachTheKthSmallestNumber/
│   │   │   └── MinimumAdjacentSwapsToReachTheKthSmallestNumber.cpp
│   │   ├── minimumChangesToMakeAlternatingBinaryString/
│   │   │   └── MinimumChangesToMakeAlternatingBinaryString.cpp
│   │   ├── minimumCostForTickets/
│   │   │   └── MinimumCostForTickets.cpp
│   │   ├── minimumDegreeOfAConnectedTrioInAGraph/
│   │   │   └── MinimumDegreeOfAConnectedTrioInAGraph.cpp
│   │   ├── minimumDepthOfBinaryTree/
│   │   │   └── minimumDepthOfBinaryTree.cpp
│   │   ├── minimumDistanceToTheTargetElement/
│   │   │   └── MinimumDistanceToTheTargetElement.cpp
│   │   ├── minimumElementsToAddToFormAGivenSum/
│   │   │   └── MinimumElementsToAddToFormAGivenSum.cpp
│   │   ├── minimumFallingPathSum/
│   │   │   └── MinimumFallingPathSum.cpp
│   │   ├── minimumHeightTrees/
│   │   │   └── MinimumHeightTrees.cpp
│   │   ├── minimumInsertionsToBalanceAParenthesesString/
│   │   │   └── MinimumInsertionsToBalanceAParenthesesString.cpp
│   │   ├── minimumIntervalToIncludeEachQuery/
│   │   │   └── MinimumIntervalToIncludeEachQuery.cpp
│   │   ├── minimumLengthOfStringAfterDeletingSimilarEnds/
│   │   │   └── MinimumLengthOfStringAfterDeletingSimilarEnds.cpp
│   │   ├── minimumLimitOfBallsInABag/
│   │   │   └── MinimumLimitOfBallsInABag.cpp
│   │   ├── minimumNumberOfOperationsToMoveAllBallsToEachBox/
│   │   │   └── MinimumNumberOfOperationsToMoveAllBallsToEachBox.cpp
│   │   ├── minimumNumberOfOperationsToReinitializeAPermutation/
│   │   │   └── MinimumNumberOfOperationsToReinitializeAPermutation.cpp
│   │   ├── minimumNumberOfPeopleToTeach/
│   │   │   └── MinimumNumberOfPeopleToTeach.cpp
│   │   ├── minimumOperationsToMakeArrayEqual/
│   │   │   └── MinimumOperationsToMakeArrayEqual.cpp
│   │   ├── minimumOperationsToMakeTheArrayIncreasing/
│   │   │   └── MinimumOperationsToMakeTheArrayIncreasing.cpp
│   │   ├── minimumPathSum/
│   │   │   └── minimumPathSum.cpp
│   │   ├── minimumSidewayJumps/
│   │   │   └── MinimumSidewayJumps.cpp
│   │   ├── minimumSizeSubarraySum/
│   │   │   └── MinimumSizeSubarraySum.cpp
│   │   ├── minimumSpeedToArriveOnTime/
│   │   │   └── MinimumSpeedToArriveOnTime.cpp
│   │   ├── minimumWindowSubstring/
│   │   │   └── minimumWindowSubstring.cpp
│   │   ├── mirrorReflection/
│   │   │   └── MirrorReflection.cpp
│   │   ├── missingNumber/
│   │   │   └── MissingNumber.cpp
│   │   ├── missingRanges/
│   │   │   └── missingRanges.cpp
│   │   ├── mostCommonWord/
│   │   │   └── MostCommonWord.cpp
│   │   ├── moveZeroes/
│   │   │   └── moveZeroes.cpp
│   │   ├── multiplyStrings/
│   │   │   └── multiplyStrings.cpp
│   │   ├── nQueens/
│   │   │   ├── nQueuens.II.cpp
│   │   │   └── nQueuens.cpp
│   │   ├── nRepeatedElementInSize2NArray/
│   │   │   └── N-Repeated-Element-in-Size-2N-Array.cpp
│   │   ├── nextPermutation/
│   │   │   └── nextPermutation.cpp
│   │   ├── nimGame/
│   │   │   └── nimGame.cpp
│   │   ├── nthDigit/
│   │   │   └── NthDigit.cpp
│   │   ├── numberOf1Bits/
│   │   │   └── numberOf1Bits.cpp
│   │   ├── numberOfDifferentIntegersInAString/
│   │   │   └── NumberOfDifferentIntegersInAString.cpp
│   │   ├── numberOfDifferentSubsequencesGcds/
│   │   │   └── NumberOfDifferentSubsequencesGcds.cpp
│   │   ├── numberOfDigitOne/
│   │   │   └── NumberOfDigitOne.cpp
│   │   ├── numberOfGoodWaysToSplitAString/
│   │   │   └── NumberOfGoodWaysToSplitAString.cpp
│   │   ├── numberOfIslands/
│   │   │   └── NumberOfIslands.cpp
│   │   ├── numberOfOrdersInTheBacklog/
│   │   │   └── NumberOfOrdersInTheBacklog.cpp
│   │   ├── numberOfRecentCalls/
│   │   │   └── NumberOfRecentCalls.cpp
│   │   ├── numberOfRectanglesThatCanFormTheLargestSquare/
│   │   │   └── NumberOfRectanglesThatCanFormTheLargestSquare.cpp
│   │   ├── numberOfRestrictedPathsFromFirstToLastNode/
│   │   │   └── NumberOfRestrictedPathsFromFirstToLastNode.cpp
│   │   ├── numberOfStudentsUnableToEatLunch/
│   │   │   └── NumberOfStudentsUnableToEatLunch.cpp
│   │   ├── numberOfSubArraysWithOddSum/
│   │   │   └── NumberOfSubArraysWithOddSum.cpp
│   │   ├── numberOfSubstringsWithOnly1s/
│   │   │   └── NumberOfSubstringsWithOnly1s.cpp
│   │   ├── oddEvenLinkedList/
│   │   │   └── OddEvenLinkedList.cpp
│   │   ├── oneEditDistance/
│   │   │   └── oneEditDistance.cpp
│   │   ├── palindromeLinkedList/
│   │   │   └── PalindromeLinkedList.cpp
│   │   ├── palindromeNumber/
│   │   │   └── palindromeNumber.cpp
│   │   ├── palindromePairs/
│   │   │   └── PalindromePairs.cpp
│   │   ├── palindromePartitioning/
│   │   │   ├── palindromePartitioning.II.cpp
│   │   │   └── palindromePartitioning.cpp
│   │   ├── palindromicSubstrings/
│   │   │   └── PalindromicSubstrings.cpp
│   │   ├── partitionEqualSubsetSum/
│   │   │   └── PartitionEqualSubsetSum.cpp
│   │   ├── partitionList/
│   │   │   └── partitionList.cpp
│   │   ├── pascalTriangle/
│   │   │   ├── pascalTriangle.II.cpp
│   │   │   └── pascalTriangle.cpp
│   │   ├── patchingArray/
│   │   │   └── PatchingArray.cpp
│   │   ├── pathSum/
│   │   │   ├── pathSum.II.cpp
│   │   │   └── pathSum.cpp
│   │   ├── peakIndexInAMountainArray/
│   │   │   └── PeakIndexInAMountainArray.cpp
│   │   ├── peekingIterator/
│   │   │   └── PeekingIterator.cpp
│   │   ├── perfectRectangle/
│   │   │   └── PerfectRectangle.cpp
│   │   ├── perfectSquares/
│   │   │   └── PerfectSquares.cpp
│   │   ├── permutationSequence/
│   │   │   └── permutationSequence.cpp
│   │   ├── permutations/
│   │   │   ├── permutations.II.cpp
│   │   │   └── permutations.cpp
│   │   ├── plusOne/
│   │   │   └── plusOne.cpp
│   │   ├── populatingNextRightPointersInEachNode/
│   │   │   ├── populatingNextRightPointersInEachNode.II.cpp
│   │   │   └── populatingNextRightPointersInEachNode.cpp
│   │   ├── pow/
│   │   │   └── pow.cpp
│   │   ├── powerOfFour/
│   │   │   └── PowerOfFour.cpp
│   │   ├── powerOfThree/
│   │   │   └── PowerOfThree.cpp
│   │   ├── powerOfTwo/
│   │   │   └── PowerOfTwo.cpp
│   │   ├── processTasksUsingServers/
│   │   │   └── ProcessTasksUsingServers.cpp
│   │   ├── productOfArrayExceptSelf/
│   │   │   └── ProductOfArrayExceptSelf.cpp
│   │   ├── queriesOnNumberOfPointsInsideACircle/
│   │   │   └── QueriesOnNumberOfPointsInsideACircle.cpp
│   │   ├── queueReconstructionByHeight/
│   │   │   └── QueueReconstructionByHeight.cpp
│   │   ├── randomPickIndex/
│   │   │   └── RandomPickIndex.cpp
│   │   ├── randomPointInNonOverlappingRectangles/
│   │   │   └── randomPointInNonOverlappingRectangles.cpp
│   │   ├── rangeSumQuery-Immutable/
│   │   │   ├── rangeSumQuery-Immutable.cpp
│   │   │   └── rangeSumQuery-Mutable/
│   │   │       └── RangeSumQueryMutable.cpp
│   │   ├── rangeSumQuery2D-Immutable/
│   │   │   └── RangeSumQuery2dImmutable.cpp
│   │   ├── ransomNote/
│   │   │   └── RansomNote.cpp
│   │   ├── readNCharactersGivenRead4/
│   │   │   ├── readNCharactersGivenRead4.II.cpp
│   │   │   └── readNCharactersGivenRead4.cpp
│   │   ├── reconstructItinerary/
│   │   │   └── ReconstructItinerary.cpp
│   │   ├── recoverATreeFromPreorderTraversal/
│   │   │   └── recoverATreeFromPreorderTraversal.cpp
│   │   ├── recoverBinarySearchTree/
│   │   │   └── recoverBinarySearchTree.cpp
│   │   ├── rectangleArea/
│   │   │   └── RectangleArea.cpp
│   │   ├── reformatPhoneNumber/
│   │   │   └── ReformatPhoneNumber.cpp
│   │   ├── regularExpressionMatching/
│   │   │   └── regularExpressionMatching.cpp
│   │   ├── removeDuplicateLetters/
│   │   │   └── RemoveDuplicateLetters.cpp
│   │   ├── removeDuplicatesFromSortedArray/
│   │   │   ├── removeDuplicatesFromSortedArray.II.cpp
│   │   │   └── removeDuplicatesFromSortedArray.cpp
│   │   ├── removeDuplicatesFromSortedList/
│   │   │   ├── removeDuplicatesFromSortedList.II.cpp
│   │   │   └── removeDuplicatesFromSortedList.cpp
│   │   ├── removeElement/
│   │   │   └── removeElement.cpp
│   │   ├── removeInvalidParentheses/
│   │   │   └── RemoveInvalidParentheses.cpp
│   │   ├── removeKDigits/
│   │   │   └── RemoveKDigits.cpp
│   │   ├── removeLinkedListElements/
│   │   │   └── RemoveLinkedListElements.cpp
│   │   ├── removeNthNodeFromEndOfList/
│   │   │   └── removeNthNodeFromEndOfList.cpp
│   │   ├── reorderList/
│   │   │   └── reorderList.cpp
│   │   ├── repeatedDNASequences/
│   │   │   └── repeatedDNASequences.cpp
│   │   ├── replaceAllDigitsWithCharacters/
│   │   │   └── ReplaceAllDigitsWithCharacters.cpp
│   │   ├── restoreIPAddresses/
│   │   │   └── restoreIPAddresses.cpp
│   │   ├── restoreTheArrayFromAdjacentPairs/
│   │   │   └── RestoreTheArrayFromAdjacentPairs.cpp
│   │   ├── reverseBits/
│   │   │   └── reverseBits.cpp
│   │   ├── reverseInteger/
│   │   │   └── reverseInteger.cpp
│   │   ├── reverseLinkedList/
│   │   │   ├── reverseLinkedList.II.cpp
│   │   │   └── reverseLinkedList.cpp
│   │   ├── reverseNodesInKGroup/
│   │   │   └── reverseNodesInKGroup.cpp
│   │   ├── reverseString/
│   │   │   └── ReverseString.cpp
│   │   ├── reverseVowelsOfAString/
│   │   │   └── reverseVowelsOfAString.cpp
│   │   ├── reverseWordsInAString/
│   │   │   ├── reverseWordsInAString.II.cpp
│   │   │   └── reverseWordsInAString.cpp
│   │   ├── romanToInteger/
│   │   │   └── romanToInteger.cpp
│   │   ├── rotateArray/
│   │   │   └── rotateArray.cpp
│   │   ├── rotateFunction/
│   │   │   └── RotateFunction.cpp
│   │   ├── rotateImage/
│   │   │   └── rotateImage.cpp
│   │   ├── rotateList/
│   │   │   └── rotateList.cpp
│   │   ├── rotatingTheBox/
│   │   │   └── RotatingTheBox.cpp
│   │   ├── sameTree/
│   │   │   └── sameTree.cpp
│   │   ├── satisfiabilityOfEqualityEquations/
│   │   │   └── SatisfiabilityOfEqualityEquations.cpp
│   │   ├── scrambleString/
│   │   │   └── scrambleString.cpp
│   │   ├── search2DMatrix/
│   │   │   ├── search2DMatrix.II.cpp
│   │   │   └── search2DMatrix.cpp
│   │   ├── searchForRange/
│   │   │   └── searchForRange.cpp
│   │   ├── searchInRotatedSortedArray/
│   │   │   ├── searchInRotatedSortedArray.II.cpp
│   │   │   └── searchInRotatedSortedArray.cpp
│   │   ├── searchInsertPosition/
│   │   │   └── searchInsertPosition.cpp
│   │   ├── seatReservationManager/
│   │   │   └── SeatReservationManager.cpp
│   │   ├── secondLargestDigitInAString/
│   │   │   └── SecondLargestDigitInAString.cpp
│   │   ├── sentenceScreenFitting/
│   │   │   ├── main.cpp
│   │   │   ├── sentenceScreenFitting.cpp
│   │   │   └── sentenceScreenFitting.h
│   │   ├── sentenceSimilarity/
│   │   │   └── SentenceSimilarity.III.cpp
│   │   ├── serializeAndDeserializeBinaryTree/
│   │   │   └── SerializeAndDeserializeBinaryTree.cpp
│   │   ├── setMatrixZeroes/
│   │   │   └── setMatrixZeroes.cpp
│   │   ├── shortEncodingOfWords/
│   │   │   └── ShortEncodingOfWords.cpp
│   │   ├── shortestPalindrome/
│   │   │   └── ShortestPalindrome.cpp
│   │   ├── shuffleAnArray/
│   │   │   └── ShuffleAnArray.cpp
│   │   ├── shuffleString/
│   │   │   └── ShuffleString.cpp
│   │   ├── shuffleTheArray/
│   │   │   └── ShuffleTheArray.cpp
│   │   ├── signOfTheProductOfAnArray/
│   │   │   └── SignOfTheProductOfAnArray.cpp
│   │   ├── simplifyPath/
│   │   │   └── simplifyPath.cpp
│   │   ├── singleNumber/
│   │   │   ├── singleNumber.II.cpp
│   │   │   ├── singleNumber.III.cpp
│   │   │   └── singleNumber.cpp
│   │   ├── singleThreadedCpu/
│   │   │   └── SingleThreadedCpu.cpp
│   │   ├── slidingWindowMaximum/
│   │   │   └── SlidingWindowMaximum.cpp
│   │   ├── smallestStringStartingFromLeaf/
│   │   │   └── SmallestStringStartingFromLeaf.cpp
│   │   ├── sortArrayByParity/
│   │   │   ├── SortArrayByParity.II.cpp
│   │   │   └── SortArrayByParity.cpp
│   │   ├── sortColors/
│   │   │   └── sortColors.cpp
│   │   ├── sortList/
│   │   │   └── sortList.cpp
│   │   ├── sortingTheSentence/
│   │   │   └── SortingTheSentence.cpp
│   │   ├── spiralMatrix/
│   │   │   ├── spiralMatrix.II.cpp
│   │   │   └── spiralMatrix.cpp
│   │   ├── splitArrayLargestSum/
│   │   │   └── SplitArrayLargestSum.cpp
│   │   ├── splittingAStringIntoDescendingConsecutiveValues/
│   │   │   └── SplittingAStringIntoDescendingConsecutiveValues.cpp
│   │   ├── sqrt/
│   │   │   └── sqrt.cpp
│   │   ├── squaresOfASortedArray/
│   │   │   └── SquaresOfASortedArray.cpp
│   │   ├── strStr/
│   │   │   └── strStr.cpp
│   │   ├── stringToIntegerAtoi/
│   │   │   └── stringToIntegerAtoi.cpp
│   │   ├── stringWithoutAAAOrBBB/
│   │   │   └── StringWithoutAAAOrBBB.cpp
│   │   ├── subsets/
│   │   │   ├── subsets.II.cpp
│   │   │   └── subsets.cpp
│   │   ├── substringWithConcatenationOfAllWords/
│   │   │   └── substringWithConcatenationOfAllWords.cpp
│   │   ├── substringsOfSizeThreeWithDistinctCharacters/
│   │   │   └── SubstringsOfSizeThreeWithDistinctCharacters.cpp
│   │   ├── sudokuSolver/
│   │   │   └── sudokuSolver.cpp
│   │   ├── sumOfBeautyOfAllSubstrings/
│   │   │   └── SumOfBeautyOfAllSubstrings.cpp
│   │   ├── sumOfDigitsInBaseK/
│   │   │   └── SumOfDigitsInBaseK.cpp
│   │   ├── sumOfDigitsOfStringAfterConvert/
│   │   │   └── SumOfDigitsOfStringAfterConvert.cpp
│   │   ├── sumOfEvenNumbersAfterQueries/
│   │   │   └── SumOfEvenNumbersAfterQueries.cpp
│   │   ├── sumOfFlooredPairs/
│   │   │   └── SumOfFlooredPairs.cpp
│   │   ├── sumOfLeftLeaves/
│   │   │   └── SumOfLeftLeaves.cpp
│   │   ├── sumOfTwoIntegers/
│   │   │   └── SumOfTwoIntegers.cpp
│   │   ├── sumOfUniqueElements/
│   │   │   └── SumOfUniqueElements.cpp
│   │   ├── sumRootToLeafNumber/
│   │   │   └── sumRootToLeafNumber.cpp
│   │   ├── summaryRanges/
│   │   │   └── SummaryRanges.cpp
│   │   ├── superUglyNumber/
│   │   │   └── SuperUglyNumber.cpp
│   │   ├── surroundedRegions/
│   │   │   └── surroundedRegions.cpp
│   │   ├── swapNodesInPairs/
│   │   │   └── swapNodesInPairs.cpp
│   │   ├── symmetricTree/
│   │   │   └── symmetricTree.cpp
│   │   ├── targetSum/
│   │   │   └── targetSum.cpp
│   │   ├── textJustification/
│   │   │   └── textJustification.cpp
│   │   ├── theSkylineProblem/
│   │   │   └── TheSkylineProblem.cpp
│   │   ├── thirdMaximumNumber/
│   │   │   └── ThirdMaximumNumber.cpp
│   │   ├── thousandSeparator/
│   │   │   └── ThousandSeparator.cpp
│   │   ├── threeConsecutiveOdds/
│   │   │   └── ThreeConsecutiveOdds.cpp
│   │   ├── timeBasedKeyValueStore/
│   │   │   └── TimeBasedKeyValueStore.cpp
│   │   ├── timeNeededToInformAllEmployees/
│   │   │   └── TimeNeededToInformAllEmployees.cpp
│   │   ├── topKFrequentElements/
│   │   │   └── topKFrequentElements.cpp
│   │   ├── totalHammingDistance/
│   │   │   └── totalHammingDistance.cpp
│   │   ├── trappingRainWater/
│   │   │   └── trappingRainWater.cpp
│   │   ├── treeOfCoprimes/
│   │   │   └── TreeOfCoprimes.cpp
│   │   ├── triangle/
│   │   │   └── triangle.cpp
│   │   ├── triplesWithBitwiseANDEqualToZero/
│   │   │   └── TriplesWithBitwiseAndEqualToZero.cpp
│   │   ├── truncateSentence/
│   │   │   └── TruncateSentence.cpp
│   │   ├── tupleWithSameProduct/
│   │   │   └── TupleWithSameProduct.cpp
│   │   ├── twoArraysEqualByReversingSubArrays/
│   │   │   └── MakeTwoArraysEqualByReversingSubArrays.cpp
│   │   ├── twoCityScheduling/
│   │   │   └── TwoCityScheduling.cpp
│   │   ├── twoSum/
│   │   │   ├── twoSum.II.cpp
│   │   │   ├── twoSum.III.cpp
│   │   │   └── twoSum.cpp
│   │   ├── uglyNumber/
│   │   │   ├── UglyNumber.II.cpp
│   │   │   └── UglyNumber.cpp
│   │   ├── uniqueBinarySearchTrees/
│   │   │   ├── uniqueBinarySearchTrees.II.cpp
│   │   │   └── uniqueBinarySearchTrees.cpp
│   │   ├── uniqueEmailAddresses/
│   │   │   └── UniqueEmailAddresses.cpp
│   │   ├── uniqueMorseCodeWords/
│   │   │   └── UniqueMorseCodeWords.cpp
│   │   ├── uniqueNumberOfOccurrences/
│   │   │   └── Unique-Number-of-Occurrences.cpp
│   │   ├── uniquePaths/
│   │   │   ├── UniquePaths.III.cpp
│   │   │   ├── uniquePaths.II.cpp
│   │   │   └── uniquePaths.cpp
│   │   ├── validNumber/
│   │   │   └── validNumber.cpp
│   │   ├── validPalindrome/
│   │   │   └── validPalindrome.cpp
│   │   ├── validParentheses/
│   │   │   └── validParentheses.cpp
│   │   ├── validPerfectSquare/
│   │   │   └── ValidPerfectSquare.cpp
│   │   ├── validSudoku/
│   │   │   └── validSudoku.cpp
│   │   ├── validateBinarySearchTree/
│   │   │   └── validateBinarySearchTree.cpp
│   │   ├── verifyPreorderSerializationOfABinaryTree/
│   │   │   └── VerifyPreorderSerializationOfABinaryTree.cpp
│   │   ├── verticalOrderTraversalOfABinaryTree/
│   │   │   └── VerticalOrderTraversalOfABinaryTree.cpp
│   │   ├── videoStitching/
│   │   │   └── VideoStitching.cpp
│   │   ├── waysToSplitArrayIntoThreeSubarrays/
│   │   │   └── WaysToSplitArrayIntoThreeSubarrays.cpp
│   │   ├── wiggleSort/
│   │   │   └── WiggleSort.II.cpp
│   │   ├── wiggleSubsequence/
│   │   │   └── wiggleSubsequence.cpp
│   │   ├── wildcardMatching/
│   │   │   └── wildcardMatching.cpp
│   │   ├── wordBreak/
│   │   │   ├── wordBreak.II.cpp
│   │   │   └── wordBreak.cpp
│   │   ├── wordLadder/
│   │   │   ├── wordLadder.II.cpp
│   │   │   └── wordLadder.cpp
│   │   ├── wordPattern/
│   │   │   └── WordPattern.cpp
│   │   ├── wordSearch/
│   │   │   ├── wordSearch.II.cpp
│   │   │   └── wordSearch.cpp
│   │   └── zigZagConversion/
│   │       └── zigZagConversion.cpp
│   ├── golang/
│   │   └── twoSum/
│   │       └── twoSum.go
│   ├── java/
│   │   ├── algorithms-java.iml
│   │   ├── junit-4.7.jar
│   │   └── src/
│   │       ├── LargestNumberAfterMutatingSubstring/
│   │       │   └── largestNumberAfterMutatingSubstring.java
│   │       ├── MaxSubArray/
│   │       │   └── MaxSubarray.java
│   │       ├── RotateImage/
│   │       │   └── rotateImage.java
│   │       ├── balancedBinaryTree/
│   │       │   ├── TreeNode.java
│   │       │   ├── balancedBinaryTree.java
│   │       │   └── balancedBinaryTreeTest.java
│   │       ├── binarySearchTreeIterator/
│   │       │   ├── TreeNode.java
│   │       │   ├── binarySearchTreeIterator.java
│   │       │   └── binarySearchTreeIteratorTest.java
│   │       ├── binaryTreeBFSTraversal/
│   │       │   ├── TreeNode.java
│   │       │   ├── binaryTreeBFSTraversal.java
│   │       │   └── binaryTreeBFSTraversalTest.java
│   │       ├── binaryTreeLevelOrderTraversal/
│   │       │   ├── TreeNode.java
│   │       │   ├── binaryTreeLevelOrderTraversal.java
│   │       │   └── binaryTreeLevelOrderTraversalTest.java
│   │       ├── binaryTreeMaximumPathSum/
│   │       │   ├── TreeNode.java
│   │       │   ├── binaryTreeMaximumPathSum.java
│   │       │   └── binaryTreeMaximumPathSumTest.java
│   │       ├── binaryTreePreorderTraversal/
│   │       │   ├── TreeNode.java
│   │       │   ├── binaryTreePreorderTraversal.java
│   │       │   └── binaryTreePreorderTraversalTest.java
│   │       ├── containerwithmostwater.java
│   │       ├── countAndSay/
│   │       │   ├── CountAndSay.java
│   │       │   └── TestCountAndSay.java
│   │       ├── dynamicProgramming/
│   │       │   ├── climbStairs/
│   │       │   │   ├── climbStairs.java
│   │       │   │   └── climbStairsTest.java
│   │       │   ├── minimumPathSum/
│   │       │   │   ├── minimumPathSum.java
│   │       │   │   └── minimumPathSumTest.java
│   │       │   ├── triangle/
│   │       │   │   ├── triangle.java
│   │       │   │   └── triangleTest.java
│   │       │   └── uniquePaths/
│   │       │       ├── uniquePaths.java
│   │       │       ├── uniquePathsII.java
│   │       │       ├── uniquePathsIITest.java
│   │       │       └── uniquePathsTest.java
│   │       ├── findMinimumInRotatedSortedArray/
│   │       │   ├── findMinimumInRotatedSortedArray.java
│   │       │   └── findMinimumInRotatedSortedArrayTest.java
│   │       ├── findPeakElement/
│   │       │   ├── findPeakElement.java
│   │       │   └── findPeakElementTest.java
│   │       ├── firstBadVersion/
│   │       │   ├── VersionControl.java
│   │       │   ├── firstBadVersion.java
│   │       │   └── firstBadVersionTest.java
│   │       ├── inorderSuccessorInBST/
│   │       │   ├── TreeNode.java
│   │       │   ├── inorderSuccessorInBST.java
│   │       │   └── inorderSuccessorInBSTTest.java
│   │       ├── lengthOfLastWord/
│   │       │   ├── LengthOfLastWord.java
│   │       │   └── TestLengthOfLastWord.java
│   │       ├── lowestCommonAncestorOfABinaryTree/
│   │       │   ├── TreeNode.java
│   │       │   ├── lowestCommonAncestorOfABinaryTree.java
│   │       │   └── lowestCommonAncestorOfABinaryTreeTest.java
│   │       ├── lruCache/
│   │       │   ├── LRUCache.java
│   │       │   └── LRUCacheTest.java
│   │       ├── maximumDepthOfBinaryTree/
│   │       │   ├── TreeNode.java
│   │       │   ├── maximumDepthOfBinaryTree.java
│   │       │   └── maximumDepthOfBinaryTreeTest.java
│   │       ├── minStack/
│   │       │   ├── MinStack.java
│   │       │   └── TestMinStack.java
│   │       ├── myQueue/
│   │       │   ├── MyQueue.java
│   │       │   └── TestMyQueue.java
│   │       ├── myStack/
│   │       │   ├── MyStack.java
│   │       │   └── TestMyStack.java
│   │       ├── palindromeNumber/
│   │       │   ├── PalindromeNumber.java
│   │       │   └── TestPalindromeNumber.java
│   │       ├── powXn/
│   │       │   ├── PowXn.java
│   │       │   └── TestPowXn.java
│   │       ├── removeDuplicatesFromSortedArray/
│   │       │   ├── RemoveDuplicatesFromSortedArray.java
│   │       │   └── TestRemoveDuplicates.java
│   │       ├── reverseLinkedList/
│   │       │   ├── ListNode.java
│   │       │   ├── ReverseLinkedList.java
│   │       │   └── TestReverseLinkedList.java
│   │       ├── reverseLinkedListII/
│   │       │   ├── ListNode.java
│   │       │   ├── ReverseLinkedListII.java
│   │       │   └── TestReverseLinkedListII.java
│   │       ├── reverseWordsInAString/
│   │       │   ├── ReverseWordsInAString.java
│   │       │   └── TestReverseWordsInAString.java
│   │       ├── rotateArray/
│   │       │   ├── RotateArray.java
│   │       │   └── TestRotateArray.java
│   │       ├── search2DMatrix/
│   │       │   ├── search2DMatrix.java
│   │       │   └── search2DMatrixTest.java
│   │       ├── searchA2DMatrixII/
│   │       │   ├── SearchA2DMatrixII.java
│   │       │   └── Test_240.java
│   │       ├── searchForRange/
│   │       │   ├── searchForRange.java
│   │       │   └── searchForRangeTest.java
│   │       ├── searchInABigSortedArray/
│   │       │   ├── searchInABigSortedArray.java
│   │       │   └── searchInABigSortedArrayTest.java
│   │       ├── searchInRotatedSortedArray/
│   │       │   ├── searchInRotatedSortedArray.java
│   │       │   └── searchInRotatedSortedArrayTest.java
│   │       ├── searchInsertPosition/
│   │       │   ├── searchInsertPosition.java
│   │       │   └── searchInsertPositionTest.java
│   │       ├── searchRangeInBinarySearchTree/
│   │       │   ├── TreeNode.java
│   │       │   ├── searchRangeInBinarySearchTree.java
│   │       │   └── searchRangeInBinarySearchTreeTest.java
│   │       ├── strStr/
│   │       │   ├── StrStrKmp.java
│   │       │   ├── TestStrStrKmp.java
│   │       │   ├── strStr.java
│   │       │   └── strStrTest.java
│   │       ├── subsets/
│   │       │   ├── subsets.java
│   │       │   ├── subsetsII.java
│   │       │   ├── subsetsIITest.java
│   │       │   └── subsetsTest.java
│   │       ├── validAnagram/
│   │       │   ├── TestValidAnagram.java
│   │       │   └── ValidAnagram.java
│   │       ├── validPalindrome/
│   │       │   ├── TestValidPalindrome.java
│   │       │   └── ValidPalindrome.java
│   │       └── validateBinarySearchTree/
│   │           ├── TreeNode.java
│   │           ├── validateBinarySearchTree.java
│   │           └── validateBinarySearchTreeTest.java
│   └── python/
│       ├── 1-bitAnd2-bitCharacters/
│       │   └── isOneBitCharacter.py
│       ├── AddOneRowToTree/
│       │   └── addOneRow.py
│       ├── BinarySearchTreeIterator/
│       │   └── BSTIterator.py
│       ├── BinaryTreePostorderTraversal/
│       │   └── postorderTraversal.py
│       ├── BinaryTreeTilt/
│       │   └── findTilt.py
│       ├── BinaryTreeZigzagLevelOrderTraversal/
│       │   └── zigzagLevelOrder.py
│       ├── CheckCompletenessOfABinaryTree/
│       │   └── isCompleteTree.py
│       ├── ConstructBinaryTreeFromInorderAndPostorderTraversal/
│       │   └── buildTree.py
│       ├── ConstructBinaryTreeFromPreorderAndInorderTraversal/
│       │   └── buildTree.py
│       ├── ContainsDuplicateII/
│       │   └── containsNearbyDuplicate.py
│       ├── ContainsDuplicateIII/
│       │   └── containsNearbyAlmostDuplicate.py
│       ├── ConvertBSTtoGreaterTree/
│       │   └── convertBST.py
│       ├── CopyListWithRandomPointer/
│       │   └── copyRandomList.py
│       ├── CountCompleteTreeNodes/
│       │   └── countNodes.py
│       ├── DeleteNodeInABST/
│       │   └── deleteNode.py
│       ├── DiameterOfBinaryTree/
│       │   └── diameterOfBinaryTree.py
│       ├── DifferentWaysToAddParentheses/
│       │   └── diffWaysToCompute.py
│       ├── FibonacciNumber/
│       │   └── fib.py
│       ├── FindDuplicateSubtrees/
│       │   └── findDuplicateSubtrees.py
│       ├── FindTheDuplicateNumber/
│       │   └── findDuplicate.py
│       ├── FlattenBinaryTreeToLinkedList/
│       │   └── flatten.py
│       ├── FlipBinaryTreeToMatchPreorderTraversal/
│       │   └── flipMatchVoyage.py
│       ├── FlipEquivalentBinaryTrees/
│       │   └── flipEquiv.py
│       ├── HappyNumber/
│       │   └── isHappy.py
│       ├── HouseRobber/
│       │   └── rob.py
│       ├── HouseRobberIII/
│       │   └── rob.py
│       ├── ImageSmoother/
│       │   └── imageSmoother.py
│       ├── InsertionSortList/
│       │   └── insertionSortList.py
│       ├── K-diffPairsInAnArray/
│       │   └── findPairs.py
│       ├── KthSmallestElementInABST/
│       │   └── kthSmallest.py
│       ├── LargestNumberAtLeastTwiceOfOthers/
│       │   └── dominantIndex.py
│       ├── LargestPerimeterTriangle/
│       │   └── largestPerimeter.py
│       ├── LinkedListCycleII/
│       │   └── detectCycle.py
│       ├── LongestConsecutiveSequence/
│       │   └── LongestConsecutive.py
│       ├── LongestContinuousIncreasingSubsequence/
│       │   └── findLengthOfLCIS.py
│       ├── LongestTurbulentSubarray/
│       │   └── maxTurbulenceSize.py
│       ├── LongestUnivaluePath/
│       │   └── longestUnivaluePath.py
│       ├── LowestCommonAncestorOfABinarySearchTree/
│       │   └── lowestCommonAncestor.py
│       ├── LowestCommonAncestorOfABinaryTree/
│       │   └── lowestCommonAncestor.py
│       ├── MaximizeDistanceToClosestPerson/
│       │   └── maxDistToClosest.py
│       ├── MaximumAverageSubarrayI/
│       │   └── findMaxAverage.py
│       ├── MaximumProductOfThreeNumbers/
│       │   └── maximumProduct.py
│       ├── MaximumWidthOfBinaryTree/
│       │   └── widthOfBinaryTree.py
│       ├── MiddleOfTheLinkedList/
│       │   └── middleOfTheLinkedList.py
│       ├── MinCostClimbingStairs/
│       │   └── minCostClimbingStairs.py
│       ├── Non-decreasingArray/
│       │   └── checkPossibility.py
│       ├── NumberOfIslands/
│       │   └── numIslands.py
│       ├── PancakeSorting/
│       │   └── pancakeSort.py
│       ├── PartitionList/
│       │   └── partition.py
│       ├── PathSumII/
│       │   └── pathSum.py
│       ├── PathSumIII/
│       │   └── pathSum.py
│       ├── PopulatingNextRightPointersInEachNode/
│       │   └── connect.py
│       ├── PopulatingNextRightPointersInEachNodeII/
│       │   └── connect.py
│       ├── PositionsOfLargeGroups/
│       │   └── largeGroupPositions.py
│       ├── PrintBinaryTree/
│       │   └── printTree.py
│       ├── RedundantConnection/
│       │   └── findRedundantConnection.py
│       ├── RemoveDuplicatesFromSortedListII/
│       │   └── deleteDuplicates.py
│       ├── RemoveNthNodeFromEndOfList/
│       │   └── removeNthFromEnd.py
│       ├── ReorderList/
│       │   └── reorderList.py
│       ├── RevealCardsInIncreasingOrder/
│       │   └── deckRevealedIncreasing.py
│       ├── ReverseLinkedListII/
│       │   └── reverseBetween.py
│       ├── SearchA2DMatrixII/
│       │   └── searchMatrix.py
│       ├── SecondMinimumNodeInABinaryTree/
│       │   └── findSecondMinimumValue.py
│       ├── SerializeAndDeserializeBST/
│       │   └── serialize.py
│       ├── ShortestUnsortedContinuousSubarray/
│       │   └── findUnsortedSubarray.py
│       ├── SingleNumberII/
│       │   └── SingleNumberII.py
│       ├── SortList/
│       │   └── sortList.py
│       ├── SquaresOfSortedArray/
│       │   └── sortedSquares.py
│       ├── Subsets/
│       │   └── subsets.py
│       ├── SubtreeOfAnotherTree/
│       │   └── isSubtree.py
│       ├── SumOfLeftLeaves/
│       │   └── sumOfLeftLeaves.py
│       ├── SumRootToLeafNumbers/
│       │   └── sumNumbers.py
│       ├── SwimInRisingWater/
│       │   └── swim_in_rising_water.py
│       ├── ThirdMaximumNumber/
│       │   └── thirdMax.py
│       ├── UniqueBinarySearchTrees/
│       │   └── numTrees.py
│       ├── UniqueBinarySearchTreesII/
│       │   └── generateTrees.py
│       ├── ValidMountainArray/
│       │   └── validMountainArray.py
│       ├── ValidateBinarySearchTree/
│       │   └── isValidBST.py
│       ├── XOfAKindInADeckOfCards/
│       │   └── hasGroupsSizeX.py
│       ├── firstMissingPositive/
│       │   └── firstMissingPositive.py
│       ├── jumpGame/
│       │   └── jumpGame.py
│       └── uniquePaths/
│           └── uniquePathsIII.py
├── database/
│   ├── README.md
│   └── TripsAndUsers.sql
├── scripts/
│   ├── README.md
│   ├── comments.sh
│   ├── git.config.sh
│   ├── lib/
│   │   └── query_problem.sh
│   ├── readme.sh
│   └── workflow.sh
└── shell/
    ├── README.md
    ├── TenthLine.sh
    ├── TransposeFile.sh
    ├── ValidPhoneNumbers.sh
    └── WordFrequency.sh

SYMBOL INDEX (2441 symbols across 711 files)

FILE: algorithms/cpp/3Sum/3Sum.cpp
  function threeSum (line 48) | vector<vector<int> > threeSum(vector<int> &num) {
  function threeSum2 (line 99) | vector<vector<int> > threeSum2(vector<int> &num) {
  function isSumZero (line 110) | bool isSumZero(vector < int>& v) {
  function sum (line 114) | int sum(vector<int>& v) {
  function combination (line 122) | vector<vector<int> > combination(vector<int> &v, int k) {
  function printMatrix (line 168) | void printMatrix(vector<vector<int> > &matrix)
  function main (line 181) | int main()

FILE: algorithms/cpp/3SumClosest/3SumClosest.cpp
  function threeSumClosest (line 47) | int threeSumClosest(vector<int> &num, int target) {
  function main (line 97) | int main()

FILE: algorithms/cpp/4Sum/4Sum.cpp
  function fourSum (line 38) | vector<vector<int> > fourSum(vector<int> &num, int target) {
  function threeSum (line 57) | vector<vector<int> > threeSum(vector<int> num, int target) {
  function printMatrix (line 102) | int printMatrix(vector< vector<int> > &vv)
  function main (line 114) | int main()

FILE: algorithms/cpp/FindValidMatrixGivenRowAndColumnSums/FindValidMatrixGivenRowAndColumnSums.cpp
  class Solution (line 48) | class Solution {
    method restoreMatrix (line 50) | vector<vector<int>> restoreMatrix(vector<int>& row, vector<int>& col) {

FILE: algorithms/cpp/LRUCache/LRUCache.cpp
  class Node (line 32) | class Node {
    method Node (line 37) | Node(int k, int v) { key=k; value=v; next = prev = NULL; }
  class DoubleLinkedList (line 42) | class DoubleLinkedList {
    method DoubleLinkedList (line 52) | DoubleLinkedList(){
    method Size (line 64) | int Size() const {
    method Node (line 68) | Node* NewAtBegin(int key, int value) {
    method Node (line 73) | Node* NewAtEnd(int key, int value) {
    method Node (line 78) | Node* AddAtBegin(Node* n){
    method Node (line 93) | Node* AddAtEnd(Node* n) {
    method Unlink (line 107) | void Unlink(Node* n){
    method Delete (line 128) | void Delete(Node* n){
    method TakeToBegin (line 133) | void TakeToBegin(Node* n){
    method Node (line 138) | Node* GetTailNode() {
    method DeleteLast (line 142) | void DeleteLast() {
    method Print (line 146) | void Print(){
  class LRUCache (line 158) | class LRUCache{
    method LRUCache (line 169) | LRUCache(int capacity) {
    method print (line 172) | void print(){
    method get (line 176) | int get(int key) {
    method set (line 186) | void set(int key, int value) {
  function main (line 206) | int main(int argc, char** argv)

FILE: algorithms/cpp/NumberOfWaysToSplitString/NumberOfWaysToSplitString.cpp
  class Solution (line 49) | class Solution {
    method numWays (line 51) | int numWays(string s) {

FILE: algorithms/cpp/UTF8Validation/UTF8Validation.cpp
  class Solution (line 49) | class Solution {
    method validUtf8 (line 51) | bool validUtf8(vector<int>& data) {

FILE: algorithms/cpp/accountsMerge/AccountsMerge.cpp
  class Solution_Time_Limit_Exceeded (line 45) | class Solution_Time_Limit_Exceeded {
    method accountsMerge (line 50) | vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
    method string (line 85) | string find(unordered_map<string, string>& emails_chains,
    method join (line 93) | bool join(unordered_map<string, string>& emails_chains,
  class Solution (line 112) | class Solution {
    method accountsMerge (line 117) | vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
    method find (line 161) | int find(unordered_map<int, int>& emails_chains, int id) {
    method join (line 168) | bool join(unordered_map<int, int>& emails_chains, int id1, int id2) {

FILE: algorithms/cpp/addAndSearchWord/AddAndSearchWord.cpp
  class TrieNode (line 42) | class TrieNode {
    method TrieNode (line 44) | TrieNode():isWord(false) {
    method TrieNode (line 47) | TrieNode* & operator [] (char idx){
    method TrieNode (line 51) | TrieNode* & operator [] (int idx){
  class TrieTree (line 62) | class TrieTree {
    method TrieTree (line 64) | TrieTree():root(new TrieNode()){ }
    method put (line 67) | void put(string &s) {
    method search (line 77) | bool search(string &s){
    method get (line 83) | bool get(string &s, TrieNode* root, int idx=0){
    method freeTree (line 114) | void freeTree(TrieNode* root){
  class WordDictionary (line 125) | class WordDictionary {
    method addWord (line 129) | void addWord(string word) {
    method search (line 135) | bool search(string word) {
  function main (line 147) | int main()

FILE: algorithms/cpp/addBinary/addBinary.cpp
  function string (line 21) | string addBinary(string a, string b) {
  function main (line 41) | int main(int argc, char** argv)

FILE: algorithms/cpp/addDigits/addDigits.cpp
  class Solution (line 16) | class Solution {
    method addDigits (line 19) | int addDigits(int num) {
    method addDigits01 (line 31) | int addDigits01(int num) {
    method addDigits02 (line 43) | int addDigits02(int num) {
    method addDigits03 (line 74) | int addDigits03(int num) {
    method addDigits04 (line 79) | int addDigits04(int num){
    method addDigits05 (line 84) | int addDigits05(int num){

FILE: algorithms/cpp/addStrings/AddStrings.cpp
  class Solution (line 19) | class Solution {
    method string (line 21) | string addStrings(string num1, string num2) {

FILE: algorithms/cpp/addToArrayFormOfInteger/AddToArrayFormOfInteger.cpp
  class Solution (line 45) | class Solution {
    method addToArrayForm (line 47) | vector<int> addToArrayForm(vector<int>& A, int K) {

FILE: algorithms/cpp/addTwoNumbers/addTwoNumbers.cpp
  class Solution (line 24) | class Solution {
    method ListNode (line 27) | ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
    method getValueAndMoveNext (line 52) | int getValueAndMoveNext(ListNode* &l){

FILE: algorithms/cpp/additiveNumber/AdditiveNumber.cpp
  class Solution (line 35) | class Solution {
    method isAdditiveNumber (line 37) | bool isAdditiveNumber(string num) {
    method isAdditiveNumberHelper (line 54) | bool isAdditiveNumberHelper(string& n1, string& n2, string& n3){
    method string (line 71) | string StringAdd(string n1, string n2) {

FILE: algorithms/cpp/anagrams/GroupAnagrams.cpp
  class Solution (line 30) | class Solution {
    method groupAnagrams (line 32) | vector< vector<string> > groupAnagrams(vector<string> &strs) {
    method groupAnagrams01 (line 56) | vector< vector<string> > groupAnagrams01(vector<string> &strs) {
    method anagrams (line 74) | vector<string> anagrams(vector<string> &strs) {

FILE: algorithms/cpp/anagrams/ValidAnagram.cpp
  class Solution (line 19) | class Solution {
    method isAnagram01 (line 23) | bool isAnagram01(string s, string t) {
    method isAnagram02 (line 30) | bool isAnagram02(string s, string t) {
    method isAnagram (line 52) | bool isAnagram(string s, string t) {

FILE: algorithms/cpp/arithmeticSlices/ArithmeticSlices.cpp
  class Solution (line 34) | class Solution {
    method sum1toN (line 55) | int sum1toN(int n) {
    method numberOfArithmeticSlices (line 59) | int numberOfArithmeticSlices(vector<int>& A) {

FILE: algorithms/cpp/backspaceStringCompare/BackspaceStringCompare.cpp
  class Solution (line 64) | class Solution {
    method removeBackspaces (line 66) | void removeBackspaces(string &s) {
    method backspaceCompare (line 78) | bool backspaceCompare(string S, string T) {

FILE: algorithms/cpp/balancedBinaryTree/balancedBinaryTree.cpp
  class Solution (line 24) | class Solution {
    method isBalanced (line 26) | bool isBalanced(TreeNode *root) {
    method isBalancedUtil (line 31) | bool isBalancedUtil(TreeNode* root, int& height){
    method isBalanced (line 50) | bool isBalanced(TreeNode *root) {
    method treeDepth (line 62) | int treeDepth(TreeNode *root) {
  class Solution (line 48) | class Solution {
    method isBalanced (line 26) | bool isBalanced(TreeNode *root) {
    method isBalancedUtil (line 31) | bool isBalancedUtil(TreeNode* root, int& height){
    method isBalanced (line 50) | bool isBalanced(TreeNode *root) {
    method treeDepth (line 62) | int treeDepth(TreeNode *root) {

FILE: algorithms/cpp/basicCalculator/BasicCalculator.II.cpp
  function isOperator (line 37) | bool isOperator(const char ch) {
  function Priority (line 42) | int Priority(const char c) {
  function calculate_exp (line 52) | long long calculate_exp(long long x, long long y, char op) {
  function calculate_two_stacks (line 64) | int calculate_two_stacks(string& s) {
  function calculate (line 108) | int calculate(string s) {
  function main (line 112) | int main(int argc, char**argv)

FILE: algorithms/cpp/basicCalculator/BasicCalculator.cpp
  class Expression (line 41) | class Expression
  class Number (line 48) | class Number: public Expression
    method Number (line 52) | Number(string num) { this->number = atoi(num.c_str()); }
    method interpret (line 54) | int interpret() { return number; }
  class Plus (line 59) | class Plus : public Expression
    method Plus (line 62) | Plus(Expression* left, Expression* right) :leftOperand(left), rightOpe...
    method interpret (line 64) | int interpret() { return leftOperand->interpret() + rightOperand->inte...
  class Minus (line 70) | class Minus : public Expression
    method Minus (line 73) | Minus(Expression* left, Expression* right) :leftOperand(left), rightOp...
    method interpret (line 75) | int interpret() { return leftOperand->interpret() - rightOperand->inte...
  class Multiply (line 81) | class Multiply : public Expression
    method Multiply (line 84) | Multiply(Expression* left, Expression* right) :leftOperand(left), righ...
    method interpret (line 86) | int interpret() { return leftOperand->interpret() * rightOperand->inte...
  class Divide (line 92) | class Divide : public Expression
    method Divide (line 95) | Divide(Expression* left, Expression* right) :leftOperand(left), rightO...
    method interpret (line 97) | int interpret() { return leftOperand->interpret() / rightOperand->inte...
  function isOperator (line 103) | bool isOperator(const string &c) {
  function isOperator (line 106) | bool isOperator(const char &c) {
  class Evaluator (line 110) | class Evaluator : public Expression
    method Evaluator (line 116) | Evaluator(vector<string>& s)
    method interpret (line 144) | int interpret() {
  function Parse (line 152) | vector<string> Parse(string& s){
  function Priority (line 175) | int Priority(const string &c) {
  function Infix2RPN (line 185) | vector<string> Infix2RPN(vector<string>& infix) {
  function calculate_RPN_design_pattern (line 218) | int calculate_RPN_design_pattern(string& s) {
  function calculate_RPN_evluation (line 240) | int calculate_RPN_evluation(string& s) {
  function calculate_two_stacks (line 262) | inline void calculate_two_stacks(stack<int>& num_stack, stack<char>& op_...
  function calculate_two_stacks (line 269) | int calculate_two_stacks(string& s) {
  function calculate (line 298) | int calculate(string s) {
  function main (line 304) | int main(int argc, char** argv) {

FILE: algorithms/cpp/bestTimeToBuyAndSellStock/BestTimeToBuyAndSellStockWithCooldown.cpp
  class Solution (line 22) | class Solution {
    method maxProfit (line 41) | int maxProfit(vector<int>& prices) {

FILE: algorithms/cpp/bestTimeToBuyAndSellStock/BestTimeToBuyAndSellStockWithTransactionFee.cpp
  class Solution (line 33) | class Solution {
    method max (line 35) | int max(int x, int y) {
    method max (line 38) | int max(int x, int y, int z) {
    method maxProfit (line 44) | int maxProfit(vector<int>& prices, int fee) {
    method genPricesPairs (line 52) | void genPricesPairs(vector<int> &prices, vector< pair<int, int> > &pri...
    method maxProfit_dp01 (line 74) | int maxProfit_dp01(vector<int> &prices, int &fee) {
    method maxProfit_dp02 (line 93) | int maxProfit_dp02(vector<int> &prices, int &fee) {
    method maxProfit_dp03 (line 187) | int maxProfit_dp03(vector<int> &prices, int &fee) {

FILE: algorithms/cpp/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.II.cpp
  class Solution (line 37) | class Solution {
    method maxProfit (line 39) | int maxProfit(vector<int>& prices) {
    method maxProfit01 (line 47) | int maxProfit01(vector<int> &prices) {
    method maxProfit02 (line 74) | int maxProfit02(vector<int>& prices) {

FILE: algorithms/cpp/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.III.cpp
  class Solution (line 37) | class Solution {
    method maxProfit (line 51) | int maxProfit(vector<int> &prices) {

FILE: algorithms/cpp/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.IV.cpp
  class Solution (line 29) | class Solution {
    method maxProfit (line 52) | int maxProfit(int k, vector<int> &prices) {
    method maxProfit_DP01 (line 79) | int maxProfit_DP01 (int k, vector<int> &prices) {
    method maxProfit_DP02 (line 98) | int maxProfit_DP02 (int k, vector<int> &prices) {
    method maxProfit_DP03 (line 119) | int maxProfit_DP03 (int k, vector<int> &prices) {

FILE: algorithms/cpp/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.cpp
  class Solution (line 29) | class Solution {
    method maxProfit (line 44) | int maxProfit(vector<int> &prices) {
    method maxProfit (line 72) | int maxProfit(vector<int>& prices) {
  class Solution (line 70) | class Solution {
    method maxProfit (line 44) | int maxProfit(vector<int> &prices) {
    method maxProfit (line 72) | int maxProfit(vector<int>& prices) {

FILE: algorithms/cpp/binarySearchTreeIterator/binarySearchTreeIterator.cpp
  class BSTIterator (line 17) | class BSTIterator {
    method BSTIterator (line 23) | BSTIterator(TreeNode *root) {
    method hasNext (line 40) | bool hasNext() {
    method next (line 45) | int next() {

FILE: algorithms/cpp/binaryTreeInorderTraversal/binaryTreeInorderTraversal.cpp
  class Solution (line 53) | class Solution {
    method inorderTraversal (line 55) | vector<int> inorderTraversal(TreeNode *root) {

FILE: algorithms/cpp/binaryTreeLevelOrderTraversal/binaryTreeLevelOrderTraversal.II.cpp
  class Solution (line 58) | class Solution {
    method levelOrderBottom (line 60) | vector<vector<int> > levelOrderBottom(TreeNode *root) {

FILE: algorithms/cpp/binaryTreeLevelOrderTraversal/binaryTreeLevelOrderTraversal.cpp
  type TreeNode (line 59) | struct TreeNode {
    method TreeNode (line 63) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function levelOrder (line 71) | vector<vector<int> > levelOrder(TreeNode *root) {
  function levelOrder1 (line 81) | vector<vector<int> > levelOrder1(TreeNode *root) {
  function levelOrder2 (line 125) | vector<vector<int> > levelOrder2(TreeNode *root) {
  function levelOrder3 (line 156) | vector<vector<int> > levelOrder3(TreeNode *root) {
  function printTree (line 185) | void printTree(TreeNode *root)
  function printTree_level_order (line 197) | void printTree_level_order(TreeNode *root)
  function TreeNode (line 215) | TreeNode* createTree(int a[], int n)
    method TreeNode (line 63) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function printMatrix (line 240) | int printMatrix(vector< vector<int> > &vv)
  function main (line 251) | int main()

FILE: algorithms/cpp/binaryTreeMaximumPathSum/binaryTreeMaximumPathSum.cpp
  type TreeNode (line 28) | struct TreeNode {
    method TreeNode (line 32) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function maxPathSum (line 36) | int maxPathSum(TreeNode *root, int& maxSum ) {
  function maxPathSum (line 60) | int maxPathSum(TreeNode *root) {
  function main (line 67) | int main()

FILE: algorithms/cpp/binaryTreePaths/binaryTreePaths.cpp
  class Solution (line 34) | class Solution {
    method DFS (line 37) | void DFS(TreeNode* node, string answer)
    method binaryTreePaths (line 50) | vector<string> binaryTreePaths(TreeNode* root) {
    method binaryTreePathsHelper (line 68) | void binaryTreePathsHelper(TreeNode* root, vector<int> solution, vecto...
    method binaryTreePaths (line 89) | vector<string> binaryTreePaths(TreeNode* root) {
  class Solution (line 66) | class Solution {
    method DFS (line 37) | void DFS(TreeNode* node, string answer)
    method binaryTreePaths (line 50) | vector<string> binaryTreePaths(TreeNode* root) {
    method binaryTreePathsHelper (line 68) | void binaryTreePathsHelper(TreeNode* root, vector<int> solution, vecto...
    method binaryTreePaths (line 89) | vector<string> binaryTreePaths(TreeNode* root) {

FILE: algorithms/cpp/binaryTreePostorderTraversal/binaryTreePostorderTraversal.cpp
  type TreeNode (line 32) | struct TreeNode {
    method TreeNode (line 36) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function postorderTraversal (line 47) | vector<int> postorderTraversal(TreeNode *root) {
  function postorderTraversal1 (line 57) | vector<int> postorderTraversal1(TreeNode *root) {
  function postorderTraversal2 (line 80) | vector<int> postorderTraversal2(TreeNode *root) {
  function TreeNode (line 108) | TreeNode* createTree(int a[], int n)
    method TreeNode (line 36) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function printTree_post_order (line 133) | void printTree_post_order(TreeNode *root)
  function printArray (line 145) | void printArray(vector<int> v)
  function main (line 153) | int main()

FILE: algorithms/cpp/binaryTreePreorderTraversal/binaryTreePreorderTraversal.cpp
  type TreeNode (line 31) | struct TreeNode {
    method TreeNode (line 35) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function preorderTraversal (line 41) | vector<int> preorderTraversal(TreeNode *root) {
  function preorderTraversal1 (line 50) | vector<int> preorderTraversal1(TreeNode *root) {
  function preorderTraversal2 (line 70) | vector<int> preorderTraversal2(TreeNode *root) {
  function TreeNode (line 91) | TreeNode* createTree(int a[], int n)
    method TreeNode (line 35) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function printTree_pre_order (line 116) | void printTree_pre_order(TreeNode *root)
  function printArray (line 128) | void printArray(vector<int> v)
  function main (line 136) | int main()

FILE: algorithms/cpp/binaryTreeRightSideView/binaryTreeRightSideView.cpp
  class Solution (line 34) | class Solution {
    method rightSideViewHelper (line 36) | void rightSideViewHelper(TreeNode* root, int level, vector<int>& resul...
    method rightSideViewHelper (line 43) | void rightSideViewHelper(TreeNode* root, vector<int>& result) {
    method rightSideView (line 67) | vector<int> rightSideView(TreeNode *root) {

FILE: algorithms/cpp/binaryTreeUpsideDown/binaryTreeUpsideDown.cpp
  class Solution (line 39) | class Solution {
    method TreeNode (line 41) | TreeNode *upsideDownBinaryTree(TreeNode *root) {

FILE: algorithms/cpp/binaryTreeZigzagLevelOrderTraversal/binaryTreeZigzagLevelOrderTraversal.cpp
  type TreeNode (line 57) | struct TreeNode {
    method TreeNode (line 61) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function zigzagLevelOrder (line 66) | vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
  function zigzagLevelOrder1 (line 73) | vector<vector<int> > zigzagLevelOrder1(TreeNode *root) {
  function TreeToArray_level_order (line 109) | vector<TreeNode*> TreeToArray_level_order(TreeNode* root){
  function zigzagLevelOrder2 (line 130) | vector<vector<int> > zigzagLevelOrder2(TreeNode *root) {
  function printTree_level_order (line 159) | void printTree_level_order(TreeNode *root)
  function TreeNode (line 177) | TreeNode* createTree(int a[], int n)
    method TreeNode (line 61) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function printMatrix (line 202) | int printMatrix(vector< vector<int> > &vv)
  function main (line 214) | int main(int argc, char** argv)

FILE: algorithms/cpp/binaryWatch/BinaryWatch.cpp
  class Solution (line 29) | class Solution {
    method combination (line 31) | void combination(int nLED, int nLight, int max, bool zero,
    method generate_combination (line 54) | void generate_combination(int nLED, int max, bool zero, vector<vector<...
    method print (line 60) | void print(vector<vector<string>>&  vv) {
    method Solution (line 76) | Solution():hour(4, vector<string>()), mins(6, vector<string>()){
    method readBinaryWatch (line 95) | vector<string> readBinaryWatch(int num) {

FILE: algorithms/cpp/bitwiseANDOfNumbersRange/BitwiseAndOfNumbersRange.cpp
  function rangeBitwiseAnd (line 41) | int rangeBitwiseAnd(int m, int n) {
  function main (line 56) | int main(int argc, char**argv) {

FILE: algorithms/cpp/brokenCalculator/BrokenCalculator.cpp
  class Solution (line 47) | class Solution {
    method brokenCalc (line 49) | int brokenCalc(int X, int Y) {

FILE: algorithms/cpp/buddyStrings/BuddyStrings.cpp
  class Solution (line 69) | class Solution {
    method buddyStrings (line 71) | bool buddyStrings(string A, string B) {

FILE: algorithms/cpp/buildingBoxes/BuildingBoxes.cpp
  class Solution (line 85) | class Solution {
    method total (line 87) | int total(long h){
    method minimumBoxes (line 91) | int minimumBoxes(int n) {

FILE: algorithms/cpp/bulbSwitcher/BulbSwitcher.II.cpp
  class Solution (line 77) | class Solution {
    method flipLights (line 79) | int flipLights(int n, int m) {

FILE: algorithms/cpp/bulbSwitcher/BulbSwitcher.III.cpp
  class Solution (line 51) | class Solution {
    method numTimesAllBlue (line 53) | int numTimesAllBlue(vector<int>& light) {

FILE: algorithms/cpp/bulbSwitcher/BulbSwitcher.IV.cpp
  class Solution (line 54) | class Solution {
    method minFlips (line 56) | int minFlips(string target) {

FILE: algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp
  class Solution (line 47) | class Solution {
    method bulbSwitch (line 49) | int bulbSwitch(int n) {
    method bulbSwitch (line 77) | int bulbSwitch(int n) {
  class Solution (line 75) | class Solution {
    method bulbSwitch (line 49) | int bulbSwitch(int n) {
    method bulbSwitch (line 77) | int bulbSwitch(int n) {

FILE: algorithms/cpp/bullsAndCows/bullsAndCows.cpp
  class Solution (line 37) | class Solution {
    method string (line 39) | string getHint(string secret, string guess) {
    method string (line 44) | string getHint01(string secret, string guess) {
    method string (line 64) | string getHint02(string secret, string guess) {

FILE: algorithms/cpp/burstBalloons/BurstBalloons.cpp
  class Solution (line 37) | class Solution {
    method maxCoins (line 39) | int maxCoins(vector<int>& nums) {
    method maxCoins_DC (line 66) | int maxCoins_DC(vector<int>& nums, vector<vector<int>>& matrix, int lo...
    method maxCoins_DP (line 83) | int maxCoins_DP(vector<int>& nums, vector<vector<int>>& dp) {
    method printVector (line 97) | void printVector(vector<int>& nums) {

FILE: algorithms/cpp/calculateMoneyInLeetcodeBank/CalculateMoneyInLeetcodeBank.cpp
  class Solution (line 41) | class Solution {
    method totalMoney (line 43) | int totalMoney(int n) {

FILE: algorithms/cpp/candy/candy.cpp
  function candy (line 54) | int candy(vector<int> &ratings) {
  function generateRatings (line 74) | void generateRatings(vector<int> &ratings, int n) {
  function print (line 81) | void print(vector<int> &v) {
  function main (line 88) | int main(int argc, char**argv)

FILE: algorithms/cpp/checkIfArrayIsSortedAndRotated/CheckIfArrayIsSortedAndRotated.cpp
  class Solution (line 55) | class Solution {
    method check (line 57) | bool check(vector<int>& nums) {

FILE: algorithms/cpp/checkIfBinaryStringHasAtMostOneSegmentOfOnes/CheckIfBinaryStringHasAtMostOneSegmentOfOnes.cpp
  class Solution (line 28) | class Solution {
    method checkOnesSegment (line 30) | bool checkOnesSegment(string s) {

FILE: algorithms/cpp/checkIfNumberIsASumOfPowersOfThree/CheckIfNumberIsASumOfPowersOfThree.cpp
  class Solution (line 34) | class Solution {
    method checkPowersOfThree (line 36) | bool checkPowersOfThree(int n) {
    method checkPowersOfThree_DFS (line 41) | bool checkPowersOfThree_DFS(int n, int p) {
    method checkPowersOfThree_Base3 (line 59) | bool checkPowersOfThree_Base3(int n) {

FILE: algorithms/cpp/checkIfOneStringSwapCanMakeStringsEqual/CheckIfOneStringSwapCanMakeStringsEqual.cpp
  class Solution (line 43) | class Solution {
    method areAlmostEqual (line 45) | bool areAlmostEqual(string s1, string s2) {

FILE: algorithms/cpp/checkIfTheSentenceIsPangram/CheckIfTheSentenceIsPangram.cpp
  class Solution (line 29) | class Solution {
    method checkIfPangram (line 31) | bool checkIfPangram(string sentence) {

FILE: algorithms/cpp/checkIfWordEqualsSummationOfTwoWords/CheckIfWordEqualsSummationOfTwoWords.cpp
  class Solution (line 59) | class Solution {
    method strToInt (line 61) | int strToInt(string& str) {
    method isSumEqual (line 68) | bool isSumEqual(string firstWord, string secondWord, string targetWord) {

FILE: algorithms/cpp/climbStairs/climbStairs.cpp
  class Solution (line 14) | class Solution {
    method climbStairs (line 17) | int climbStairs(int n) {
    method climbStairs2 (line 28) | int climbStairs2(int n) {

FILE: algorithms/cpp/cloneGraph/cloneGraph.cpp
  class Solution (line 43) | class Solution {
    method UndirectedGraphNode (line 45) | UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {

FILE: algorithms/cpp/closestDessertCost/ClosestDessertCost.cpp
  class Solution (line 70) | class Solution {
    method abs_min (line 72) | int abs_min (int x, int y, int z) {
    method abs_min (line 77) | int abs_min(int x, int y) {
    method closestCost (line 84) | int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int...
    method closetToppingCost (line 95) | int closetToppingCost(vector<int>& costs, int target, int idx ){

FILE: algorithms/cpp/closestRoom/ClosestRoom.cpp
  class Solution (line 55) | class Solution {
    method print (line 57) | void print(vector<vector<int>>& vv) {
    method closestRoom (line 66) | vector<int> closestRoom(vector<vector<int>>& rooms, vector<vector<int>...

FILE: algorithms/cpp/closestSubsequenceSum/ClosestSubsequenceSum.cpp
  class Solution (line 44) | class Solution {
    method abs (line 46) | int abs(int n){
    method printSet (line 50) | void printSet(set<int>& s){
    method findClosetDiff (line 58) | int findClosetDiff(set<int>& sums, int goal) {
    method getAllSums (line 71) | void getAllSums(int index, int end, vector<int>& nums, int sum, set<in...
    method getAllSums (line 80) | void getAllSums(int start, int end, vector<int>& nums, set<int>& sums) {
    method minAbsDifference (line 91) | int minAbsDifference(vector<int>& nums, int goal) {

FILE: algorithms/cpp/coinChange/CoinChange2.cpp
  class Solution (line 42) | class Solution {
    method change (line 44) | int change(int amount, vector<int>& coins) {
    method change_recursive (line 50) | int change_recursive(int amount, vector<int>& coins) {
    method change_recursive_helper (line 57) | void change_recursive_helper(int amount, vector<int>& coins, int idx, ...
    method change_dp (line 70) | int change_dp(int amount, vector<int>& coins) {

FILE: algorithms/cpp/coinChange/coinChange.cpp
  function Solution (line 31) | class Solution {
    method coinChange (line 88) | int coinChange(vector<int>& coins, int amount) {
  class Solution (line 86) | class Solution {
    method coinChange (line 88) | int coinChange(vector<int>& coins, int amount) {

FILE: algorithms/cpp/combinationSum/combinationSum.II.cpp
  function combinationSumHelper (line 35) | void combinationSumHelper(vector<int> &candidates, int start, int target...
  function combinationSum2 (line 55) | vector<vector<int> > combinationSum2(vector<int> &candidates, int target) {
  function printMatrix (line 68) | void printMatrix(vector< vector<int> > &vv)
  function printArray (line 79) | void printArray(vector<int> &v)
  function test (line 88) | void test(int a[], int len, int target)
  function main (line 99) | int main(int argc, char** argv)

FILE: algorithms/cpp/combinationSum/combinationSum.III.cpp
  function combinationSumHelper (line 31) | void combinationSumHelper(vector<int>& candidates, int start, int num, i...
  function combinationSum3 (line 48) | vector< vector<int> > combinationSum3(int k, int n) {
  function PrintResults (line 63) | void PrintResults(int k, int n, vector< vector<int> >& results) {
  function main (line 75) | int main(int argc, char** argv)

FILE: algorithms/cpp/combinationSum/combinationSum.cpp
  function combinationSumHelper (line 32) | void combinationSumHelper(vector<int> &candidates, int start, int target...
  function combinationSum (line 51) | vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
  function printMatrix (line 64) | void printMatrix(vector< vector<int> > &vv)
  function printArray (line 75) | void printArray(vector<int> &v)
  function main (line 85) | int main(int argc, char** argv)

FILE: algorithms/cpp/combinationSumIV/combinationSumIV.cpp
  class Solution (line 52) | class Solution {
    method combinationSum4 (line 54) | int combinationSum4(vector<int>& nums, int target) {

FILE: algorithms/cpp/combinations/combinations.cpp
  function combine (line 36) | vector<vector<int> > combine(int n, int k) {
  function combine1 (line 45) | vector<vector<int> > combine1(int n, int k) {
  function getCombination (line 52) | void getCombination(int n, int k, vector<int>& solution, vector< vector<...
  function combine2 (line 67) | vector<vector<int> > combine2(int n, int k) {
  function printResult (line 114) | void printResult(vector<vector<int> >& result)
  function main (line 125) | int main(int argc, char** argv)

FILE: algorithms/cpp/compareStringsByFrequencyOfTheSmallestCharacter/CompareStringsByFrequencyOfTheSmallestCharacter.cpp
  class Solution (line 35) | class Solution {
    method numSmallerByFrequency (line 37) | vector<int> numSmallerByFrequency(vector<string>& queries, vector<stri...
    method f (line 52) | int f(string& s) {
    method binary_search (line 66) | int binary_search(vector<int> &v, int target) {

FILE: algorithms/cpp/compareVersionNumbers/compareVersionNumbers.cpp
  class Solution (line 21) | class Solution {
    method split (line 33) | vector<int> split(const string &s, char delim) {
    method rightTrimZero (line 39) | void rightTrimZero(vector<int> &v){
    method compareVersion (line 45) | int compareVersion(string version1, string version2) {

FILE: algorithms/cpp/constructBinaryTreeFromInorderAndPostorderTraversal/constructBinaryTreeFromInorderAndPostorderTraversal.cpp
  type TreeNode (line 20) | struct TreeNode {
    method TreeNode (line 24) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function TreeNode (line 29) | TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
    method TreeNode (line 24) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function TreeNode (line 34) | TreeNode *buildTree(vector<int> &inorder, int in_offset, vector<int> &po...
    method TreeNode (line 24) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function TreeNode (line 63) | TreeNode *buildTree2(vector<int> &inorder, vector<int> &postorder) {
    method TreeNode (line 24) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function printTree_pre_order (line 102) | void printTree_pre_order(TreeNode *root)
  function printTree_in_order (line 114) | void printTree_in_order(TreeNode *root)
  function printTree_level_order (line 127) | void printTree_level_order(TreeNode *root)
  function main (line 146) | int main()

FILE: algorithms/cpp/constructBinaryTreeFromPreorderAndInorderTraversal/constructBinaryTreeFromPreorderAndInorderTraversal.cpp
  type TreeNode (line 20) | struct TreeNode {
    method TreeNode (line 24) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function TreeNode (line 29) | TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
    method TreeNode (line 24) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function TreeNode (line 34) | TreeNode *buildTree(vector<int>& preorder, int& preidx, vector<int>& ino...
    method TreeNode (line 24) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function printTree_pre_order (line 74) | void printTree_pre_order(TreeNode *root)
  function printTree_in_order (line 86) | void printTree_in_order(TreeNode *root)
  function printTree_level_order (line 99) | void printTree_level_order(TreeNode *root)
  function main (line 118) | int main()

FILE: algorithms/cpp/constructTheLexicographicallyLargestValidSequence/ConstructTheLexicographicallyLargestValidSequence.cpp
  class Solution (line 42) | class Solution {
    method print (line 44) | void print(vector<int>& v) {
    method constructDistancedSequence (line 52) | vector<int> constructDistancedSequence(int n) {
    method dfs (line 62) | bool dfs(vector<bool>& available, vector<int>& result, int pos, int cnt){

FILE: algorithms/cpp/containerWithMostWater/containerWithMostWater.cpp
  class Solution (line 17) | class Solution {
    method maxArea (line 19) | int maxArea(vector<int> &height) {

FILE: algorithms/cpp/containsDuplicate/ContainsDuplicate.II.cpp
  class Solution (line 14) | class Solution {
    method containsNearbyDuplicate (line 16) | bool containsNearbyDuplicate(vector<int>& nums, int k) {

FILE: algorithms/cpp/containsDuplicate/ContainsDuplicate.III.cpp
  class Solution (line 15) | class Solution {
    method containsNearbyAlmostDuplicate (line 17) | bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {

FILE: algorithms/cpp/containsDuplicate/ContainsDuplicate.cpp
  class Solution (line 14) | class Solution {
    method containsDuplicate (line 16) | bool containsDuplicate(vector<int>& nums) {

FILE: algorithms/cpp/convertANumberToHexadecimal/ConvertANumberToHexadecimal.cpp
  class Solution (line 37) | class Solution {
    method string (line 40) | string toHex(int num) {

FILE: algorithms/cpp/convertSortedArrayToBinarySearchTree/convertSortedArrayToBinarySearchTree.cpp
  class Solution (line 20) | class Solution {
    method TreeNode (line 22) | TreeNode *sortedArrayToBST(vector<int> &num) {

FILE: algorithms/cpp/convertSortedListToBinarySearchTree/convertSortedListToBinarySearchTree.cpp
  type ListNode (line 19) | struct ListNode {
    method ListNode (line 22) | ListNode(int x) : val(x), next(NULL) {}
  type TreeNode (line 26) | struct TreeNode {
    method TreeNode (line 30) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function TreeNode (line 36) | TreeNode *sortedListToBST(ListNode *head) {
    method TreeNode (line 30) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function TreeNode (line 45) | TreeNode* sortedListToBST(int low, int high, ListNode*& head) {
    method TreeNode (line 30) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function printTree_level_order (line 62) | void printTree_level_order(TreeNode *root)
  function ListNode (line 80) | ListNode* createList(int a[], int n)
    method ListNode (line 22) | ListNode(int x) : val(x), next(NULL) {}
  function printList (line 94) | void printList(ListNode* h)
  function main (line 104) | int main(int argc, char** argv)

FILE: algorithms/cpp/copyListWithRandomPointer/copyListWithRandomPointer.cpp
  class Solution (line 69) | class Solution {
    method RandomListNode (line 71) | RandomListNode *copyRandomList(RandomListNode *head) {
  class MySolution (line 147) | class MySolution {
    method RandomListNode (line 149) | RandomListNode *copyRandomList(RandomListNode *head) {

FILE: algorithms/cpp/countAndSay/countAndSay.cpp
  function string (line 28) | string vecToStr(vector<int> v) {
  function getNext (line 36) | vector<int> getNext(vector<int>& v) {
  function string (line 63) | string countAndSay(int n) {
  function main (line 79) | int main(int argc, char** argv)

FILE: algorithms/cpp/countCompleteTreeNodes/CountCompleteTreeNodes.cpp
  class Solution (line 28) | class Solution {
    method isCompleteTree (line 31) | int isCompleteTree(TreeNode* root) {
    method countNodes (line 46) | int countNodes(TreeNode* root) {

FILE: algorithms/cpp/countGoodMeals/CountGoodMeals.cpp
  class Solution (line 38) | class Solution {
    method countPairs (line 40) | int countPairs(vector<int>& deliciousness) {

FILE: algorithms/cpp/countItemsMatchingARule/CountItemsMatchingARule.cpp
  class Solution (line 43) | class Solution {
    method countMatches (line 45) | int countMatches(vector<vector<string>>& items, string ruleKey, string...

FILE: algorithms/cpp/countNicePairsInAnArray/CountNicePairsInAnArray.cpp
  class Solution (line 36) | class Solution {
    method rev (line 38) | int rev(int n) {
    method countNicePairs (line 48) | int countNicePairs(vector<int>& nums) {
    method countNicePairs01 (line 52) | int countNicePairs01(vector<int>& nums) {
    method countNicePairs02 (line 72) | int countNicePairs02(vector<int>& nums) {

FILE: algorithms/cpp/countNumberOfHomogenousSubstrings/CountNumberOfHomogenousSubstrings.cpp
  class Solution (line 45) | class Solution {
    method countHomogenous (line 47) | int countHomogenous(string s) {

FILE: algorithms/cpp/countNumbersWithUniqueDigits/CountNumbersWithUniqueDigits.cpp
  class Solution (line 35) | class Solution {
    method countNumbersWithUniqueDigits (line 37) | int countNumbersWithUniqueDigits(int n) {
    method nine_factor (line 45) | int nine_factor(int n) {
    method countNumbersWithUniqueDigits (line 59) | int countNumbersWithUniqueDigits(int n) {
  class Solution (line 57) | class Solution {
    method countNumbersWithUniqueDigits (line 37) | int countNumbersWithUniqueDigits(int n) {
    method nine_factor (line 45) | int nine_factor(int n) {
    method countNumbersWithUniqueDigits (line 59) | int countNumbersWithUniqueDigits(int n) {

FILE: algorithms/cpp/countOddNumbersInAnIntervalRange/CountOddNumbersInAnIntervalRange.cpp
  class Solution (line 27) | class Solution {
    method countOdds1 (line 29) | int countOdds1(int low, int high) {
    method countOdds2 (line 35) | int countOdds2(int low, int high) {
    method countOdds (line 38) | int countOdds(int low, int high) {

FILE: algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp
  class Node (line 73) | class Node{
    method Node (line 78) | Node(long long v):val(v), cnt(1), left(NULL), right(NULL) {}
  class Tree (line 82) | class Tree{
    method Tree (line 84) | Tree():root(NULL){ }
    method Insert (line 87) | void Insert(long long val) {
    method LessThan (line 90) | int LessThan(long long sum, int val) {
    method Insert (line 98) | void Insert(Node* &root, long long val) {
    method LessThan (line 115) | int LessThan(Node* root, long long sum, int val, int res) {
    method freeTree (line 134) | void freeTree(Node* root){
  class Solution (line 145) | class Solution {
    method countRangeSum (line 147) | int countRangeSum(vector<int>& nums, int lower, int upper) {

FILE: algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp
  class Solution (line 31) | class Solution {
    method search (line 35) | int search(int t)
    method compute (line 45) | int compute(int t)
    method add (line 52) | void add(int t)
    method countSmaller (line 57) | vector<int> countSmaller(vector<int>& nums) {
    method countSmaller (line 139) | vector<int> countSmaller(vector<int>& nums) {
  class BinarySearchTreeNode (line 83) | class BinarySearchTreeNode
    method BinarySearchTreeNode (line 90) | BinarySearchTreeNode(int value) : val(value), less(0),count(1),left(NU...
  class BinarySearchTree (line 93) | class BinarySearchTree
    method BinarySearchTree (line 98) | BinarySearchTree(const int value):root(new BinarySearchTreeNode(value)...
    method insert (line 102) | void insert(const int value, int &numLessThan) {
    method freeTree (line 106) | void freeTree(BinarySearchTreeNode* root){
    method insert (line 113) | void insert(BinarySearchTreeNode* root, const int value, int &numLessT...
  class Solution (line 137) | class Solution {
    method search (line 35) | int search(int t)
    method compute (line 45) | int compute(int t)
    method add (line 52) | void add(int t)
    method countSmaller (line 57) | vector<int> countSmaller(vector<int>& nums) {
    method countSmaller (line 139) | vector<int> countSmaller(vector<int>& nums) {

FILE: algorithms/cpp/countPairsOfNodes/CountPairsOfNodes.cpp
  class Solution (line 107) | class Solution {
    method countPairs (line 109) | vector<int> countPairs(int n, vector<vector<int>>& edges, vector<int>&...

FILE: algorithms/cpp/countPairsWithXorInARange/CountPairsWithXorInARange.cpp
  type TrieNode (line 116) | struct TrieNode {
    method TrieNode (line 119) | TrieNode() {
  function insertTrie (line 127) | void insertTrie(TrieNode *root, int n) {
  class Solution (line 146) | class Solution {
    method countSmallerPairs (line 149) | int countSmallerPairs(TrieNode * root,  int N, int K) {
    method countPairs (line 177) | int countPairs(vector<int>& nums, int low, int high) {

FILE: algorithms/cpp/countPrimes/CountPrimes.cpp
  function countPrimes (line 117) | int countPrimes(int n) {
  function main (line 139) | int main(int argc, char**argv)

FILE: algorithms/cpp/countingBits/CountingBits.cpp
  class Solution (line 31) | class Solution {
    method countBits (line 59) | vector<int> countBits(int num) {

FILE: algorithms/cpp/courseSchedule/CourseSchedule.II.cpp
  class Solution (line 48) | class Solution {
    method topologicalSort (line 51) | bool topologicalSort( int n, vector<int>& explored, vector<int>& path,
    method findOrder (line 79) | vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequi...

FILE: algorithms/cpp/courseSchedule/CourseSchedule.cpp
  class Solution (line 44) | class Solution {
    method hasCycle (line 47) | bool hasCycle(int n, vector<int>& explored, vector<int>& path, map<int...
    method canFinish (line 69) | bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {

FILE: algorithms/cpp/courseSchedule/non-recursive/course_schedule.cpp
  type _node (line 29) | struct _node {
    type _node (line 32) | struct _node
  class Solution (line 35) | class Solution {
    method canFinish (line 37) | bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
    method to_neighbor_repr (line 47) | vector<unordered_set<int>> to_neighbor_repr(int numOfvex, vector<Val>&...
    method dsf (line 62) | bool dsf(int numOfvex, vector<unordered_set<int>>& graph, vector<int>&...

FILE: algorithms/cpp/courseSchedule/non-recursive/main.cpp
  function main (line 17) | int main(int argc, const char * argv[]) {

FILE: algorithms/cpp/cousinsInBinaryTree/CousinsInBinaryTree.cpp
  class Solution (line 47) | class Solution {
    method isCousins (line 49) | bool isCousins(TreeNode* root, int x, int y) {
    method DepthAndParent (line 62) | int DepthAndParent(TreeNode* root, TreeNode*& parent, int depth, int x) {

FILE: algorithms/cpp/createMaximumNumber/CreateMaximumNumber.cpp
  class Solution (line 69) | class Solution {
    method maxNumber (line 71) | vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
    method compareTwoArray (line 88) | bool compareTwoArray(vector<int>& nums1, int start1, vector<int>& nums...
    method mergeTwoArrays (line 99) | vector<int> mergeTwoArrays(vector<int>& nums1, vector<int>& nums2) {
    method findMaxSubArray (line 132) | vector<int> findMaxSubArray(vector<int>& nums, int k) {

FILE: algorithms/cpp/decodeString/DecodeString.cpp
  class Solution (line 27) | class Solution {
    method string (line 29) | string decodeString(string s) {
    method isValid (line 82) | bool isValid(string& s) {
    method isNum (line 101) | bool isNum(char ch) {

FILE: algorithms/cpp/decodeWays/decodeWays.cpp
  function check (line 34) | int check(char ch){
  function check (line 39) | int check(char ch1, char ch2){
  function numDecodings (line 44) | int numDecodings(string s) {
  function main (line 69) | int main(int argc, char**argv)

FILE: algorithms/cpp/decodeXORedPermutation/DecodeXoredPermutation.cpp
  class Solution (line 80) | class Solution {
    method decode (line 82) | vector<int> decode(vector<int>& encoded) {

FILE: algorithms/cpp/deleteNodeInALinkedList/DeleteNodeInALinkedList.cpp
  class Solution (line 23) | class Solution {
    method deleteNode (line 27) | void deleteNode(ListNode* node) {

FILE: algorithms/cpp/designAuthenticationManager/DesignAuthenticationManager.cpp
  class AuthenticationManager (line 63) | class AuthenticationManager {
    method AuthenticationManager (line 69) | AuthenticationManager(int timeToLive):ttl(timeToLive) { }
    method generate (line 71) | void generate(string tokenId, int currentTime) {
    method renew (line 76) | void renew(string tokenId, int currentTime) {
    method countUnexpiredTokens (line 87) | int countUnexpiredTokens(int currentTime) {
    method clean (line 91) | int clean(int expired) {

FILE: algorithms/cpp/detectCapital/DetectCapital.cpp
  class Solution (line 31) | class Solution {
    method is_lower (line 32) | bool is_lower(char ch) {
    method is_upper (line 35) | bool is_upper(char ch) {
    method is_alpha (line 38) | bool is_alpha(char ch) {
    method detectCapitalUse (line 42) | bool detectCapitalUse(string word) {

FILE: algorithms/cpp/determineColorOfAChessboardSquare/DetermineColorOfAChessboardSquare.cpp
  class Solution (line 39) | class Solution {
    method squareIsWhite (line 41) | bool squareIsWhite(string coordinates) {

FILE: algorithms/cpp/diameterOfBinaryTree/diameterOfBinaryTree.cpp
  class Solution (line 15) | class Solution {
    method maxDepth (line 18) | int maxDepth(TreeNode* root) {
    method diameterOfBinaryTree (line 26) | int diameterOfBinaryTree(TreeNode* root) {

FILE: algorithms/cpp/differentWaysToAddParentheses/DifferentWaysToAddParentheses.cpp
  function isOperator (line 39) | bool isOperator(char ch){
  function diffWaysToCompute (line 45) | vector<int> diffWaysToCompute(string input) {
  function printVector (line 89) | void printVector(vector<int>& v) {
  function main (line 97) | int main(int argc, char**argv)

FILE: algorithms/cpp/distinctSubsequences/distinctSubsequences.cpp
  function numDistinct1 (line 94) | int numDistinct1(string S, string T) {
  function numDistinct2 (line 146) | int numDistinct2(string S, string T) {
  function numDistinct (line 172) | int numDistinct(string S, string T) {
  function main (line 183) | int main(int argc, char** argv)

FILE: algorithms/cpp/distributeCoinsInBinaryTree/DistributeCoinsInBinaryTree.cpp
  class Solution (line 55) | class Solution {
    method distributeCoins (line 57) | int distributeCoins(TreeNode* root) {
    method dfs (line 79) | int dfs(TreeNode* root, int& result) {

FILE: algorithms/cpp/divideTwoInt/divideTwoInt.cpp
  function divide (line 21) | int divide(int dividend, int divisor) {
  function main (line 54) | int main()

FILE: algorithms/cpp/dungeonGame/dungeonGame.cpp
  class Solution (line 48) | class Solution {
    method calculateMinimumHP (line 50) | int calculateMinimumHP(vector<vector<int> > &dungeon) {

FILE: algorithms/cpp/editDistance/editDistance.cpp
  function min (line 81) | int min(int x, int y, int z) {
  function minDistance (line 85) | int minDistance(string word1, string word2) {
  function main (line 115) | int main(int argc, char**argv)

FILE: algorithms/cpp/eggDropWith2EggsAndNFloors/EggDropWith2EggsAndNFloors.cpp
  class Solution (line 79) | class Solution {
    method twoEggDrop (line 81) | int twoEggDrop(int n) {

FILE: algorithms/cpp/eliminationGame/EliminationGame.cpp
  class Solution (line 30) | class Solution {
    method lastRemaining (line 32) | int lastRemaining(int n) {

FILE: algorithms/cpp/equalSumArraysWithMinimumNumberOfOperations/EqualSumArraysWithMinimumNumberOfOperations.cpp
  class Solution (line 50) | class Solution {
    method print (line 52) | void print(vector<int>& n) {
    method minOpsBySort (line 60) | int minOpsBySort(int gaps, vector<int>& small, vector<int>& big) {
    method minOpsByCnt1 (line 84) | int minOpsByCnt1(int gaps, vector<int>& small, vector<int>& big) {
    method minOpsByCnt2 (line 110) | int minOpsByCnt2(int gaps, vector<int>& small, vector<int>& big) {
    method minOperations (line 129) | int minOperations(vector<int>& nums1, vector<int>& nums2) {

FILE: algorithms/cpp/evaluateDivision/EvaluateDivision.cpp
  class Solution (line 28) | class Solution {
    method dfs (line 30) | bool dfs( unordered_map<string, unordered_map<string, double>>& m,
    method calcEquation (line 62) | vector<double> calcEquation(vector<pair<string, string>> equations,

FILE: algorithms/cpp/evaluateReversePolishNotation/evaluateReversePolishNotation.cpp
  class Solution (line 28) | class Solution {
    method evalRPN (line 30) | int evalRPN(vector<string> &tokens) {
    method isOp (line 75) | bool isOp(string &op) {
    method isNum (line 79) | bool isNum(string &num) {
  function main (line 90) | int main()

FILE: algorithms/cpp/evaluateTheBracketPairsOfAString/EvaluateTheBracketPairsOfAString.cpp
  class Solution (line 68) | class Solution {
    method isBracket (line 70) | bool isBracket(char c) {
    method string (line 74) | string evaluate(string s, vector<vector<string>>& knowledge) {

FILE: algorithms/cpp/excelSheetColumnNumber/excelSheetColumnNumber.cpp
  function string (line 31) | string base26_int2str(long long n) {
  function base26_str2int (line 42) | long long base26_str2int(string& s){
  function string (line 52) | string titleToNumber(int n) {
  function main (line 56) | int main(int argc, char**argv)

FILE: algorithms/cpp/excelSheetColumnTitle/excelSheetColumnTitle.cpp
  function string (line 30) | string base26_int2str(long long n) {
  function base26_str2int (line 41) | long long base26_str2int(string& s){
  function string (line 51) | string convertToTitle(int n) {
  function main (line 55) | int main(int argc, char**argv)

FILE: algorithms/cpp/expressionAddOperators/ExpressionAddOperators.cpp
  class Solution (line 23) | class Solution {
    method addOperators (line 25) | vector<string> addOperators(string num, int target) {
    method helper (line 33) | void helper(const string &num, const int target, //`num` and `target` ...

FILE: algorithms/cpp/factorialTrailingZeroes/factorialTrailingZeroes.cpp
  class Solution (line 63) | class Solution {
    method trailingZeroes (line 65) | int trailingZeroes(int n) {
    method trailingZeroes (line 75) | int trailingZeroes(int n) {

FILE: algorithms/cpp/fibonacciNumber/FibonacciNumber.cpp
  class Solution (line 38) | class Solution {
    method fib (line 40) | int fib(int N) {

FILE: algorithms/cpp/filterRestaurantsByVeganFriendlyPriceAndDistance/FilterRestaurantsByVeganFriendlyPriceAndDistance.cpp
  function cmp (line 59) | static bool cmp(const vector<int>& v1, const vector<int>& v2) {
  class Solution (line 62) | class Solution {
    method filterRestaurants (line 64) | vector<int> filterRestaurants(vector<vector<int>>& restaurants, int ve...

FILE: algorithms/cpp/findAllAnagramsInAString/Find-All-Anagrams-in-a-String.cpp
  class Solution (line 38) | class Solution {
    method findAnagrams (line 40) | vector<int> findAnagrams(string s, string p) {

FILE: algorithms/cpp/findKthLargestXorCoordinateValue/FindKthLargestXorCoordinateValue.cpp
  class Solution (line 49) | class Solution {
    method print (line 51) | void print(vector<vector<int>>& m) {
    method kthLargestValue (line 63) | int kthLargestValue(vector<vector<int>>& matrix, int k) {

FILE: algorithms/cpp/findMedianFromDataStream/FindMedianFromDataStream.cpp
  class MedianFinder (line 33) | class MedianFinder {
    method addNum (line 42) | void addNum(int num) {
    method findMedian (line 63) | double findMedian() {

FILE: algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.II.cpp
  function findMin (line 40) | int findMin(vector<int> &num) {
  function rotate_array (line 75) | void rotate_array(int a[], int n, int pos){
  function printArray (line 103) | void printArray(int A[], int n) {
  function main (line 111) | int main(int argc, char** argv)

FILE: algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp
  function findMin (line 29) | int findMin(vector<int> &num) {
  function rotate_array (line 63) | void rotate_array(int a[], int n, int pos){
  function printArray (line 91) | void printArray(int A[], int n) {
  function main (line 99) | int main(int argc, char** argv)

FILE: algorithms/cpp/findNearestPointThatHasTheSameXOrYCoordinate/FindNearestPointThatHasTheSameXOrYCoordinate.cpp
  class Solution (line 45) | class Solution {
    method nearestValidPoint (line 47) | int nearestValidPoint(int x, int y, vector<vector<int>>& points) {

FILE: algorithms/cpp/findPeakElement/findPeakElement.cpp
  function findPeakElement (line 52) | int findPeakElement(const vector<int> &num) {
  function printVector (line 87) | void printVector(vector<int> &n) {
  function test (line 96) | void test(int a[], int n) {
  function main (line 105) | int main(int argc, char**argv)

FILE: algorithms/cpp/findTheDifference/FindTheDifference.cpp
  class Solution (line 27) | class Solution {
    method findTheDifference (line 29) | char findTheDifference(string s, string t) {

FILE: algorithms/cpp/findTheDuplicateNumber/findTheDuplicateNumber.cpp
  class Solution (line 25) | class Solution {
    method findDuplicate (line 33) | int findDuplicate(vector<int>& nums) {

FILE: algorithms/cpp/findTheHighestAltitude/FindTheHighestAltitude.cpp
  class Solution (line 32) | class Solution {
    method largestAltitude (line 34) | int largestAltitude(vector<int>& gain) {

FILE: algorithms/cpp/findTheWinnerOfAnArrayGame/FindTheWinnerOfAnArrayGame.cpp
  class Solution (line 53) | class Solution {
    method getWinner (line 55) | int getWinner(vector<int>& arr, int k) {

FILE: algorithms/cpp/findTheWinnerOfTheCircularGame/FindTheWinnerOfTheCircularGame.cpp
  class Solution (line 50) | class Solution {
    method findTheWinner (line 52) | int findTheWinner(int n, int k) {

FILE: algorithms/cpp/findXorSumOfAllPairsBitwiseAnd/FindXorSumOfAllPairsBitwiseAnd.cpp
  class Solution (line 39) | class Solution {
    method getXORSum (line 41) | int getXORSum(vector<int>& arr1, vector<int>& arr2) {

FILE: algorithms/cpp/findingMkAverage/FindingMkAverage.cpp
  class MKAverage (line 61) | class MKAverage {
    method print (line 72) | void print(T& v) {
    method takeMax (line 78) | int takeMax(multiset<int>& s) {
    method takeMin (line 84) | int takeMin(multiset<int>& s) {
    method MKAverage (line 91) | MKAverage(int _m, int _k): ring(_m, 0), m(_m), k(_k), sum(0), pos(0), ...
    method ins (line 95) | void ins(int n) {
    method del (line 109) | void del(int n) {
    method addElement (line 125) | void addElement(int num) {
    method calculateMKAverage (line 144) | int calculateMKAverage() {
  class MKAverage1 (line 169) | class MKAverage1 {
    method print (line 180) | void print(T& v) {
    method MKAverage1 (line 187) | MKAverage1(int _m, int _k):  ring(_m,0), m(_m), k(_k), sum(0), pos(0),...
    method ins (line 190) | void ins(int n) {
    method del (line 208) | void del(int n) {
    method addElement (line 225) | void addElement(int num) {
    method calculateMKAverage (line 259) | int calculateMKAverage() {

FILE: algorithms/cpp/findingTheUsersActiveMinutes/FindingTheUsersActiveMinutes.cpp
  class Solution (line 51) | class Solution {
    method findingUsersActiveMinutes (line 53) | vector<int> findingUsersActiveMinutes(vector<vector<int>>& logs, int k) {

FILE: algorithms/cpp/firstBadVersion/FirstBadVersion.cpp
  class Solution (line 27) | class Solution {
    method firstBadVersion (line 30) | int firstBadVersion(int n) {

FILE: algorithms/cpp/firstMissingPositive/firstMissingPositive.cpp
  function firstMissingPositive_move (line 38) | int firstMissingPositive_move(int A[], int n) {
  function firstMissingPositive_map (line 74) | int firstMissingPositive_map(int A[], int n) {
  function firstMissingPositive (line 120) | int firstMissingPositive(int A[], int n) {
  function printArray (line 129) | void printArray(int a[], int n){
  function Test (line 137) | void Test(int a[], int n, int expected) {
  function main (line 145) | int main()

FILE: algorithms/cpp/firstUniqueCharacterInAString/FirstUniqueCharacterInAString.cpp
  class Solution (line 21) | class Solution {
    method firstUniqChar (line 23) | int firstUniqChar(string s) {

FILE: algorithms/cpp/fizzBuzz/FizzBuzz.cpp
  class Solution (line 37) | class Solution {
    method fizzBuzz_old_school_way (line 39) | vector<string> fizzBuzz_old_school_way(int n) {
    class FizzBuzz (line 56) | class FizzBuzz {
      method FizzBuzz (line 58) | FizzBuzz() : x(0) {}
      method string (line 60) | string operator()() {
    method fizzBuzz_cpp_way (line 76) | vector<string> fizzBuzz_cpp_way(int n) {
    method fizzBuzz (line 82) | vector<string> fizzBuzz(int n) {

FILE: algorithms/cpp/flattenBinaryTreeToLinkedList/flattenBinaryTreeToLinkedList.cpp
  class Solution (line 48) | class Solution {
    method flatten (line 50) | void flatten(TreeNode *root) {

FILE: algorithms/cpp/flattenNestedListIterator/FlattenNestedListIterator.cpp
  class NestedIterator (line 42) | class NestedIterator {
    method flatten (line 46) | void flatten(vector<NestedInteger> &nestedList) {
    method NestedIterator (line 56) | NestedIterator(vector<NestedInteger> &nestedList) {
    method next (line 61) | int next() {
    method hasNext (line 65) | bool hasNext() {

FILE: algorithms/cpp/formArrayByConcatenatingSubarraysOfAnotherArray/FormArrayByConcatenatingSubarraysOfAnotherArray.cpp
  class Solution (line 51) | class Solution {
    method canChoose (line 53) | bool canChoose(vector<vector<int>>& groups, vector<int>& nums) {

FILE: algorithms/cpp/fractionToRecurringDecimal/fractionToRecurringDecimal.cpp
  function string (line 46) | string fractionToDecimal(int numerator, int denominator) {
  function test (line 95) | void test(int num, int deno)
  function main (line 100) | int main(int argc, char** argv)

FILE: algorithms/cpp/frequencyOfTheMostFrequentElement/FrequencyOfTheMostFrequentElement.cpp
  class Solution (line 43) | class Solution {
    method maxFrequency (line 45) | int maxFrequency(vector<int>& nums, int k) {

FILE: algorithms/cpp/friendCircles/FriendCircles.cpp
  class Solution (line 46) | class Solution {
    method findCircleNum_DFS (line 51) | int findCircleNum_DFS(vector<vector<int>>& M) {
    method mark (line 65) | void mark(vector<vector<int>>& M, int i ) {
    method findCircleNum_UF (line 76) | int findCircleNum_UF(vector<vector<int>>& M) {
    method find (line 96) | int find(vector<int>& relations, int i ) {
    method join (line 104) | bool join(vector<int> &relations, int x, int y) {
    method findCircleNum (line 113) | int findCircleNum(vector<vector<int>>& M) {

FILE: algorithms/cpp/frogJump/FrogJump.cpp
  class Solution (line 46) | class Solution {
    method canCross_recursion (line 48) | bool canCross_recursion(vector<int>& stones, int curr, int last_jump) {
    method canCross_recursion_with_cache (line 61) | bool canCross_recursion_with_cache(vector<int>& stones, int curr, int ...
    method canCross_non_recursion (line 82) | bool canCross_non_recursion(vector<int>& stones) {
    method canCross (line 112) | bool canCross(vector<int>& stones) {

FILE: algorithms/cpp/gameOfLife/GameOfLife.cpp
  class Solution (line 51) | class Solution {
    method liveCheck (line 58) | void liveCheck(vector<vector<int>>& board, int r, int c) {
    method gameOfLife (line 79) | void gameOfLife(vector<vector<int>>& board) {

FILE: algorithms/cpp/gasStation/gasStation.cpp
  class Solution (line 20) | class Solution {
    method canCompleteCircuit (line 22) | int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {

FILE: algorithms/cpp/generateParentheses/generateParentheses.cpp
  function generateParenthesis (line 23) | vector<string> generateParenthesis(int n) {
  function generator (line 31) | void generator(vector<string>& result, int left, int right, string s){
  function printResult (line 44) | void printResult(vector<string>& result)
  function main (line 51) | int main(int argc, char** argv)

FILE: algorithms/cpp/grayCode/grayCode.cpp
  function grayCode01 (line 73) | vector<int> grayCode01(int n) {
  function grayCode02 (line 102) | vector<int> grayCode02(int n) {
  function grayCode (line 112) | vector<int> grayCode(int n) {
  function printBits (line 120) | void printBits(int n, int len){
  function printVector (line 130) | void printVector(vector<int>& v, int bit_len)
  function main (line 143) | int main(int argc, char** argv)

FILE: algorithms/cpp/greatestCommonDivisorOfStrings/GreatestCommonDivisorOfStrings.cpp
  class Solution (line 34) | class Solution {
    method findGCD_r (line 41) | int findGCD_r(int a, int b) {
    method findGCD (line 47) | int findGCD(int a, int b) {
    method isStrRepeatByLen (line 57) | bool isStrRepeatByLen(string& s, int len) {
    method strPrefixComp (line 68) | bool strPrefixComp(string& s1, string &s2, int len){
    method string (line 75) | string gcdOfStrings(string s1, string s2) {

FILE: algorithms/cpp/h-Index/h-Index.II.cpp
  class Solution (line 14) | class Solution {
    method hIndex (line 17) | int hIndex(vector<int>& citations) {

FILE: algorithms/cpp/h-Index/h-Index.cpp
  class Solution (line 41) | class Solution {
    method hIndex (line 43) | int hIndex(vector<int>& citations) {
    method hIndex01 (line 47) | int hIndex01(vector<int>& citations) {
    method hIndex02 (line 57) | int hIndex02(vector<int>& citations) {

FILE: algorithms/cpp/happyNumber/HappyNumber.cpp
  function squares (line 29) | int squares(int n) {
  function isHappy (line 39) | bool isHappy(int n) {
  function main (line 59) | int main(int argc, char** argv)

FILE: algorithms/cpp/houseRobber/houseRobber.II.cpp
  class Solution (line 23) | class Solution {
    method orginal_rob (line 25) | int orginal_rob(vector<int> &money, int start, int end) {
    method rob (line 37) | int rob(vector<int>& nums) {

FILE: algorithms/cpp/houseRobber/houseRobber.cpp
  function rob1 (line 38) | int rob1(vector<int> &money) {
  function rob2 (line 57) | int rob2(vector<int> &money) {
  function rob (line 69) | int rob(vector<int> &num) {
  function printVector (line 75) | void printVector( vector<int> &v ){
  function main (line 83) | int main(int argc, char** argv) {

FILE: algorithms/cpp/houseRobber/houseRobberIII.cpp
  class Solution (line 68) | class Solution {
    method rob (line 71) | int rob(TreeNode* root) {
    method max (line 95) | int max(int a, int b) {
    method max (line 98) | int max(int a, int b, int c) {
    method max (line 101) | int max(int a, int b, int c, int d) {
    method rob_or_not (line 105) | void rob_or_not(TreeNode* root, int& max_robbed, int& max_not_robbed) {
    method rob (line 129) | int rob(TreeNode* root) {
  class Solution (line 93) | class Solution {
    method rob (line 71) | int rob(TreeNode* root) {
    method max (line 95) | int max(int a, int b) {
    method max (line 98) | int max(int a, int b, int c) {
    method max (line 101) | int max(int a, int b, int c, int d) {
    method rob_or_not (line 105) | void rob_or_not(TreeNode* root, int& max_robbed, int& max_not_robbed) {
    method rob (line 129) | int rob(TreeNode* root) {

FILE: algorithms/cpp/implementQueueUsingStacks/ImplementQueueUsingStacks.cpp
  class Queue (line 31) | class Queue {
    method push (line 34) | void push(int x) {
    method pop (line 39) | void pop(void) {
    method peek (line 46) | int peek(void) {
    method empty (line 54) | bool empty(void) {
    method transfer (line 59) | void transfer(stack<int>& s1, stack<int>& s2) {

FILE: algorithms/cpp/implementStackUsingQueues/ImplementStackUsingQueues.cpp
  class Stack (line 37) | class Stack {
    method push (line 40) | void push(int x) {
    method pop (line 44) | void pop() {
    method top (line 56) | int top() {
    method empty (line 60) | bool empty() {

FILE: algorithms/cpp/implementTriePrefixTree/ImplementTriePrefixTree.cpp
  class TrieNode (line 16) | class TrieNode {
    method TrieNode (line 19) | TrieNode():isWord(false) {   }
  class Trie (line 24) | class Trie {
    method Trie (line 26) | Trie() {
    method insert (line 31) | void insert(string s) {
    method search (line 44) | bool search(string key) {
    method startsWith (line 50) | bool startsWith(string prefix) {
    method retrieve (line 56) | inline bool retrieve(const string& key, bool isWord) {

FILE: algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp
  class Solution (line 23) | class Solution {
    method increasingTriplet (line 25) | bool increasingTriplet(vector<int>& nums) {
    method increasingTriplet (line 49) | bool increasingTriplet(vector<int>& nums) {
  class Solution (line 47) | class Solution {
    method increasingTriplet (line 25) | bool increasingTriplet(vector<int>& nums) {
    method increasingTriplet (line 49) | bool increasingTriplet(vector<int>& nums) {

FILE: algorithms/cpp/incrementalMemoryLeak/IncrementalMemoryLeak.cpp
  class Solution (line 52) | class Solution {
    method memLeak (line 54) | vector<int> memLeak(int memory1, int memory2) {

FILE: algorithms/cpp/insertDeleteGetRandom/InsertDeleteGetrandomO1.cpp
  class RandomizedSet (line 42) | class RandomizedSet {
    method RandomizedSet (line 45) | RandomizedSet() {
    method insert (line 50) | bool insert(int val) {
    method remove (line 58) | bool remove(int val) {
    method getRandom (line 79) | int getRandom() {
    method find (line 86) | bool find(int val) {

FILE: algorithms/cpp/insertDeleteGetRandom/InsertDeleteGetrandomO1DuplicatesAllowed.cpp
  class RandomizedCollection (line 42) | class RandomizedCollection {
    method RandomizedCollection (line 45) | RandomizedCollection() {
    method insert (line 50) | bool insert(int val) {
    method remove (line 57) | bool remove(int val) {
    method getRandom (line 84) | int getRandom() {
    method find (line 90) | bool find(int val) {

FILE: algorithms/cpp/insertInterval/insertInterval.cpp
  type Interval (line 27) | struct Interval {
    method Interval (line 30) | Interval() : start(0), end(0) {}
    method Interval (line 31) | Interval(int s, int e) : start(s), end(e) {}
  function compare (line 35) | bool compare(const Interval& lhs, const Interval& rhs){
  function merge (line 39) | vector<Interval> merge(vector<Interval> &intervals) {
  function insert (line 61) | vector<Interval> insert(vector<Interval> &intervals, Interval newInterva...
  function main (line 68) | int main(int argc, char**argv)

FILE: algorithms/cpp/insertionSortList/insertionSortList.cpp
  type ListNode (line 15) | struct ListNode {
    method ListNode (line 18) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 21) | ListNode *insertionSortList(ListNode *head) {
    method ListNode (line 18) | ListNode(int x) : val(x), next(NULL) {}
  function printList (line 48) | void printList(ListNode* h)
  function ListNode (line 57) | ListNode* createList(int a[], int n)
    method ListNode (line 18) | ListNode(int x) : val(x), next(NULL) {}
  function main (line 72) | int main(int argc, char** argv)

FILE: algorithms/cpp/integerBreak/IntegerBreak.cpp
  class Solution (line 23) | class Solution {
    method integerBreak (line 34) | int integerBreak(int n) {
    method integerBreak (line 50) | int integerBreak(int n) {
  class Solution (line 48) | class Solution {
    method integerBreak (line 34) | int integerBreak(int n) {
    method integerBreak (line 50) | int integerBreak(int n) {

FILE: algorithms/cpp/integerReplacement/IntegerReplacement.cpp
  class Solution (line 39) | class Solution {
    method integerReplacement_recursion (line 43) | int integerReplacement_recursion(int n) {
    method integerReplacement_recursionWithCache (line 50) | int integerReplacement_recursionWithCache(int n) {
    method integerReplacement_simple (line 66) | int integerReplacement_simple(int n){
    method integerReplacement (line 80) | int integerReplacement(int n) {

FILE: algorithms/cpp/integerToEnglishWords/IntegerToEnglishWords.cpp
  function string (line 42) | string numberLess1000ToWords(int num) {
  function string (line 64) | string numberToWords(int num) {
  function main (line 89) | int main(int argc, char** argv)

FILE: algorithms/cpp/integerToRoman/integerToRoman.cpp
  function string (line 19) | string intToRoman(int num) {
  function main (line 35) | int main(int argc, char** argv)

FILE: algorithms/cpp/interleavingString/interleavingString.cpp
  function isInterleave (line 67) | bool isInterleave(string s1, string s2, string s3) {
  function isInterleave_dfs (line 106) | bool isInterleave_dfs(string s1, string s2, string s3) {
  function main (line 130) | int main(int argc, char**argv)

FILE: algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp
  class Solution (line 17) | class Solution {
    method intersection (line 21) | vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    method intersection (line 57) | vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
  class Solution2 (line 36) | class Solution2 {
    method intersection (line 38) | vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
  class Solution (line 55) | class Solution {
    method intersection (line 21) | vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    method intersection (line 57) | vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {

FILE: algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArraysII.cpp
  class Solution (line 39) | class Solution { // O(NlogN + MlogM)
    method intersect (line 41) | vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
    method intersect (line 73) | vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
  class Solution (line 71) | class Solution {
    method intersect (line 41) | vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
    method intersect (line 73) | vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {

FILE: algorithms/cpp/intersectionOfTwoLinkedLists/intersectionOfTwoLinkedLists.cpp
  class Solution (line 37) | class Solution {
    method ListNode (line 39) | ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    method getListLength (line 66) | inline int getListLength(ListNode *head){

FILE: algorithms/cpp/intervalListIntersectons/IntervalListIntersections.cpp
  class Solution (line 49) | class Solution {
    method compareInterval (line 52) | bool compareInterval(Interval& lhs, Interval& rhs) {
    method overlapped (line 56) | bool overlapped(Interval& lhs, Interval& rhs) {
    method Interval (line 63) | Interval mergeTwoInterval(Interval& lhs, Interval& rhs) {
    method intervalIntersection (line 70) | vector<Interval> intervalIntersection(vector<Interval>& A, vector<Inte...

FILE: algorithms/cpp/invertBinaryTree/InvertBinaryTree.cpp
  class Solution (line 39) | class Solution {
    method TreeNode (line 42) | TreeNode* invertTree_recursive(TreeNode* root) {
    method TreeNode (line 50) | TreeNode* invertTree_non_recursive(TreeNode* root) {
    method TreeNode (line 64) | TreeNode* invertTree(TreeNode* root) {

FILE: algorithms/cpp/isSubsequence/IsSubsequence.cpp
  class Solution (line 33) | class Solution {
    method isSubsequence (line 35) | bool isSubsequence(string s, string t) {

FILE: algorithms/cpp/islandPerimeter/IslandPerimeter.cpp
  class Solution (line 30) | class Solution {
    method edge (line 32) | int edge(vector<vector<int>> &grid, int x, int y) {
    method islandPerimeter (line 45) | int islandPerimeter(vector<vector<int>>& grid) {

FILE: algorithms/cpp/isomorphicStrings/IsomorphicStrings.cpp
  class Solution (line 29) | class Solution {
    method isIsomorphic (line 31) | bool isIsomorphic(string s, string t) {

FILE: algorithms/cpp/jewelsAndStones/JewelsAndStones.cpp
  class Solution (line 36) | class Solution {
    method numJewelsInStones (line 38) | int numJewelsInStones(string J, string S) {

FILE: algorithms/cpp/jumpGame/jumpGame.II.cpp
  function jump (line 26) | int jump(int A[], int n) {
  function printArray (line 54) | void printArray(int a[], int n){
  function main (line 62) | int main()

FILE: algorithms/cpp/jumpGame/jumpGame.cpp
  class Solution (line 21) | class Solution {
    method canJump (line 23) | bool canJump(int A[], int n) {

FILE: algorithms/cpp/kthLargestElementInAnArray/KthLargestElementInAnArray.cpp
  class Solution (line 23) | class Solution {
    method findKthLargest_buildin (line 26) | int findKthLargest_buildin(vector<int>& nums, int k) {
    method partition (line 33) | int partition(vector<int>& nums, int left, int right) {
    method findKthLargest_qsort (line 47) | int findKthLargest_qsort(vector<int>& nums, int k) {
    method findKthLargest (line 63) | int findKthLargest(vector<int>& nums, int k) {

FILE: algorithms/cpp/kthSmallestElementInaBST/KthSmallestElementInABst.cpp
  class Solution (line 33) | class Solution {
    method kthSmallestHelper_recursive (line 36) | int kthSmallestHelper_recursive(TreeNode* root, int& k) {
    method kthSmallestHelper_nonRecursive (line 50) | int kthSmallestHelper_nonRecursive(TreeNode* root, int k){
    method kthSmallest (line 70) | int kthSmallest(TreeNode* root, int k) {

FILE: algorithms/cpp/largestColorValueInADirectedGraph/LargestColorValueInADirectedGraph.cpp
  class Node (line 46) | class Node {
    method Node (line 48) | Node(char c) {
    method AddMyColor (line 54) | void AddMyColor() { colors[color]++; }
    method Processed (line 55) | void Processed() { processed = true; }
    method isProcessed (line 56) | bool isProcessed() { return processed; }
    method AddIncomming (line 57) | void AddIncomming(int n=1) { incomming += n;}
    method Incomming (line 58) | int Incomming() {return incomming;}
    method AddChildNode (line 59) | void AddChildNode(int n) { children.push_back(n); }
    method ChildrenCount (line 61) | int ChildrenCount() { return children.size(); }
    method MaxColorValue (line 63) | int MaxColorValue() {
    method MergeChildColors (line 70) | void MergeChildColors(Node& child){
  class Solution (line 86) | class Solution {
    method print (line 88) | void print(vector<int>& v) {
    method largestPathValue (line 100) | int largestPathValue(string colors, vector<vector<int>>& edges) {
    method topologicalSort (line 140) | void topologicalSort(int i, vector<int>& topSort, vector<bool>& visite...
    method travel (line 153) | bool travel(int i, vector<bool>& visited ) {

FILE: algorithms/cpp/largestMergeOfTwoStrings/LargestMergeOfTwoStrings.cpp
  class Solution (line 53) | class Solution {
    method string_cmp (line 55) | bool string_cmp(string& s1, int p1, string& s2, int p2) {
    method string (line 63) | string largestMerge(string word1, string word2) {

FILE: algorithms/cpp/largestNumber/largestNumber.cpp
  class Solution (line 17) | class Solution {
    method comp (line 21) | static bool comp (string& s1, string& s2) { return s1+s2 > s2+s1; }
    method string (line 23) | string largestNumber(vector<int> &num) {

FILE: algorithms/cpp/largestNumberAfterMutatingSubstring/LargestNumberAfterMutatingSubstring.cpp
  class Solution (line 53) | class Solution {
    method string (line 55) | string maximumNumber(string num, vector<int>& change) {

FILE: algorithms/cpp/largestPerimeterTriangle/largestPerimeterTriangle.cpp
  class Solution (line 1) | class Solution {
    method largestPerimeter (line 3) | int largestPerimeter(vector<int>& A) {

FILE: algorithms/cpp/largestRectangleInHistogram/largestRectangleInHistogram.cpp
  function largestRectangleArea_01 (line 58) | int largestRectangleArea_01(vector<int>& heights) {
  function largestRectangleArea (line 158) | int largestRectangleArea(vector<int> &height) {
  function printArray (line 187) | void printArray(vector<int> &v)
  function test (line 195) | void test(int a[], int n)
  function main (line 202) | int main()

FILE: algorithms/cpp/largestSubmatrixWithRearrangements/LargestSubmatrixWithRearrangements.cpp
  class Solution (line 48) | class Solution {
    method largestSubmatrix (line 50) | int largestSubmatrix(vector<vector<int>>& matrix) {

FILE: algorithms/cpp/largestSubstringBetweenTwoEqualCharacters/LargestSubstringBetweenTwoEqualCharacters.cpp
  class Solution (line 42) | class Solution {
    method maxLengthBetweenEqualCharacters (line 44) | int maxLengthBetweenEqualCharacters(string s) {

FILE: algorithms/cpp/latestTimeByReplacingHiddenDigits/LatestTimeByReplacingHiddenDigits.cpp
  class Solution (line 37) | class Solution {
    method string (line 39) | string maximumTime(string time) {

FILE: algorithms/cpp/lengthOfLastWord/lengthOfLastWord.cpp
  function lengthOfLastWord (line 24) | int lengthOfLastWord(const char *s) {
  function main (line 47) | int main(int argc, char** argv)

FILE: algorithms/cpp/letterCombinationsOfAPhoneNumber/letterCombinationsOfAPhoneNumber.cpp
  function letterCombinations (line 26) | vector<string> letterCombinations(string digits) {
  function printVector (line 73) | void printVector(vector<string>& ss){
  function main (line 82) | int main(int argc, char**argv)

FILE: algorithms/cpp/lexicographicalNumbers/LexicographicalNumbers.cpp
  class Solution (line 14) | class Solution {
    method lexicalOrder01 (line 18) | vector<int> lexicalOrder01(int n) {
    method myComp (line 27) | static bool myComp(int i,int j) {
    method lexicalOrder02 (line 37) | vector<int> lexicalOrder02(int n) {
    method lexicalOrder_helper (line 47) | void lexicalOrder_helper(int num, int& n, vector<int>& result) {
    method lexicalOrder03 (line 60) | vector<int> lexicalOrder03(int n) {
    method lexicalOrder (line 101) | vector<int> lexicalOrder(int n) {

FILE: algorithms/cpp/lexicographicallySmallestStringAfterApplyingOperations/LexicographicallySmallestStringAfterApplyingOperations.cpp
  class Solution (line 72) | class Solution {
    method rotate_str (line 75) | void rotate_str(string& s, int n) {
    method add_str (line 78) | void add_str(string& s, int n) {
    method string (line 84) | string findLexSmallestString(string s, int a, int b) {
    method dfs (line 90) | void dfs(string& s, int a, int b, string& result) {

FILE: algorithms/cpp/linkedListCycle/linkedListCycle.II.cpp
  class Solution (line 23) | class Solution {
    method hasCycle (line 28) | bool hasCycle(ListNode *head) {
    method ListNode (line 55) | ListNode *detectCycle(ListNode *head) {

FILE: algorithms/cpp/linkedListCycle/linkedListCycle.cpp
  class Solution (line 24) | class Solution {
    method hasCycle (line 26) | bool hasCycle(ListNode *head) {
    method hasCycle01 (line 35) | bool hasCycle01(ListNode *head) {
    method hasCycle02 (line 47) | bool hasCycle02(ListNode *head) {
    method hasCycle03 (line 62) | bool hasCycle03(ListNode *head) {
    method hasCycle04 (line 74) | bool hasCycle04(ListNode *head) {

FILE: algorithms/cpp/linkedListRandomNode/LinkedListRandomNode.cpp
  class Solution (line 35) | class Solution {
    method Solution (line 39) | Solution(ListNode* head) {
    method getRandom (line 47) | int getRandom() {

FILE: algorithms/cpp/longerContiguousSegmentsOfOnesThanZeros/LongerContiguousSegmentsOfOnesThanZeros.cpp
  class Solution (line 49) | class Solution {
    method checkZeroOnes (line 51) | bool checkZeroOnes(string s) {

FILE: algorithms/cpp/longestAbsoluteFilePath/LongestAbsoluteFilePath.cpp
  class Solution (line 55) | class Solution {
    method lengthLongestPath (line 74) | int lengthLongestPath(string input) {

FILE: algorithms/cpp/longestCommonPrefix/longestCommonPrefix.cpp
  function string (line 18) | string longestCommonPrefix(vector<string> &strs) {
  function main (line 39) | int main()

FILE: algorithms/cpp/longestConsecutiveSequence/longestConsecutiveSequence.cpp
  class Solution (line 34) | class Solution {
    method longestConsecutive (line 36) | int longestConsecutive(vector<int> &num) {

FILE: algorithms/cpp/longestIncreasingPathInAMatrix/LongestIncreasingPathInAMatrix.cpp
  class Solution (line 42) | class Solution {
    method longestIncreasingPath (line 44) | int longestIncreasingPath(vector<vector<int>>& matrix) {
    method helper (line 57) | int helper(vector<vector<int>>& matrix, vector<vector<int>>& path, con...

FILE: algorithms/cpp/longestIncreasingSubsequence/longestIncreasingSubsequence.cpp
  class Solution (line 28) | class Solution {
    method lengthOfLIS (line 30) | int lengthOfLIS(vector<int>& nums) {
    method lengthOfLIS (line 67) | int lengthOfLIS(vector<int>& nums) {
    method binary_search (line 102) | int binary_search(int number)
    method lengthOfLIS (line 130) | int lengthOfLIS(vector<int>& nums) {
  class Solution (line 49) | class Solution {
    method lengthOfLIS (line 30) | int lengthOfLIS(vector<int>& nums) {
    method lengthOfLIS (line 67) | int lengthOfLIS(vector<int>& nums) {
    method binary_search (line 102) | int binary_search(int number)
    method lengthOfLIS (line 130) | int lengthOfLIS(vector<int>& nums) {

FILE: algorithms/cpp/longestNiceSubstring/LongestNiceSubstring.cpp
  class Solution (line 47) | class Solution {
    method getCharIndex (line 48) | inline int getCharIndex(char c) {
    method getCaseIndex (line 51) | inline int getCaseIndex(char c) {
    method string (line 55) | string longestNiceSubstring(string s) {

FILE: algorithms/cpp/longestPalindrome/LongestPalindrome.cpp
  class Solution (line 27) | class Solution {
    method longestPalindrome (line 29) | int longestPalindrome(string s) {

FILE: algorithms/cpp/longestPalindromicSubsequence/LongestPalindromicSubsequence.cpp
  class Solution (line 68) | class Solution {
    method longestPalindromeSubseq (line 70) | int longestPalindromeSubseq(string s) {

FILE: algorithms/cpp/longestPalindromicSubstring/longestPalindromicSubstring.cpp
  function string (line 19) | string findPalindrome(string s, int left, int right)
  function string (line 35) | string longestPalindrome_recursive_way(string s) {
  function findPalindrome (line 59) | void findPalindrome(string s, int left, int right, int& start, int& len)
  function string (line 76) | string longestPalindrome_recursive_way2(string s) {
  function string (line 95) | string longestPalindrome_dp_way(string s) {
  function string (line 132) | string longestPalindrome_dp_opt_way(string s) {
  function string (line 176) | string longestPalindrome(string s) {
  function main (line 183) | int main(int argc, char**argv)

FILE: algorithms/cpp/longestSubstringOfAllVowelsInOrder/LongestSubstringOfAllVowelsInOrder.cpp
  class Solution (line 45) | class Solution {
    type Vowels (line 47) | enum Vowels{
    method Vowels (line 56) | Vowels isVowels(char c) {
    method longestBeautifulSubstring (line 67) | int longestBeautifulSubstring(string word) {

FILE: algorithms/cpp/longestSubstringWithAtLeastKRepeatingCharacters/LongestSubstringWithAtLeastKRepeatingCharacters.cpp
  class Solution (line 42) | class Solution {
    method longestSubstring (line 44) | int longestSubstring(string s, int k) {
    method max (line 91) | inline int max(int x, int y) { return x>y? x:y; }
    method split (line 93) | inline void split(const string &s, char delim, vector<string> &elems) {
    method split (line 104) | inline vector<string> split(const string &s, char delim) {

FILE: algorithms/cpp/longestSubstringWithAtMostTwoDistinctCharacters/longestSubstringWithAtMostTwoDistinctCharacters.cpp
  function lengthOfLongestSubstringTwoDistinct (line 33) | int lengthOfLongestSubstringTwoDistinct(string s) {
  function main (line 57) | int main(int argc, char** argv)

FILE: algorithms/cpp/longestSubstringWithoutRepeatingCharacters/longestSubstringWithoutRepeatingCharacters.cpp
  function lengthOfLongestSubstring1 (line 28) | int lengthOfLongestSubstring1(string s) {
  function lengthOfLongestSubstring (line 44) | int lengthOfLongestSubstring(string s) {
  function main (line 63) | int main(int argc, char** argv)

FILE: algorithms/cpp/longestTurbulentSubarray/LongestTurbulentSubarray.cpp
  class Solution (line 39) | class Solution {
    method maxTurbulenceSize_01 (line 42) | int maxTurbulenceSize_01(vector<int>& A) {
    method maxTurbulenceSize_02 (line 113) | int maxTurbulenceSize_02(vector<int>& A) {
    method maxTurbulenceSize (line 134) | int maxTurbulenceSize(vector<int>& A) {

FILE: algorithms/cpp/longestValidParentheses/longestValidParentheses.cpp
  function longestValidParentheses (line 23) | int longestValidParentheses(string s) {
  function main (line 51) | int main(int argc, char** argv)

FILE: algorithms/cpp/lowestCommonAncestorOfABinarySearchTree/LowestCommonAncestorOfABinarySearchTree.cpp
  class Solution (line 39) | class Solution {
    method TreeNode (line 41) | TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* ...

FILE: algorithms/cpp/lowestCommonAncestorOfABinaryTree/LowestCommonAncestorOfABinaryTree.cpp
  class Solution (line 40) | class Solution {
    method findPath (line 42) | bool findPath(TreeNode* root, TreeNode* p, vector<TreeNode*>& path) {
    method TreeNode (line 58) | TreeNode* lowestCommonAncestor01(TreeNode* root, TreeNode* p, TreeNode...
    method TreeNode (line 77) | TreeNode* lowestCommonAncestor02(TreeNode* root, TreeNode* p, TreeNode...
    method TreeNode (line 95) | TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* ...

FILE: algorithms/cpp/majorityElement/majorityElement.II.cpp
  class Solution (line 14) | class Solution {
    method majorityElement01 (line 18) | vector<int> majorityElement01(vector<int>& nums) {
    method majorityElement02 (line 33) | vector<int> majorityElement02(vector<int>& nums) {
    method majorityElement (line 67) | vector<int> majorityElement(vector<int>& nums) {

FILE: algorithms/cpp/majorityElement/majorityElement.cpp
  function majorityElement (line 26) | int majorityElement(vector<int> &num) {
  function split (line 53) | vector<int> split(const string &s, char delim) {
  function main (line 60) | int main(int argc, char** argv)

FILE: algorithms/cpp/makeTheXorOfAllSegmentsEqualToZero/MakeTheXorOfAllSegmentsEqualToZero.cpp
  class Solution (line 66) | class Solution {
    method minChanges (line 68) | int minChanges(vector<int>& nums, int k) {

FILE: algorithms/cpp/mapOfHighestPeak/MapOfHighestPeak.cpp
  class Cell (line 49) | class Cell{
  class Solution (line 56) | class Solution {
    method setHeight (line 58) | void setHeight(vector<vector<int>>& height,
    method highestPeak (line 70) | vector<vector<int>> highestPeak(vector<vector<int>>& isWater) {

FILE: algorithms/cpp/matrixCellsInDistanceOrder/MatrixCellsInDistanceOrder.cpp
  class Solution (line 47) | class Solution {
    method put (line 49) | void put(int R, int C, int r, int c, vector<vector<int>>& res) {
    method allCellsDistOrder (line 54) | vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {

FILE: algorithms/cpp/maxAreaOfIsland/MaxAreaOfIsland.cpp
  class Solution (line 36) | class Solution {
    method maxAreaOfIsland (line 38) | int maxAreaOfIsland(vector<vector<int>>& grid) {
    method maxAreaOfIsland_DFS (line 52) | void maxAreaOfIsland_DFS( vector<vector<int>>& grid, int i, int j, int...

FILE: algorithms/cpp/maxPointsOnALine/maxPointsOnALine.cpp
  type Point (line 18) | struct Point {
    method Point (line 21) | Point() : x(0), y(0) {}
    method Point (line 22) | Point(int a, int b) : x(a), y(b) {}
  function maxPoints (line 26) | int maxPoints(vector<Point> &points) {
  function generatePoints (line 79) | void generatePoints(vector<Point> &points, int n) {
  function printPoints (line 89) | void printPoints(vector<Point> &points) {
  function main (line 97) | int main(int argc, char** argv)

FILE: algorithms/cpp/maximalRectangle/maximalRectangle.cpp
  function largestRectangleArea (line 30) | int largestRectangleArea(vector<int> &height) {
  function maximalRectangle (line 54) | int maximalRectangle(vector<vector<char> > &matrix) {
  function printArray (line 78) | void printArray(vector<int> &v)
  function test (line 87) | void test(int a[], int n)
  function main (line 94) | int main(int argc, char** argv)

FILE: algorithms/cpp/maximalSquare/MaximalSquare.cpp
  class Solution (line 67) | class Solution {
    method min (line 69) | inline int min(int x, int y) {
    method min (line 72) | inline int min(int x, int y, int z) {
    method maximalSquare (line 75) | int maximalSquare(vector<vector<char>>& matrix) {

FILE: algorithms/cpp/maximizeNumberOfNiceDivisors/MaximizeNumberOfNiceDivisors.cpp
  class Solution (line 73) | class Solution {
    method maxNiceDivisors (line 75) | int maxNiceDivisors(int primeFactors) {
    method maxNiceDivisors_01 (line 81) | int maxNiceDivisors_01(int primeFactors) {
    method maxNiceDivisors_02 (line 91) | int maxNiceDivisors_02(int primeFactors) {
    method pow3 (line 109) | int pow3(int x) {
    method maxNiceDivisors_03 (line 124) | int maxNiceDivisors_03(int primeFactors) {

FILE: algorithms/cpp/maximizePalindromeLengthFromSubsequences/MaximizePalindromeLengthFromSubsequences.cpp
  class Solution (line 72) | class Solution {
    method longestPalindrome (line 75) | int longestPalindrome(string word1, string word2) {

FILE: algorithms/cpp/maximizeScoreAfterNOperations/MaximizeScoreAfterNOperations.cpp
  class Solution (line 48) | class Solution {
    method gcd (line 52) | int gcd(int a, int b) {
    method maxScore (line 61) | int maxScore(vector<int>& nums) {
    method maxScore (line 76) | int maxScore(vector<vector<int>>& pair_gcd, int mask, int n, int step) {

FILE: algorithms/cpp/maximumAbsoluteSumOfAnySubarray/MaximumAbsoluteSumOfAnySubarray.cpp
  class Solution (line 35) | class Solution {
    method maxAbsoluteSum (line 37) | int maxAbsoluteSum(vector<int>& nums) {
    method maxAbsoluteSum01 (line 44) | int maxAbsoluteSum01(vector<int>& nums) {
    method maxSumArray (line 49) | int maxSumArray(vector<int>& nums) {
    method minSumArray (line 60) | int minSumArray(vector<int>& nums) {
    method maxAbsoluteSum02 (line 73) | int maxAbsoluteSum02(vector<int>& nums) {

FILE: algorithms/cpp/maximumAscendingSubarraySum/MaximumAscendingSubarraySum.cpp
  class Solution (line 44) | class Solution {
    method maxAscendingSum (line 46) | int maxAscendingSum(vector<int>& nums) {

FILE: algorithms/cpp/maximumAveragePassRatio/MaximumAveragePassRatio.cpp
  class Solution (line 44) | class Solution {
    method print_queue (line 47) | void print_queue(T q) { // NB: pass by value so the print uses a copy
    method ratio (line 58) | double ratio(double pass, double total) {
    method profit (line 62) | double profit(double pass, double total) {
    method maxAverageRatio (line 67) | double maxAverageRatio(vector<vector<int>>& classes, int extraStudents) {

FILE: algorithms/cpp/maximumAverageSubarray/MaximumAverageSubarray.I.cpp
  class Solution (line 28) | class Solution {
    method findMaxAverage (line 30) | double findMaxAverage(vector<int>& nums, int k) {

FILE: algorithms/cpp/maximumBuildingHeight/MaximumBuildingHeight.cpp
  class Solution (line 130) | class Solution {
    method print (line 132) | void print(vector<vector<int>>& vv){
    method getMaxHeight (line 142) | int getMaxHeight(vector<int>& left, vector<int>& right) {
    method maxBuilding (line 162) | int maxBuilding(int n, vector<vector<int>>& restrictions) {

FILE: algorithms/cpp/maximumDepthOfBinaryTree/maximumDepthOfBinaryTree.cpp
  class Solution (line 23) | class Solution {
    method maxDepth (line 25) | int maxDepth(TreeNode *root) {
  class Solution2 (line 44) | class Solution2 {
    method maxDepth (line 46) | int maxDepth(TreeNode *root) {

FILE: algorithms/cpp/maximumDistanceBetweenAPairOfValues/MaximumDistanceBetweenAPairOfValues.cpp
  class Solution (line 51) | class Solution {
    method maxDistance (line 53) | int maxDistance(vector<int>& nums1, vector<int>& nums2) {
    method binary_search (line 59) | int binary_search(vector<int>& nums, int start, int target) {
    method maxDistance1 (line 69) | int maxDistance1(vector<int>& nums1, vector<int>& nums2) {
    method maxDistance2 (line 79) | int maxDistance2(vector<int>& nums1, vector<int>& nums2) {

FILE: algorithms/cpp/maximumElementAfterDecreasingAndRearranging/MaximumElementAfterDecreasingAndRearranging.cpp
  class Solution (line 55) | class Solution {
    method maximumElementAfterDecrementingAndRearranging (line 57) | int maximumElementAfterDecrementingAndRearranging(vector<int>& arr) {

FILE: algorithms/cpp/maximumErasureValue/MaximumErasureValue.cpp
  class Solution (line 33) | class Solution {
    method maximumUniqueSubarray (line 35) | int maximumUniqueSubarray(vector<int>& nums) {

FILE: algorithms/cpp/maximumGap/maximumGap.cpp
  function maximumGap (line 23) | int maximumGap(vector<int> &num) {
  function main (line 67) | int main()

FILE: algorithms/cpp/maximumIceCreamBars/MaximumIceCreamBars.cpp
  class Solution (line 44) | class Solution {
    method maxIceCream (line 46) | int maxIceCream(vector<int>& costs, int coins) {

FILE: algorithms/cpp/maximumNumberOfBallsInABox/MaximumNumberOfBallsInABox.cpp
  class Solution (line 50) | class Solution {
    method sum (line 52) | int sum(int n) {
    method countBalls (line 60) | int countBalls(int lowLimit, int highLimit) {

FILE: algorithms/cpp/maximumNumberOfConsecutiveValuesYouCanMake/MaximumNumberOfConsecutiveValuesYouCanMake.cpp
  class Solution (line 52) | class Solution {
    method getMaximumConsecutive (line 54) | int getMaximumConsecutive(vector<int>& coins) {

FILE: algorithms/cpp/maximumNumberOfEventsThatCanBeAttended/MaximumNumberOfEventsThatCanBeAttended.II.cpp
  class Solution (line 47) | class Solution {
    method comp_start (line 49) | static const bool comp_start(vector<int>& x, vector<int>& y) {
    method comp_end (line 53) | static const bool comp_end(vector<int>& x, vector<int>& y) {
    method print (line 57) | void print(vector<vector<int>>& events){
    method maxValue (line 70) | int maxValue(vector<vector<int>>& events, int k) {
    method findNextEvent (line 91) | int findNextEvent(vector<vector<int>>& events, int low, int day) {
    method maxValueDFS (line 105) | int maxValueDFS(vector<vector<int>>& events, int current, int k) {
    method maxValueDFS (line 118) | int maxValueDFS(vector<vector<int>>& events, int current, int k, vecto...
    method findPrevEvent (line 142) | int findPrevEvent(vector<vector<int>>& events, int high, int day) {
    method maxValueDP (line 155) | int maxValueDP(vector<vector<int>>& events, int k) {

FILE: algorithms/cpp/maximumNumberOfEventsThatCanBeAttended/MaximumNumberOfEventsThatCanBeAttended.cpp
  class Solution (line 53) | class Solution {
    method comp_start (line 55) | static const bool comp_start(vector<int>& x, vector<int>& y) {
    method comp_end (line 59) | static const bool comp_end(vector<int>& x, vector<int>& y) {
    method find (line 66) | int find(int x, vector<int>& f) {
    method print (line 73) | void print(vector<vector<int>>& events){
    method maxEvents (line 81) | int maxEvents(vector<vector<int>>& events) {
    method maxEvents_priority_queue (line 86) | int maxEvents_priority_queue(vector<vector<int>>& events) {
    method maxEvents_union_find (line 122) | int maxEvents_union_find(vector<vector<int>>& events) {

FILE: algorithms/cpp/maximumNumberOfGroupsGettingFreshDonuts/MaximumNumberOfGroupsGettingFreshDonuts.cpp
  class Solution (line 38) | class Solution {
    method maxHappyGroups (line 40) | int maxHappyGroups(int batchSize, vector<int>& groups) {
    method dfs (line 71) | int dfs(vector<int>& reminder, int batchSize, int sum, map<vector<int>...

FILE: algorithms/cpp/maximumNumberOfWordsYouCanType/MaximumNumberOfWordsYouCanType.cpp
  class Solution (line 41) | class Solution {
    method canBeTypedWords (line 43) | int canBeTypedWords(string text, string brokenLetters) {

FILE: algorithms/cpp/maximumPopulationYear/MaximumPopulationYear.cpp
  class Solution (line 36) | class Solution {
    method maximumPopulation (line 39) | int maximumPopulation(vector<vector<int>>& logs) {

FILE: algorithms/cpp/maximumProductOfTwoElementsInAnArray/MaximumProductOfTwoElementsInAnArray.cpp
  class Solution (line 34) | class Solution {
    method maxProduct (line 36) | int maxProduct(vector<int>& nums) {

FILE: algorithms/cpp/maximumProductOfWordLengths/MaximumProductOfWordLengths.cpp
  class Solution (line 34) | class Solution {
    method maxProduct (line 46) | int maxProduct(vector<string>& words) {

FILE: algorithms/cpp/maximumProductSubarray/maximumProductSubarray.cpp
  function max (line 30) | int max(int x, int y) {
  function min (line 33) | int min(int x, int y){
  function max (line 36) | int max(int x, int y, int z) {
  function min (line 39) | int min(int x, int y, int z) {
  function maxProduct (line 50) | int maxProduct(int A[], int n) {
  function main (line 73) | int main()

FILE: algorithms/cpp/maximumScoreFromPerformingMultiplicationOperations/MaximumScoreFromPerformingMultiplicationOperations.cpp
  class Solution (line 51) | class Solution {
    method maximumScore (line 56) | int maximumScore(vector<int>& nums, vector<int>& multipliers) {
    method maximumScoreDFS (line 63) | int maximumScoreDFS(vector<int>& nums, int left, int right,

FILE: algorithms/cpp/maximumScoreFromRemovingStones/MaximumScoreFromRemovingStones.cpp
  class Solution (line 55) | class Solution {
    method can_move (line 57) | bool can_move(int a, int b, int c) {
    method swap (line 65) | void swap(int& x, int& y){
    method sort (line 71) | void sort(int& a, int& b, int& c) {
    method maximumScore (line 79) | int maximumScore(int a, int b, int c) {
    method maximumScore_loop (line 83) | int maximumScore_loop(int a, int b, int c) {
    method maximumScore_math (line 95) | int maximumScore_math(int a, int b, int c) {

FILE: algorithms/cpp/maximumScoreFromRemovingSubstrings/MaximumScoreFromRemovingSubstrings.cpp
  class Solution (line 45) | class Solution {
    method maximumGain (line 47) | int maximumGain(string s, int x, int y) {

FILE: algorithms/cpp/maximumScoreOfAGoodSubarray/MaximumScoreOfAGoodSubarray.cpp
  class Solution (line 33) | class Solution {
    method maximumScore (line 35) | int maximumScore(vector<int>& nums, int k) {

FILE: algorithms/cpp/maximumSubArray/maximumSubArray.cpp
  function max (line 30) | int max(int x, int y){
  function maxSubArray (line 34) | int maxSubArray(int A[], int n) {
  function maxSubArray1 (line 41) | int maxSubArray1(int A[], int n) {
  function maxSubArray2 (line 53) | int maxSubArray2(int A[], int n) {
  function main (line 66) | int main()

FILE: algorithms/cpp/maximumSubarrayMinProduct/MaximumSubarrayMinProduct.cpp
  class Solution (line 48) | class Solution {
    method maxSumMinProduct (line 50) | int maxSumMinProduct(vector<int>& nums) {

FILE: algorithms/cpp/maximumUnitsOnATruck/MaximumUnitsOnATruck.cpp
  class Solution (line 42) | class Solution {
    method print (line 44) | void print(vector<vector<int>>& boxes) {
    method maximumUnits (line 53) | int maximumUnits(vector<vector<int>>& boxTypes, int truckSize) {

FILE: algorithms/cpp/maximumValueAfterInsertion/MaximumValueAfterInsertion.cpp
  class Solution (line 40) | class Solution {
    method string (line 42) | string maxValue(string n, int x) {

FILE: algorithms/cpp/maximumValueAtAGivenIndexInABoundedArray/MaximumValueAtAGivenIndexInABoundedArray.cpp
  class Solution (line 83) | class Solution {
    method maxValue (line 85) | int maxValue(int n, int index, int maxSum) {

FILE: algorithms/cpp/maximumXorForEachQuery/MaximumXorForEachQuery.cpp
  class Solution (line 50) | class Solution {
    method getMaximumXor (line 52) | vector<int> getMaximumXor(vector<int>& nums, int maximumBit) {
    method getMaximumXor (line 67) | vector<int> getMaximumXor(vector<int>& nums, int maximumBit) {

FILE: algorithms/cpp/medianOfTwoSortedArrays/medianOfTwoSortedArrays.cpp
  function binarySearch (line 16) | int binarySearch(int A[], int low, int high, int key){
  function findMedianSortedArrayHelper (line 31) | double findMedianSortedArrayHelper(int A[], int m, int B[], int n, int l...
  function findMedianSortedArrays (line 94) | double findMedianSortedArrays(int A[], int m, int B[], int n) {
  function main (line 114) | int main()

FILE: algorithms/cpp/mergeIntervals/mergeIntervals.cpp
  type Interval (line 21) | struct Interval {
    method Interval (line 24) | Interval() : start(0), end(0) {}
    method Interval (line 25) | Interval(int s, int e) : start(s), end(e) {}
  function compare (line 29) | bool compare(const Interval& lhs, const Interval& rhs){
  function merge (line 33) | vector<Interval> merge(vector<Interval> &intervals) {
  function main (line 55) | int main(int argc, char**argv)

FILE: algorithms/cpp/mergeKSortedLists/mergeKSortedLists.cpp
  type ListNode (line 20) | struct ListNode {
    method ListNode (line 23) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 30) | ListNode *mergeKLists(vector<ListNode *> &lists) {
    method ListNode (line 23) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 53) | ListNode *mergeTwoLists(ListNode* head1, ListNode* head2){
    method ListNode (line 23) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 68) | ListNode *mergeTwoLists01(ListNode* head1, ListNode* head2){
    method ListNode (line 23) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 100) | ListNode *mergeTwoLists02(ListNode* head1, ListNode* head2) {
    method ListNode (line 23) | ListNode(int x) : val(x), next(NULL) {}
  function TakeOutNode (line 125) | void TakeOutNode(ListNode*& head, ListNode*& tail, ListNode*& p){
  function printList (line 137) | void printList(ListNode* h)
  function ListNode (line 146) | ListNode* createList(int a[], int n)
    method ListNode (line 23) | ListNode(int x) : val(x), next(NULL) {}
  function main (line 161) | int main(int argc, char**argv)

FILE: algorithms/cpp/mergeStringsAlternately/MergeStringsAlternately.cpp
  class Solution (line 46) | class Solution {
    method string (line 48) | string mergeAlternately(string word1, string word2) {

FILE: algorithms/cpp/mergeTwoSortedArray/mergeTwoSortedArray.cpp
  function merge (line 18) | void merge(int A[], int m, int B[], int n) {
  function printArray (line 42) | void printArray(int A[], int n) {
  function main (line 50) | int main()

FILE: algorithms/cpp/mergeTwoSortedList/mergeTwoSortedList.cpp
  class Solution (line 20) | class Solution {
    method Solution (line 22) | Solution(){
    method ListNode (line 25) | ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
    method ListNode (line 37) | ListNode *mergeTwoLists01(ListNode* head1, ListNode* head2){
    method ListNode (line 64) | ListNode *mergeTwoLists02(ListNode *l1, ListNode *l2) {
    method ListNode (line 92) | ListNode* mergeTheRest(ListNode* l, ListNode*head, ListNode* tail){
    method ListNode (line 109) | ListNode *mergeTwoLists03(ListNode *l1, ListNode *l2) {

FILE: algorithms/cpp/minCostClimbingStairs/MinCostClimbingStairs.cpp
  class Solution (line 32) | class Solution {
    method minCostClimbingStairs (line 34) | int minCostClimbingStairs(vector<int>& cost) {
    method minCostClimbingStairs01 (line 38) | int minCostClimbingStairs01(vector<int>& cost) {
    method minCostClimbingStairs02 (line 48) | int minCostClimbingStairs02(vector<int>& cost) {

FILE: algorithms/cpp/minStack/minStack.cpp
  class Stack (line 26) | class Stack {
    method Stack (line 32) | Stack():_capacity(1),_top(-1){
    method push (line 40) | void push(T x){
    method T (line 52) | T pop() {
    method T (line 56) | T& top(bool pop=false) {
    method empty (line 67) | bool empty(){
    method size (line 70) | int size() {
    method clear (line 73) | void clear(){
  class MinStack (line 99) | class MinStack {
    type minData (line 103) | struct minData{
      method minData (line 106) | minData():min(0), cnt(0) {}
      method minData (line 107) | minData(int m, int c):min(m),cnt(c){}
    method push (line 115) | void push(int x) {
    method pop (line 134) | void pop() {
    method top (line 150) | int top() {
    method getMin (line 154) | int getMin() {
    method clear (line 157) | void clear() {
  function main (line 164) | int main()

FILE: algorithms/cpp/miniParser/MiniParser.cpp
  class Solution (line 69) | class Solution {
    method NestedInteger (line 71) | NestedInteger deserialize(string s) {
    method NestedInteger (line 79) | NestedInteger helper(string& s, int& pos) {
    method NestedInteger (line 97) | NestedInteger atoni(string& s, int& pos) {
    method isnum (line 113) | bool isnum(char& c) {

FILE: algorithms/cpp/minimizeMaximumPairSumInArray/MinimizeMaximumPairSumInArray.cpp
  class Solution (line 42) | class Solution {
    method minPairSum (line 44) | int minPairSum(vector<int>& nums) {

FILE: algorithms/cpp/minimumASCIIDeleteSumForTwoStrings/MinimumAsciiDeleteSumForTwoStrings.cpp
  class Solution (line 32) | class Solution {
    method minimumDeleteSum (line 34) | int minimumDeleteSum(string s1, string s2) {

FILE: algorithms/cpp/minimumAbsoluteSumDifference/MinimumAbsoluteSumDifference.cpp
  class Solution (line 54) | class Solution {
    method minAbsoluteSumDiff (line 56) | int minAbsoluteSumDiff(vector<int>& nums1, vector<int>& nums2) {

FILE: algorithms/cpp/minimumAdjacentSwapsToReachTheKthSmallestNumber/MinimumAdjacentSwapsToReachTheKthSmallestNumber.cpp
  class Solution (line 57) | class Solution {
    method nextPermutation (line 61) | void nextPermutation(string& num) {
    method reverse (line 76) | void reverse(string& num, int start) {
    method getMinSwaps (line 87) | int getMinSwaps(string num, int k) {

FILE: algorithms/cpp/minimumChangesToMakeAlternatingBinaryString/MinimumChangesToMakeAlternatingBinaryString.cpp
  class Solution (line 39) | class Solution {
    method minOperations (line 41) | int minOperations(string s) {

FILE: algorithms/cpp/minimumCostForTickets/MinimumCostForTickets.cpp
  class Solution (line 53) | class Solution {
    method min (line 55) | int min(int x, int y){
    method min (line 58) | int min(int x, int y, int z) {
    method mincostTickets (line 62) | int mincostTickets(vector<int>& days, vector<int>& costs) {

FILE: algorithms/cpp/minimumDegreeOfAConnectedTrioInAGraph/MinimumDegreeOfAConnectedTrioInAGraph.cpp
  class Solution (line 45) | class Solution {
    method has_edge (line 50) | bool has_edge(int x, int y) {
    method node_edges (line 54) | int node_edges(int x){
    method degree (line 58) | int degree(int x, int y, int z) {
    method minTrioDegree (line 66) | int minTrioDegree(int n, vector<vector<int>>& edges) {

FILE: algorithms/cpp/minimumDepthOfBinaryTree/minimumDepthOfBinaryTree.cpp
  class Solution (line 23) | class Solution {
    method minDepth (line 25) | int minDepth(TreeNode *root) {

FILE: algorithms/cpp/minimumDistanceToTheTargetElement/MinimumDistanceToTheTargetElement.cpp
  class Solution (line 41) | class Solution {
    method getMinDistance (line 43) | int getMinDistance(vector<int>& nums, int target, int start) {

FILE: algorithms/cpp/minimumElementsToAddToFormAGivenSum/MinimumElementsToAddToFormAGivenSum.cpp
  class Solution (line 34) | class Solution {
    method sum (line 36) | long sum(vector<int>& nums) {
    method minElements (line 43) | int minElements(vector<int>& nums, int limit, int goal) {

FILE: algorithms/cpp/minimumFallingPathSum/MinimumFallingPathSum.cpp
  class Solution (line 31) | class Solution {
    method min (line 33) | int min(int x, int y) {
    method min (line 36) | int min( int x, int y, int z) {
    method minFallingPathSum (line 40) | int minFallingPathSum(vector<vector<int>>& A) {

FILE: algorithms/cpp/minimumHeightTrees/MinimumHeightTrees.cpp
  class Solution (line 64) | class Solution {
    method findMinHeightTrees (line 66) | vector<int> findMinHeightTrees(int n, vector<pair<int, int>>& edges) {

FILE: algorithms/cpp/minimumInsertionsToBalanceAParenthesesString/MinimumInsertionsToBalanceAParenthesesString.cpp
  class Solution (line 60) | class Solution {
    method minInsertions (line 62) | int minInsertions(string s) {

FILE: algorithms/cpp/minimumIntervalToIncludeEachQuery/MinimumIntervalToIncludeEachQuery.cpp
  class Solution (line 47) | class Solution {
    method minInterval (line 49) | vector<int> minInterval(vector<vector<int>>& intervals, vector<int>& q...

FILE: algorithms/cpp/minimumLengthOfStringAfterDeletingSimilarEnds/MinimumLengthOfStringAfterDeletingSimilarEnds.cpp
  class Solution (line 49) | class Solution {
    method minimumLength (line 51) | int minimumLength(string s) {

FILE: algorithms/cpp/minimumLimitOfBallsInABag/MinimumLimitOfBallsInABag.cpp
  class Solution (line 53) | class Solution {
    method minimumSize (line 55) | int minimumSize(vector<int>& nums, int maxOperations) {

FILE: algorithms/cpp/minimumNumberOfOperationsToMoveAllBallsToEachBox/MinimumNumberOfOperationsToMoveAllBallsToEachBox.cpp
  class Solution (line 40) | class Solution {
    method minOperations (line 43) | vector<int> minOperations(string boxes) {
    method minOperations01 (line 50) | void minOperations01(string& boxes, vector<int>& result ) {
    method minOperations02 (line 64) | void minOperations02(string& boxes, vector<int>& result ) {

FILE: algorithms/cpp/minimumNumberOfOperationsToReinitializeAPermutation/MinimumNumberOfOperationsToReinitializeAPermutation.cpp
  class Solution (line 48) | class Solution {
    method check (line 50) | bool check(vector<int>& a) {
    method reinitializePermutation (line 57) | int reinitializePermutation(int n) {

FILE: algorithms/cpp/minimumNumberOfPeopleToTeach/MinimumNumberOfPeopleToTeach.cpp
  class Solution (line 47) | class Solution {
    method hasLang (line 50) | bool hasLang(vector<int>& langlist, int lang){
    method canComm (line 57) | bool canComm(int u, int v, int n, vector<vector<bool>>& langs) {
    method minimumTeachings (line 64) | int minimumTeachings(int n, vector<vector<int>>& languages, vector<vec...

FILE: algorithms/cpp/minimumOperationsToMakeArrayEqual/MinimumOperationsToMakeArrayEqual.cpp
  class Solution (line 36) | class Solution {
    method minOperations (line 38) | int minOperations(int n) {

FILE: algorithms/cpp/minimumOperationsToMakeTheArrayIncreasing/MinimumOperationsToMakeTheArrayIncreasing.cpp
  class Solution (line 42) | class Solution {
    method minOperations (line 44) | int minOperations(vector<int>& nums) {

FILE: algorithms/cpp/minimumPathSum/minimumPathSum.cpp
  function minPathSum (line 30) | int minPathSum(vector<vector<int>>& grid) {
  function main (line 42) | int main()

FILE: algorithms/cpp/minimumSidewayJumps/MinimumSidewayJumps.cpp
  class Solution (line 56) | class Solution {
    method min (line 58) | int min (int x, int y) {
    method min (line 61) | int min(int x, int y, int z) {
    method print (line 64) | void print(vector<vector<int>>& matrix) {
    method minSideJumps (line 80) | int minSideJumps(vector<int>& obstacles) {

FILE: algorithms/cpp/minimumSizeSubarraySum/MinimumSizeSubarraySum.cpp
  class Solution (line 24) | class Solution {
    method minSubArrayLen (line 26) | int minSubArrayLen(int s, vector<int>& nums) {

FILE: algorithms/cpp/minimumSpeedToArriveOnTime/MinimumSpeedToArriveOnTime.cpp
  class Solution (line 62) | class Solution {
    method verify (line 64) | bool verify(vector<int>& dist, double hour, int speed) {
    method minSpeedOnTime (line 74) | int minSpeedOnTime(vector<int>& dist, double hour) {

FILE: algorithms/cpp/minimumWindowSubstring/minimumWindowSubstring.cpp
  function string (line 34) | string minWindow(string s, string t) {
  function main (line 110) | int main(int argc, char**argv)

FILE: algorithms/cpp/mirrorReflection/MirrorReflection.cpp
  class Solution (line 58) | class Solution {
    method greatestCommonDivisor (line 61) | int greatestCommonDivisor (int a, int b) {
    method leastCommonMultiple (line 66) | int leastCommonMultiple(int a, int b) {
    method mirrorReflection (line 70) | int mirrorReflection(int p, int q) {

FILE: algorithms/cpp/missingNumber/MissingNumber.cpp
  class Solution (line 22) | class Solution {
    method missingNumber01 (line 29) | int missingNumber01(vector<int>& nums) {
    method missingNumber02 (line 41) | int missingNumber02(vector<int>& nums) {
    method missingNumber (line 49) | int missingNumber(vector<int>& nums) {

FILE: algorithms/cpp/missingRanges/missingRanges.cpp
  function string (line 25) | string& makeRange(int lo, int hi){
  function findMissingRanges (line 39) | vector<string> findMissingRanges(int A[], int n, int lower, int upper) {
  function printVector (line 67) | void printVector(vector<string> v){
  function string2Array (line 77) | vector<int> string2Array(string s){
  function main (line 94) | int main(int argc, char**argv)

FILE: algorithms/cpp/mostCommonWord/MostCommonWord.cpp
  class Solution (line 50) | class Solution {
    method isLetter (line 52) | bool isLetter(char c) {
    method string (line 56) | string mostCommonWord(string paragraph, vector<string>& banned) {

FILE: algorithms/cpp/moveZeroes/moveZeroes.cpp
  class Solution (line 24) | class Solution {
    method moveZeroes (line 40) | void moveZeroes(vector<int>& nums) {
    method moveZeroes (line 70) | void moveZeroes(vector<int>& nums) {

FILE: algorithms/cpp/multiplyStrings/multiplyStrings.cpp
  function string (line 17) | string multiply(string& num, char ch){
  function string (line 33) | string strPlus(string& num1, string& num2) {
  function string (line 54) | string multiply(string num1, string num2) {
  class Solution (line 78) | class Solution {
    method string (line 81) | string strPlus(string& num1, string& num2) {
    method string (line 108) | string multiply(string num1, string num2) {
  function main (line 137) | int main(int argc, char**argv)

FILE: algorithms/cpp/nQueens/nQueuens.II.cpp
  function totalNQueens (line 25) | int totalNQueens(int n) {
  function solveNQueensRecursive (line 35) | void solveNQueensRecursive(int n, int currentRow, vector<int>& solution,...
  function isValid (line 50) | bool isValid(int attemptedColumn, int attemptedRow, vector<int> &queenIn...
  function main (line 63) | int main(int argc, char** argv)

FILE: algorithms/cpp/nQueens/nQueuens.cpp
  function solveNQueens (line 44) | vector< vector<string> > solveNQueens(int n) {
  function solveNQueensRecursive (line 56) | void solveNQueensRecursive(int n, int currentRow, vector<int>& solution,...
  function isValid (line 84) | bool isValid(int attemptedColumn, int attemptedRow, vector<int> &queenIn...
  function printMatrix (line 99) | void printMatrix(vector< vector<string> >& matrix ){
  function main (line 109) | int main(int argc, char** argv)

FILE: algorithms/cpp/nRepeatedElementInSize2NArray/N-Repeated-Element-in-Size-2N-Array.cpp
  class Solution (line 33) | class Solution {
    method repeatedNTimes (line 35) | int repeatedNTimes(vector<int>& A) {

FILE: algorithms/cpp/nextPermutation/nextPermutation.cpp
  function nextPermutation (line 73) | void nextPermutation(vector<int> &num) {
  function printVector (line 103) | void printVector(vector<int> &num) {
  function isBeginVector (line 109) | bool isBeginVector(vector<int> &num) {
  function main (line 118) | int main(int argc, char** argv)

FILE: algorithms/cpp/nimGame/nimGame.cpp
  class Solution (line 67) | class Solution {
    method canWinNim (line 69) | bool canWinNim(int n) {

FILE: algorithms/cpp/nthDigit/NthDigit.cpp
  class Solution (line 38) | class Solution {
    method findNthDigit (line 40) | int findNthDigit(int n) {

FILE: algorithms/cpp/numberOf1Bits/numberOf1Bits.cpp
  class Solution (line 17) | class Solution {
    method hammingWeight (line 19) | int hammingWeight(uint32_t n) {

FILE: algorithms/cpp/numberOfDifferentIntegersInAString/NumberOfDifferentIntegersInAString.cpp
  class Solution (line 43) | class Solution {
    method isNumber (line 45) | bool isNumber(char ch) {
    method numDifferentIntegers (line 50) | int numDifferentIntegers(string word) {

FILE: algorithms/cpp/numberOfDifferentSubsequencesGcds/NumberOfDifferentSubsequencesGcds.cpp
  class Solution (line 39) | class Solution {
    method gcd (line 43) | int gcd(int a, int b) {
    method countDifferentSubsequenceGCDs (line 53) | int countDifferentSubsequenceGCDs(vector<int>& nums) {

FILE: algorithms/cpp/numberOfDigitOne/NumberOfDigitOne.cpp
  class Solution (line 51) | class Solution {
    method countDigitOne (line 54) | int countDigitOne(int n) {

FILE: algorithms/cpp/numberOfGoodWaysToSplitAString/NumberOfGoodWaysToSplitAString.cpp
  class Solution (line 47) | class Solution {
    method numSplits (line 49) | int numSplits(string s) {

FILE: algorithms/cpp/numberOfIslands/NumberOfIslands.cpp
  function mark (line 33) | void mark(vector<vector<char> >& grid, int r, int c){
  function numIslands (line 48) | int numIslands(vector<vector<char> >& grid) {
  function initGrid (line 61) | void initGrid( string g[], int len, vector<vector<char> >& grid )
  function main (line 68) | int main(void)

FILE: algorithms/cpp/numberOfOrdersInTheBacklog/NumberOfOrdersInTheBacklog.cpp
  class Order (line 76) | class Order {
  type COMP (line 82) | enum COMP { GREATER, LESS }
  class OrderComp (line 85) | class OrderComp {
  class Solution (line 96) | class Solution {
    method processOrder (line 99) | void processOrder(T1& q1, T2& q2, COMP op, int price, int amount, stri...
    method countQ (line 128) | void countQ(T& q, int& amount){
    method getNumberOfBacklogOrders (line 135) | int getNumberOfBacklogOrders(vector<vector<int>>& orders) {

FILE: algorithms/cpp/numberOfRecentCalls/NumberOfRecentCalls.cpp
  class RecentCounter (line 30) | class RecentCounter {
    method RecentCounter (line 32) | RecentCounter() {
    method ping (line 36) | int ping(int t) {
    method binary_search (line 42) | int binary_search(int x) {

FILE: algorithms/cpp/numberOfRectanglesThatCanFormTheLargestSquare/NumberOfRectanglesThatCanFormTheLargestSquare.cpp
  class Solution (line 38) | class Solution {
    method countGoodRectangles (line 40) | int countGoodRectangles(vector<vector<int>>& rectangles) {
    method countGoodRectangles1 (line 45) | int countGoodRectangles1(vector<vector<int>>& rectangles) {
    method countGoodRectangles2 (line 59) | int countGoodRectangles2(vector<vector<int>>& rectangles) {

FILE: algorithms/cpp/numberOfRestrictedPathsFromFirstToLastNode/NumberOfRestrictedPathsFromFirstToLastNode.cpp
  class Solution (line 51) | class Solution {
    method printVector (line 52) | void printVector(vector<int>& v) {
    method countRestrictedPaths (line 60) | int countRestrictedPaths(int n, vector<vector<int>>& edges) {

FILE: algorithms/cpp/numberOfStudentsUnableToEatLunch/NumberOfStudentsUnableToEatLunch.cpp
  class Solution (line 60) | class Solution {
    method countStudents (line 62) | int countStudents(vector<int>& students, vector<int>& sandwiches) {

FILE: algorithms/cpp/numberOfSubArraysWithOddSum/NumberOfSubArraysWithOddSum.cpp
  class Solution (line 48) | class Solution {
    method numOfSubarrays (line 50) | int numOfSubarrays(vector<int>& arr) {

FILE: algorithms/cpp/numberOfSubstringsWithOnly1s/NumberOfSubstringsWithOnly1s.cpp
  class Solution (line 45) | class Solution {
    method numSub (line 53) | int numSub(string s) {

FILE: algorithms/cpp/oddEvenLinkedList/OddEvenLinkedList.cpp
  class Solution (line 34) | class Solution {
    method ListNode (line 36) | ListNode* oddEvenList(ListNode* head) {

FILE: algorithms/cpp/oneEditDistance/oneEditDistance.cpp
  function isOneEditDistance (line 30) | bool isOneEditDistance(string s, string t) {
  function main (line 77) | int main(int argc, char** argv)

FILE: algorithms/cpp/palindromeLinkedList/PalindromeLinkedList.cpp
  class Solution (line 22) | class Solution {
    method ListNode (line 24) | ListNode* findMiddle(ListNode* head) {
    method ListNode (line 33) | ListNode* reverseLink(ListNode* head) {
    method isPalindrome (line 45) | bool isPalindrome(ListNode* head) {

FILE: algorithms/cpp/palindromeNumber/palindromeNumber.cpp
  class Solution (line 26) | class Solution {
    method isPalindrome (line 29) | bool isPalindrome(int x) {
    method isPalindrome1 (line 34) | bool isPalindrome1(int x) {
    method isPalindrome2 (line 56) | bool isPalindrome2(int x) {
    method reverse (line 61) | int reverse(int x) {
  function main (line 79) | int main()

FILE: algorithms/cpp/palindromePairs/PalindromePairs.cpp
  class Solution (line 26) | class Solution {
    method isPalindrome (line 28) | bool isPalindrome(string& str) {
    method palindromePairs (line 35) | vector<vector<int>> palindromePairs(vector<string>& words) {

FILE: algorithms/cpp/palindromePartitioning/palindromePartitioning.II.cpp
  function minCut (line 28) | int minCut(string s) {
  function minCut_DP (line 85) | int minCut_DP(string& s) {
  function minCutHelper (line 129) | int minCutHelper(string &s, int steps, int& minSteps ) {
  function minCutHelper (line 178) | void minCutHelper(string &s, int start, int steps, int& min ) {
  function isPalindrome (line 197) | bool isPalindrome(string &s, int start, int end)  {
  function main (line 214) | int main(int argc, char** argv)

FILE: algorithms/cpp/palindromePartitioning/palindromePartitioning.cpp
  function isPalindrome (line 29) | bool isPalindrome(string &s, int start, int end)  {
  function partitionHelper (line 69) | void partitionHelper(string &s, int start, vector<string> &output, vecto...
  function partition (line 87) | vector< vector<string> > partition(string s) {
  function printMatrix (line 98) | void printMatrix(vector< vector<string> > &matrix)
  function main (line 111) | int main(int argc, char** argv)

FILE: algorithms/cpp/palindromicSubstrings/PalindromicSubstrings.cpp
  class Solution (line 30) | class Solution {
    method countSubstrings (line 32) | int countSubstrings(string s) {

FILE: algorithms/cpp/partitionEqualSubsetSum/PartitionEqualSubsetSum.cpp
  class Solution (line 38) | class Solution {
    method canPartitionRecrusion (line 41) | bool canPartitionRecrusion(vector<int>& nums, int half, int index) {
    method canPartition (line 52) | bool canPartition(vector<int>& nums) {

FILE: algorithms/cpp/partitionList/partitionList.cpp
  type ListNode (line 21) | struct ListNode {
    method ListNode (line 24) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 27) | ListNode *partition(ListNode *head, int x) {
    method ListNode (line 24) | ListNode(int x) : val(x), next(NULL) {}
  function printList (line 53) | void printList(ListNode* h)
  function ListNode (line 62) | ListNode* createList(int a[], int n)
    method ListNode (line 24) | ListNode(int x) : val(x), next(NULL) {}
  function main (line 76) | int main()

FILE: algorithms/cpp/pascalTriangle/pascalTriangle.II.cpp
  function getRow (line 23) | vector<int> getRow(int rowIndex) {
  function printVector (line 36) | void printVector( vector<int>  pt)
  function main (line 45) | int main(int argc, char** argv)

FILE: algorithms/cpp/pascalTriangle/pascalTriangle.cpp
  function generate (line 28) | vector<vector<int> > generate(int numRows)
  function printTriangle (line 47) | void printTriangle(vector< vector<int> > pt)
  function main (line 70) | int main(int argc, char** argv)

FILE: algorithms/cpp/patchingArray/PatchingArray.cpp
  class Solution (line 35) | class Solution {
    method minPatches (line 37) | int minPatches(vector<int>& nums, int n) {
    method minPatches_01 (line 66) | int minPatches_01(vector<int>& nums, int n) {
    method minPatches_02 (line 100) | int minPatches_02(vector<int>& nums, int n) {

FILE: algorithms/cpp/pathSum/pathSum.II.cpp
  class Solution (line 39) | class Solution {
    method pathSum (line 41) | vector<vector<int> > pathSum(TreeNode *root, int sum) {
    method generatePathSum (line 48) | void generatePathSum(TreeNode *root, int sum, int s, vector<int> v, ve...

FILE: algorithms/cpp/pathSum/pathSum.cpp
  class Solution (line 36) | class Solution {
    method Solution (line 38) | Solution(){
    method hasPathSum (line 41) | bool hasPathSum(TreeNode *root, int sum) {
    method hasPathSum3 (line 47) | bool hasPathSum3(TreeNode* root, int sum, int s) {
    method hasPathSum1 (line 54) | bool hasPathSum1(TreeNode *root, int sum) {
    method hasPathSum2 (line 79) | bool hasPathSum2(TreeNode *root, int sum) {

FILE: algorithms/cpp/peakIndexInAMountainArray/PeakIndexInAMountainArray.cpp
  class Solution (line 42) | class Solution {
    method peakIndexInMountainArray (line 44) | int peakIndexInMountainArray(vector<int>& A) {

FILE: algorithms/cpp/peekingIterator/PeekingIterator.cpp
  class Iterator (line 37) | class Iterator {
    type Data (line 38) | struct Data
  class PeekingIterator (line 51) | class PeekingIterator : public Iterator {
    method takeNext (line 56) | void takeNext() {
    method PeekingIterator (line 63) | PeekingIterator(const vector<int>& nums) : Iterator(nums) {
    method peek (line 71) | int peek() {
    method next (line 77) | int next() {
    method hasNext (line 84) | bool hasNext() const {

FILE: algorithms/cpp/perfectRectangle/PerfectRectangle.cpp
  class Solution (line 61) | class Solution {
    method isRectangleCover (line 63) | bool isRectangleCover(vector<vector<int>>& rectangles) {

FILE: algorithms/cpp/perfectSquares/PerfectSquares.cpp
  class Solution (line 19) | class Solution {
    method numSquares (line 22) | int numSquares(int n) {
    method numSquares_dp (line 62) | int numSquares_dp(int n) {
    method numSquares_dp_opt (line 81) | int numSquares_dp_opt(int n) {

FILE: algorithms/cpp/permutationSequence/permutationSequence.cpp
  function string (line 46) | string getPermutation(int n, int k) {
  function string (line 83) | string getPermutation_0(int n, int k) {
  function string (line 116) | string getPermutation_1(int n, int k) {
  function nextPermutation (line 137) | void nextPermutation(vector<int>& num) {
  function main (line 158) | int main(int argc, char**argv)

FILE: algorithms/cpp/permutations/permutations.II.cpp
  function permute (line 27) | vector<vector<int> > permute(vector<int> &num) {
  function printVector (line 60) | void printVector( vector<int>&  pt)
  function main (line 70) | int main(int argc, char** argv)

FILE: algorithms/cpp/permutations/permutations.cpp
  function permute (line 62) | vector<vector<int> > permute(vector<int> &num) {
  function main (line 89) | int main(int argc, char** argv)

FILE: algorithms/cpp/plusOne/plusOne.cpp
  function plusOne (line 17) | vector<int> plusOne(vector<int> &digits) {
  function printVector (line 34) | void printVector(vector<int>& v)
  function main (line 44) | int main()

FILE: algorithms/cpp/populatingNextRightPointersInEachNode/populatingNextRightPointersInEachNode.II.cpp
  type TreeLinkNode (line 41) | struct TreeLinkNode {
    method TreeLinkNode (line 44) | TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
    method TreeLinkNode (line 45) | TreeLinkNode() : val(0), left(NULL), right(NULL), next(NULL) {}
  function connect (line 47) | void connect(TreeLinkNode *root) {
  function connect1 (line 77) | void connect1(TreeLinkNode *root) {
  function connect3 (line 126) | void connect3(TreeLinkNode *root) {
  function connect4 (line 157) | void connect4(TreeLinkNode *root) {
  function printTree (line 191) | void printTree(TreeLinkNode *root){
  function main (line 207) | int main()

FILE: algorithms/cpp/populatingNextRightPointersInEachNode/populatingNextRightPointersInEachNode.cpp
  type TreeLinkNode (line 53) | struct TreeLinkNode {
    method TreeLinkNode (line 56) | TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
    method TreeLinkNode (line 57) | TreeLinkNode() : val(0), left(NULL), right(NULL), next(NULL) {}
  function connect (line 61) | void connect(TreeLinkNode *root) {
  function connect1 (line 77) | void connect1(TreeLinkNode *root) {
  function connect2 (line 107) | void connect2(TreeLinkNode *root) {
  function connect3 (line 134) | void connect3(TreeLinkNode *root) {
  function connect4 (line 165) | void connect4(TreeLinkNode *root) {
  function printTree (line 199) | void printTree(TreeLinkNode *root){
  function main (line 214) | int main()

FILE: algorithms/cpp/pow/pow.cpp
  function pow (line 39) | double pow(double x, int n) {
  function main (line 60) | int main(int argc, char** argv){

FILE: algorithms/cpp/powerOfFour/PowerOfFour.cpp
  class Solution (line 21) | class Solution {
    method isPowerOfFour (line 23) | bool isPowerOfFour(int num) {

FILE: algorithms/cpp/powerOfThree/PowerOfThree.cpp
  class Solution (line 17) | class Solution {
    method isPowerOfThree (line 21) | bool isPowerOfThree(int n) {
    method isPowerOfThree03 (line 29) | bool isPowerOfThree03(int n) {
    method isPowerOfThree02 (line 33) | bool isPowerOfThree02(int n) {
    method init (line 37) | void init(unordered_map<int, bool>& power ){
    method isPowerOfThree01 (line 47) | bool isPowerOfThree01(int n) {
    method isPowerOfThree_loop (line 53) | bool isPowerOfThree_loop(int n) {
    method isPowerOfThree_recursive (line 61) | bool isPowerOfThree_recursive(int n) {

FILE: algorithms/cpp/powerOfTwo/PowerOfTwo.cpp
  class Solution (line 17) | class Solution {
    method isPowerOfTwo01 (line 21) | bool isPowerOfTwo01(int n) {
    method isPowerOfTwo02 (line 34) | bool isPowerOfTwo02(int n) {
    method isPowerOfTwo (line 38) | bool isPowerOfTwo(int n) {

FILE: algorithms/cpp/processTasksUsingServers/ProcessTasksUsingServers.cpp
  class Solution (line 62) | class Solution {
    method print (line 65) | void print(T  q) {
    method assignTasks (line 76) | vector<int> assignTasks(vector<int>& servers, vector<int>& tasks) {

FILE: algorithms/cpp/productOfArrayExceptSelf/ProductOfArrayExceptSelf.cpp
  class Solution (line 20) | class Solution {
    method productExceptSelf (line 22) | vector<int> productExceptSelf(vector<int>& nums) {

FILE: algorithms/cpp/queriesOnNumberOfPointsInsideACircle/QueriesOnNumberOfPointsInsideACircle.cpp
  class Solution (line 46) | class Solution {
    method inCircle (line 49) | bool inCircle( vector<int>& point,  vector<int>& circle ) {
    method countPoints (line 61) | vector<int> countPoints(vector<vector<int>>& points, vector<vector<int...

FILE: algorithms/cpp/queueReconstructionByHeight/QueueReconstructionByHeight.cpp
  class Solution (line 24) | class Solution {
    method reconstructQueue (line 27) | vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people) {

FILE: algorithms/cpp/randomPickIndex/RandomPickIndex.cpp
  class Solution (line 28) | class Solution {
    method Solution (line 32) | Solution(vector<int> nums) {
    method pick (line 37) | int pick(int target) {

FILE: algorithms/cpp/randomPointInNonOverlappingRectangles/randomPointInNonOverlappingRectangles.cpp
  class Solution (line 43) | class Solution {
    method Solution (line 49) | Solution(vector<vector<int>>& rects) {
    method pick (line 57) | vector<int> pick() {

FILE: algorithms/cpp/rangeSumQuery-Immutable/rangeSumQuery-Immutable.cpp
  class NumArray (line 22) | class NumArray {
    method NumArray (line 38) | NumArray(vector<int> &nums): size(nums.size()), sums(size+1, 0) {
    method sumRange (line 43) | int sumRange(int i, int j) {

FILE: algorithms/cpp/rangeSumQuery-Immutable/rangeSumQuery-Mutable/RangeSumQueryMutable.cpp
  class NumArray (line 34) | class NumArray {
    method NumArray (line 40) | NumArray(vector<int> &nums)  {
    method update (line 49) | void update(int i, int val) {
    method sumRange (line 57) | int sumRange(int i, int j) {
    method sumRange (line 61) | int sumRange(int i) {

FILE: algorithms/cpp/rangeSumQuery2D-Immutable/RangeSumQuery2dImmutable.cpp
  class NumMatrix (line 78) | class NumMatrix {
    method NumMatrix (line 83) | NumMatrix(vector<vector<int>> &matrix) {
    method sumRegion (line 94) | int sumRegion(int row1, int col1, int row2, int col2) {

FILE: algorithms/cpp/ransomNote/RansomNote.cpp
  class Solution (line 24) | class Solution {
    method canConstruct (line 26) | bool canConstruct(string ransomNote, string magazine) {

FILE: algorithms/cpp/readNCharactersGivenRead4/readNCharactersGivenRead4.II.cpp
  function read4 (line 31) | int read4(char *buf) {
  class RingBuffer (line 42) | class RingBuffer {
    method RingBuffer (line 45) | RingBuffer(int cap=4): _capacity(cap) {
    method read (line 55) | int read(char* buf, int n){
    method write (line 69) | int write(char* buf, int n) {
  class Solution (line 94) | class Solution {
    method read (line 101) | int read(char *buf, int n) {
    method read1 (line 120) | int read1(char *buf, int n) {
  function main (line 148) | int main()

FILE: algorithms/cpp/readNCharactersGivenRead4/readNCharactersGivenRead4.cpp
  class Solution (line 24) | class Solution {
    method read (line 31) | int read(char *buf, int n) {
    method read1 (line 40) | int read1(char *buf, int n) {
    method read2 (line 54) | int read2(char *buf, int n) {

FILE: algorithms/cpp/reconstructItinerary/ReconstructItinerary.cpp
  class Solution (line 56) | class Solution {
    method travel (line 59) | void travel(string& start, unordered_map<string, multiset<string>>& ma...
    method findItinerary (line 68) | vector<string> findItinerary(vector<pair<string, string>> tickets) {

FILE: algorithms/cpp/recoverATreeFromPreorderTraversal/recoverATreeFromPreorderTraversal.cpp
  class Solution (line 49) | class Solution {
    method TreeNode (line 52) | TreeNode* recoverFromPreorder(string S) {

FILE: algorithms/cpp/recoverBinarySearchTree/recoverBinarySearchTree.cpp
  class Solution (line 62) | class Solution {
    method recoverTreeHelper (line 64) | void recoverTreeHelper(TreeNode *root) {
    method recoverTree (line 81) | void recoverTree(TreeNode *root) {

FILE: algorithms/cpp/rectangleArea/RectangleArea.cpp
  type leetcode (line 40) | namespace leetcode
    class Point (line 42) | class Point {
      method Point (line 44) | Point(int _x, int _y):x(_x),y(_y) {}
    class Rectangle (line 48) | class Rectangle {
      method Rectangle (line 50) | Rectangle(int a, int b, int c, int d):topLeft(a,d), bottomRight(c,b)...
      method Area (line 51) | int Area(){
      method InclusiveArea (line 55) | int InclusiveArea (Rectangle &r){
      method OverlappedArea (line 70) | int OverlappedArea(Rectangle &r) {
  function computeArea (line 82) | int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
  function main (line 93) | int main()

FILE: algorithms/cpp/reformatPhoneNumber/ReformatPhoneNumber.cpp
  class Solution (line 70) | class Solution {
    method string (line 72) | string reformatNumber(string number) {

FILE: algorithms/cpp/regularExpressionMatching/regularExpressionMatching.cpp
  function isMatch (line 36) | bool isMatch(const char *s, const char *p) {
  function main (line 60) | int main(int argc, char** argv)

FILE: algorithms/cpp/removeDuplicateLetters/RemoveDuplicateLetters.cpp
  class Solution (line 24) | class Solution {
    method string (line 26) | string removeDuplicateLetters(string s) {

FILE: algorithms/cpp/removeDuplicatesFromSortedArray/removeDuplicatesFromSortedArray.II.cpp
  function removeDuplicates (line 21) | int removeDuplicates(int A[], int n) {
  function printfArray (line 40) | void printfArray(int A[], int n) {
  function testSuite (line 49) | void testSuite(int a[], int n){
  function main (line 57) | int main()

FILE: algorithms/cpp/removeDuplicatesFromSortedArray/removeDuplicatesFromSortedArray.cpp
  class Solution (line 20) | class Solution {
    method removeDuplicates (line 22) | int removeDuplicates(int A[], int n) {

FILE: algorithms/cpp/removeDuplicatesFromSortedList/removeDuplicatesFromSortedList.II.cpp
  type ListNode (line 19) | struct ListNode {
    method ListNode (line 22) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 25) | ListNode *deleteDuplicates(ListNode *head) {
    method ListNode (line 22) | ListNode(int x) : val(x), next(NULL) {}
  function printList (line 53) | void printList(ListNode* h)
  function ListNode (line 62) | ListNode* createList(int a[], int n)
    method ListNode (line 22) | ListNode(int x) : val(x), next(NULL) {}
  function main (line 77) | int main()

FILE: algorithms/cpp/removeDuplicatesFromSortedList/removeDuplicatesFromSortedList.cpp
  type ListNode (line 18) | struct ListNode {
    method ListNode (line 21) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 24) | ListNode *deleteDuplicates(ListNode *head) {
    method ListNode (line 21) | ListNode(int x) : val(x), next(NULL) {}
  function printList (line 36) | void printList(ListNode* h)
  function ListNode (line 45) | ListNode* createList(int a[], int n)
    method ListNode (line 21) | ListNode(int x) : val(x), next(NULL) {}
  function main (line 60) | int main()

FILE: algorithms/cpp/removeElement/removeElement.cpp
  class Solution (line 14) | class Solution {
    method removeElement (line 16) | int removeElement(vector<int>& nums, int val) {
    method removeElement (line 26) | int removeElement(int A[], int n, int elem) {

FILE: algorithms/cpp/removeInvalidParentheses/RemoveInvalidParentheses.cpp
  function removeInvalidParenthesesHelper (line 30) | void removeInvalidParenthesesHelper(string& s, int index, int pair,
  function removeInvalidParentheses (line 74) | vector<string> removeInvalidParentheses(string s) {
  function printVector (line 96) | void printVector(vector<string> result) {
  function main (line 103) | int main(int argc, char** argv) {

FILE: algorithms/cpp/removeKDigits/RemoveKDigits.cpp
  class Solution (line 37) | class Solution {
    method string (line 39) | string removeKdigits_pick(string& num, int k) {
    method string (line 64) | string removeKdigits_remove(string& num, int k) {
    method string (line 99) | string removeKdigits(string num, int k) {

FILE: algorithms/cpp/removeLinkedListElements/RemoveLinkedListElements.cpp
  class Solution (line 25) | class Solution {
    method ListNode (line 27) | ListNode* removeElements(ListNode* head, int val) {

FILE: algorithms/cpp/removeNthNodeFromEndOfList/removeNthNodeFromEndOfList.cpp
  class Solution (line 30) | class Solution {
    method ListNode (line 32) | ListNode *removeNthFromEnd(ListNode *head, int n) {

FILE: algorithms/cpp/reorderList/reorderList.cpp
  class ListNode (line 23) | class ListNode {
    method ListNode (line 27) | ListNode():val(0), next(NULL) {}
    method ListNode (line 28) | ListNode(int x) : val(x), next(NULL) {}
  class Solution (line 31) | class Solution {
    method reorderList (line 33) | void reorderList(ListNode *head) {
    method ListNode (line 40) | ListNode* findMidPos(ListNode *head){
    method ListNode (line 58) | ListNode* reverseList(ListNode *head){
    method ListNode (line 70) | ListNode* Merge(ListNode *h1, ListNode* h2) {
  function printList (line 89) | void printList(ListNode *h){
  function main (line 97) | int main(int argc, char** argv)

FILE: algorithms/cpp/repeatedDNASequences/repeatedDNASequences.cpp
  function ACGT2Int (line 34) | int ACGT2Int(char ch){
  function DNASeqs2Int (line 43) | int DNASeqs2Int(string &s, int begin){
  function findRepeatedDnaSequences_01 (line 51) | vector<string> findRepeatedDnaSequences_01(string s) {
  function findRepeatedDnaSequences_02 (line 68) | vector<string> findRepeatedDnaSequences_02(string s) {
  function findRepeatedDnaSequences (line 86) | vector<string> findRepeatedDnaSequences(string s) {
  function printVector (line 94) | void printVector( vector<string> v ) {
  function main (line 102) | int main(int argc, char** argv)

FILE: algorithms/cpp/replaceAllDigitsWithCharacters/ReplaceAllDigitsWithCharacters.cpp
  class Solution (line 46) | class Solution {
    method string (line 48) | string replaceDigits(string s) {

FILE: algorithms/cpp/restoreIPAddresses/restoreIPAddresses.cpp
  function restoreIpAddresses (line 25) | vector<string> restoreIpAddresses(string s) {
  function restoreIpAddressesHelper (line 32) | void restoreIpAddressesHelper(string& s, int start, int partNum, string ...
  function main (line 61) | int main(int argc, char**argv)

FILE: algorithms/cpp/restoreTheArrayFromAdjacentPairs/RestoreTheArrayFromAdjacentPairs.cpp
  class Solution (line 48) | class Solution {
    method restoreArray (line 50) | vector<int> restoreArray(vector<vector<int>>& adjacentPairs) {

FILE: algorithms/cpp/reverseBits/reverseBits.cpp
  class Solution (line 23) | class Solution {
    method reverseBits (line 25) | uint32_t reverseBits(uint32_t n) {

FILE: algorithms/cpp/reverseInteger/reverseInteger.cpp
  function reverse (line 36) | int reverse(int x) {
  function main (line 54) | int main(int argc, char**argv)

FILE: algorithms/cpp/reverseLinkedList/reverseLinkedList.II.cpp
  type ListNode (line 25) | struct ListNode {
    method ListNode (line 28) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 32) | ListNode *reverseBetween(ListNode *head, int m, int n) {
    method ListNode (line 28) | ListNode(int x) : val(x), next(NULL) {}
  function printList (line 72) | void printList(ListNode* h)
  function ListNode (line 81) | ListNode* createList(int *a, int n)
    method ListNode (line 28) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 95) | ListNode* createList(int len) {
    method ListNode (line 28) | ListNode(int x) : val(x), next(NULL) {}
  function main (line 105) | int main(int argc, char** argv)

FILE: algorithms/cpp/reverseLinkedList/reverseLinkedList.cpp
  class Solution (line 26) | class Solution {
    method ListNode (line 28) | ListNode* reverseList_iteratively(ListNode* head) {
    method ListNode (line 38) | ListNode* reverseList_recursively(ListNode* head) {
    method ListNode (line 46) | ListNode* reverseList(ListNode* head) {

FILE: algorithms/cpp/reverseNodesInKGroup/reverseNodesInKGroup.cpp
  type ListNode (line 30) | struct ListNode {
    method ListNode (line 33) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 38) | ListNode *reverseKGroup(ListNode *head, int k) {
    method ListNode (line 33) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 55) | ListNode *reverseList(ListNode *&head, int k){
    method ListNode (line 33) | ListNode(int x) : val(x), next(NULL) {}
  function printList (line 73) | void printList(ListNode* h)
  function ListNode (line 82) | ListNode* createList(int a[], int n)
    method ListNode (line 33) | ListNode(int x) : val(x), next(NULL) {}
  function main (line 97) | int main(int argc, char** argv)

FILE: algorithms/cpp/reverseString/ReverseString.cpp
  class Solution (line 13) | class Solution {
    method string (line 15) | string reverseString(string s) {

FILE: algorithms/cpp/reverseVowelsOfAString/reverseVowelsOfAString.cpp
  class Solution (line 19) | class Solution {
    method string (line 21) | string reverseVowels(string s) {
    method Solution (line 63) | Solution(){
    method isVowels (line 77) | bool isVowels(char ch) {
    method string (line 80) | string reverseVowels(string s) {
  class Solution (line 59) | class Solution {
    method string (line 21) | string reverseVowels(string s) {
    method Solution (line 63) | Solution(){
    method isVowels (line 77) | bool isVowels(char ch) {
    method string (line 80) | string reverseVowels(string s) {

FILE: algorithms/cpp/reverseWordsInAString/reverseWordsInAString.II.cpp
  function swap (line 26) | void swap(char &a, char &b) {
  function reverse (line 31) | void reverse(string &s, int begin, int end) {
  function reverseWords (line 36) | void reverseWords(string &s) {
  function main (line 53) | int main(int argc, char** argv)

FILE: algorithms/cpp/reverseWordsInAString/reverseWordsInAString.cpp
  function reverseWords (line 36) | void reverseWords(string &s) {
  function reverseWords2 (line 80) | void reverseWords2(string &s) {
  function reverse (line 109) | void reverse(char *b, char *e) {
  function reverseWords (line 117) | void reverseWords(char *s) {
  function test (line 140) | void test() {
  function main (line 154) | main()

FILE: algorithms/cpp/romanToInteger/romanToInteger.cpp
  function romanCharToInt (line 17) | int romanCharToInt(char ch){
  function romanToInt (line 44) | int romanToInt(string s) {
  function main (line 60) | int main(int argc, char**argv)

FILE: algorithms/cpp/rotateArray/rotateArray.cpp
  function reverseArray (line 28) | void reverseArray(int nums[],int start, int end){
  function rotate1 (line 43) | void rotate1(int nums[], int n, int k) {
  function rotate2 (line 60) | void rotate2(int nums[], int n, int k) {
  function rotate (line 85) | void rotate(int nums[], int n, int k) {
  function printArray (line 94) | void printArray(int nums[], int n) {
  function initArray (line 102) | void initArray(int nums[], int n) {
  function main (line 109) | int main(int argc, char**argv) {

FILE: algorithms/cpp/rotateFunction/RotateFunction.cpp
  class Solution (line 55) | class Solution {
    method maxRotateFunction (line 57) | int maxRotateFunction(vector<int>& A) {

FILE: algorithms/cpp/rotateImage/rotateImage.cpp
  function rotate (line 20) | void rotate(vector<vector<int> > &matrix) {
  function printMatrix (line 41) | void printMatrix(vector<vector<int> > &matrix)
  function main (line 53) | int main(int argc, char** argv)

FILE: algorithms/cpp/rotateList/rotateList.cpp
  class Solution (line 23) | class Solution {
    method ListNode (line 25) | ListNode *rotateRight(ListNode *head, int k) {

FILE: algorithms/cpp/rotatingTheBox/RotatingTheBox.cpp
  class Solution (line 60) | class Solution {
    method rotate (line 62) | void rotate(vector<vector<char>>& src, vector<vector<char>>& dest) {
    method gravity (line 70) | void gravity(vector<vector<char>>& box) {
    method rotateTheBox (line 87) | vector<vector<char>> rotateTheBox(vector<vector<char>>& box) {

FILE: algorithms/cpp/sameTree/sameTree.cpp
  class Solution (line 23) | class Solution {
    method Solution (line 25) | Solution(){
    method isSameTree (line 28) | bool isSameTree(TreeNode *p, TreeNode *q) {
    method isSameTree1 (line 35) | bool isSameTree1(TreeNode *p, TreeNode *q) {
    method isSameTree2 (line 43) | bool isSameTree2(TreeNode *p, TreeNode *q) {

FILE: algorithms/cpp/satisfiabilityOfEqualityEquations/SatisfiabilityOfEqualityEquations.cpp
  class Solution (line 53) | class Solution {
    method init (line 56) | void init() {
    method Solution (line 62) | Solution() {
    method find (line 69) | char find(char ch) {
    method join (line 77) | void join(char x, char y) {
    method equationsPossible (line 85) | bool equationsPossible(vector<string>& equations) {

FILE: algorithms/cpp/scrambleString/scrambleString.cpp
  function isScramble_recursion (line 66) | bool isScramble_recursion(string s1, string s2) {
  function isScramble_dp (line 120) | bool isScramble_dp(string s1, string s2) {
  function isScramble (line 158) | bool isScramble(string s1, string s2) {
  function main (line 170) | int main(int argc, char** argv)

FILE: algorithms/cpp/search2DMatrix/search2DMatrix.II.cpp
  class Solution (line 34) | class Solution {
    method binary_search (line 37) | bool binary_search(vector<int> &v, int target) {
    method searchMatrix01 (line 55) | bool searchMatrix01(vector<vector<int>>& matrix, int target) {
    method searchMatrix02 (line 68) | bool searchMatrix02(vector<vector<int>>& matrix, int target) {
    method searchMatrix021 (line 84) | bool searchMatrix021(vector<vector<int>>& matrix, int target) {
    method searchMatrix022 (line 102) | bool searchMatrix022(vector<vector<int>>& matrix, int target) {
    method searchMatrix (line 142) | bool searchMatrix(vector<vector<int>>& matrix, int target) {

FILE: algorithms/cpp/search2DMatrix/search2DMatrix.cpp
  class Solution (line 27) | class Solution {
    method searchMatrix (line 29) | bool searchMatrix(vector<vector<int>>& matrix, int target) {
    method searchMatrix01 (line 35) | bool searchMatrix01(vector<vector<int>>& matrix, int target) {
    method searchMatrix02 (line 57) | bool searchMatrix02(vector<vector<int> > &matrix, int target) {
    method vertical_binary_search (line 69) | int vertical_binary_search(vector< vector<int> > v, int key){
    method binary_search (line 89) | int binary_search(vector<int> v, int key) {

FILE: algorithms/cpp/searchForRange/searchForRange.cpp
  function searchRange (line 35) | vector<int> searchRange(int A[], int n, int target) {
  function binary_search (line 61) | int binary_search(int A[], int low, int high, int key){
  function printVector (line 78) | void printVector( vector<int>&  pt)
  function main (line 88) | int main()

FILE: algorithms/cpp/searchInRotatedSortedArray/searchInRotatedSortedArray.II.cpp
  class Solution (line 26) | class Solution {
    method search (line 28) | bool search(int A[], int n, int key) {

FILE: algorithms/cpp/searchInRotatedSortedArray/searchInRotatedSortedArray.cpp
  function search (line 28) | int search(int A[], int n, int target) {
  function search1 (line 42) | int search1(int A[], int n, int key) {
  function search2 (line 82) | int search2(int A[], int n, int target) {
  function rotate_search (line 96) | int rotate_search(int A[], int low, int high, int key ) {
  function binary_search (line 123) | int binary_search(int A[], int n, int key) {
  function binary_search (line 140) | int binary_search(int A[], int low, int high, int key) {
  function rotate_array (line 157) | void rotate_array(int a[], int n, int pos){
  function printArray (line 185) | void printArray(int A[], int n) {
  function main (line 193) | int main(int argc, char** argv)

FILE: algorithms/cpp/searchInsertPosition/searchInsertPosition.cpp
  function binary_search (line 24) | int binary_search(int A[], int n, int key) {
  function searchInsert (line 40) | int searchInsert(int A[], int n, int target) {
  function main (line 45) | int main()

FILE: algorithms/cpp/seatReservationManager/SeatReservationManager.cpp
  class SeatManager (line 51) | class SeatManager {
    method SeatManager (line 55) | SeatManager(int n) {
    method reserve (line 61) | int reserve() {
    method unreserve (line 68) | void unreserve(int seatNumber) {

FILE: algorithms/cpp/secondLargestDigitInAString/SecondLargestDigitInAString.cpp
  class Solution (line 30) | class Solution {
    method secondHighest (line 32) | int secondHighest(string s) {

FILE: algorithms/cpp/sentenceScreenFitting/main.cpp
  function main (line 20) | int main(int argc, const char * argv[]) {

FILE: algorithms/cpp/sentenceScreenFitting/sentenceScreenFitting.cpp
  function SentenceScreenFitting (line 87) | int SentenceScreenFitting(char stc[][M], int row, int col, size_t l)

FILE: algorithms/cpp/sentenceScreenFitting/sentenceScreenFitting.h
  function class (line 23) | class Solution {

FILE: algorithms/cpp/sentenceSimilarity/SentenceSimilarity.III.cpp
  class Solution (line 51) | class Solution {
    method isWord (line 53) | bool isWord(char ch) {
    method isSpace (line 56) | bool isSpace(char ch) {
    method split (line 59) | void split(string& s, vector<string>& words) {
    method print (line 70) | void print(vector<string>& v) {
    method areSentencesSimilar (line 78) | bool areSentencesSimilar(string sentence1, string sentence2) {

FILE: algorithms/cpp/serializeAndDeserializeBinaryTree/SerializeAndDeserializeBinaryTree.cpp
  type TreeNode (line 47) | struct TreeNode {
    method TreeNode (line 51) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  class Codec (line 55) | class Codec {
    method string (line 59) | string serialize(TreeNode* root) {
    method TreeNode (line 65) | TreeNode* deserialize(string data) {
    method string (line 78) | string serialize01(TreeNode* root) {
    method TreeNode (line 89) | TreeNode* deserialize01(string data) {
    method serializeHelper (line 100) | void serializeHelper(TreeNode* root, vector<TreeNode*>& v) {
    method TreeNode (line 111) | TreeNode* deserializeHelper(vector<TreeNode*> &v, int& index) {
    method split (line 124) | void split(const string &s, char delim, vector<TreeNode*> &elems) {
    method string (line 143) | string serialize02(TreeNode* root) {
    method TreeNode (line 150) | TreeNode* deserialize02(string data) {
    method serialize (line 156) | void serialize(TreeNode* root, ostringstream& out) {
    method TreeNode (line 166) | TreeNode* deserialize(istringstream& in) {
  function main (line 183) | int main(int argc, char** argv)

FILE: algorithms/cpp/setMatrixZeroes/setMatrixZeroes.cpp
  class Solution (line 21) | class Solution {
    method Solution (line 23) | Solution(){
    method setZeroes (line 26) | void setZeroes(vector<vector<int> > &matrix) {
    method setZeroes1 (line 33) | void setZeroes1(vector<vector<int> > &matrix) {
    method setZeroes2 (line 63) | void setZeroes2(vector<vector<int> > &matrix) {

FILE: algorithms/cpp/shortEncodingOfWords/ShortEncodingOfWords.cpp
  class Solution (line 29) | class Solution {
    method comp (line 31) | static bool comp(string a,string b){
    method minimumLengthEncoding (line 34) | int minimumLengthEncoding(vector<string>& words) {

FILE: algorithms/cpp/shortestPalindrome/ShortestPalindrome.cpp
  function isPalindrome (line 26) | bool isPalindrome(string& s, int begin, int end) {
  function string (line 36) | string shortestPalindrome_bf(string& s) {
  function string (line 52) | string shortestPalindrome_dp(string& s) {
  function string (line 131) | string shortestPalindrome_kmp(string& s) {
  function string (line 170) | string shortestPalindrome(string s) {
  function main (line 177) | int main(int argc, char**argv)

FILE: algorithms/cpp/shuffleAnArray/ShuffleAnArray.cpp
  class Solution (line 26) | class Solution {
    method Solution (line 28) | Solution(vector<int> nums) : _nums(nums), _solution(nums) {
    method reset (line 33) | vector<int> reset() {
    method shuffle (line 38) | vector<int> shuffle() {

FILE: algorithms/cpp/shuffleString/ShuffleString.cpp
  class Solution (line 51) | class Solution {
    method string (line 53) | string restoreString(string s, vector<int>& indices) {

FILE: algorithms/cpp/shuffleTheArray/ShuffleTheArray.cpp
  class Solution (line 34) | class Solution {
    method shuffle (line 36) | vector<int> shuffle(vector<int>& nums, int n) {

FILE: algorithms/cpp/signOfTheProductOfAnArray/SignOfTheProductOfAnArray.cpp
  class Solution (line 41) | class Solution {
    method arraySign (line 43) | int arraySign(vector<int>& nums) {

FILE: algorithms/cpp/simplifyPath/simplifyPath.cpp
  function split (line 41) | vector<string> split(const string &s, char delim) {
  function string (line 48) | string simplifyPath(string path) {
  function main (line 78) | int main(int argc, char** argv)

FILE: algorithms/cpp/singleNumber/singleNumber.II.cpp
  class Solution (line 15) | class Solution {
    method Solution (line 17) | Solution(){
    method singleNumber (line 22) | int singleNumber(int A[], int n) {
    method singleNumber_1 (line 41) | int singleNumber_1(int A[], int n) {
    method singleNumber_2 (line 72) | int singleNumber_2(int A[], int n) {

FILE: algorithms/cpp/singleNumber/singleNumber.III.cpp
  class Solution (line 67) | class Solution {
    method singleNumber (line 69) | vector<int> singleNumber(vector<int>& nums) {

FILE: algorithms/cpp/singleNumber/singleNumber.cpp
  function singleNumber (line 19) | int singleNumber(int A[], int n) {
  function main (line 27) | int main()

FILE: algorithms/cpp/singleThreadedCpu/SingleThreadedCpu.cpp
  class Solution (line 60) | class Solution {
    method print (line 63) | void print(T q) {
    method getOrder (line 72) | vector<int> getOrder(vector<vector<int>>& tasks) {

FILE: algorithms/cpp/slidingWindowMaximum/SlidingWindowMaximum.cpp
  function maxSlidingWindow02 (line 45) | vector<int> maxSlidingWindow02(vector<int>& nums, int k) {
  function maxSlidingWindow01 (line 67) | vector<int> maxSlidingWindow01(vector<int>& nums, int k) {
  function maxSlidingWindow (line 92) | vector<int> maxSlidingWindow(vector<int>& nums, int k) {
  function printVector (line 97) | void printVector( vector<int>& v ) {
  function main (line 105) | int main(int argc, char** argv)

FILE: algorithms/cpp/smallestStringStartingFromLeaf/SmallestStringStartingFromLeaf.cpp
  class Solution (line 45) | class Solution {
    method string (line 47) | string smallestFromLeaf(TreeNode* root) {
    method smallestFromLeafHelper (line 53) | void smallestFromLeafHelper(TreeNode* root, string str, string& result) {

FILE: algorithms/cpp/sortArrayByParity/SortArrayByParity.II.cpp
  class Solution (line 28) | class Solution {
    method isEven (line 30) | bool isEven(int &x) {
    method sortArrayByParityII (line 33) | vector<int> sortArrayByParityII(vector<int>& A) {

FILE: algorithms/cpp/sortArrayByParity/SortArrayByParity.cpp
  class Solution (line 25) | class Solution {
    method isEven (line 27) | bool isEven(int& x) {
    method sortArrayByParity (line 30) | vector<int> sortArrayByParity(vector<int>& A) {

FILE: algorithms/cpp/sortColors/sortColors.cpp
  function swap (line 28) | void swap(int*a, int*b)
  function sortColors (line 35) | void sortColors(int a[], int n) {
  function printArray (line 51) | void printArray(int a[], int n) {
  function main (line 58) | int main(int argc, char** argv)

FILE: algorithms/cpp/sortList/sortList.cpp
  type ListNode (line 16) | struct ListNode {
    method ListNode (line 19) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 24) | ListNode *sortList(ListNode *head) {
    method ListNode (line 19) | ListNode(int x) : val(x), next(NULL) {}
  function ListNode (line 41) | ListNode *mergeTwoLists(ListNode* head1, ListNode* head2){
    method ListNode (line 19) | ListNode(int x) : val(x), next(NULL) {}
  function printList (line 63) | void printList(ListNode* h)
  function ListNode (line 72) | ListNode* createList(int a[], int n)
    method ListNode (line 19) | ListNode(int x) : val(x), next(NULL) {}
  function main (line 87) | int main(int argc, char** argv)

FILE: algorithms/cpp/sortingTheSentence/SortingTheSentence.cpp
  class Solution (line 42) | class Solution {
    method string (line 44) | string sortSentence(string s) {

FILE: algorithms/cpp/spiralMatrix/spiralMatrix.II.cpp
  function generateMatrix (line 31) | vector<vector<int> > generateMatrix(int n) {
  function generateMatrix (line 35) | vector<vector<int> > generateMatrix(int n, int m) {
  function printArray (line 69) | void printArray(vector<int> v)
  function printMatrix (line 78) | void printMatrix(vector< vector<int> > &vv)
  function main (line 87) | int main(int argc, char** argv)

FILE: algorithms/cpp/spiralMatrix/spiralMatrix.cpp
  function spiralOrder (line 29) | vector<int> spiralOrder(vector<vector<int> > &matrix) {
  function printArray (line 59) | void printArray(vector<int> v)
  function printMatrix (line 68) | void printMatrix(vector< vector<int> > &vv)
  function createMatrix (line 76) | vector< vector<int> > createMatrix(int n, int m)
  function main (line 90) | int main(int argc, char** argv)

FILE: algorithms/cpp/splitArrayLargestSum/SplitArrayLargestSum.cpp
  class Solution (line 29) | class Solution {
    method splitArray (line 36) | int splitArray(vector<int>& nums, int m) {
    method hasSmallerSum (line 57) | bool hasSmallerSum(vector<int>& nums, int m, int sum) {

FILE: algorithms/cpp/splittingAStringIntoDescendingConsecutiveValues/SplittingAStringIntoDescendingConsecutiveValues.cpp
  class Solution (line 56) | class Solution {
    method getNum (line 60) | bool getNum(string& s, long target) {
    method firstNum (line 72) | long firstNum(string& s, int len) {
    method splitString (line 81) | bool splitString(string s) {

FILE: algorithms/cpp/sqrt/sqrt.cpp
  function sqrt (line 18) | int sqrt(int x) {
  function sqrt_nt (line 41) | int sqrt_nt(int x) {
  function main (line 54) | int main(int argc, char**argv)

FILE: algorithms/cpp/squaresOfASortedArray/SquaresOfASortedArray.cpp
  class Solution (line 28) | class Solution {
    method sortedSquares (line 30) | vector<int> sortedSquares(vector<int>& A) {

FILE: algorithms/cpp/strStr/strStr.cpp
  function main (line 99) | int main(int argc, char** argv)

FILE: algorithms/cpp/stringToIntegerAtoi/stringToIntegerAtoi.cpp
  function atoi (line 44) | int atoi(const char *str) {
  function main (line 78) | int main()

FILE: algorithms/cpp/stringWithoutAAAOrBBB/StringWithoutAAAOrBBB.cpp
  class Solution (line 31) | class Solution {
    method string (line 33) | string strWithout3a3b(int A, int B) {

FILE: algorithms/cpp/subsets/subsets.II.cpp
  function subsets (line 42) | vector<vector<int> > subsets(vector<int> &S) {
  function combine (line 53) | vector<vector<int> > combine(vector<int> &v, int k) {
  function getCombination (line 60) | void getCombination(vector<int> &v, int n, int k, vector<int>& solution,...
  function printResult (line 78) | void printResult(vector<vector<int> >& result)
  function printArray (line 89) | void printArray(vector<int>& v){
  function main (line 97) | int main(int argc, char** argv)

FILE: algorithms/cpp/subsets/subsets.cpp
  function subsets (line 44) | vector<vector<int> > subsets(vector<int> &S) {
  function combine (line 54) | vector<vector<int> > combine(vector<int>& v, int k) {
  function combine1 (line 63) | vector<vector<int> > combine1(vector<int> &v, int k) {
  function getCombination (line 70) | void getCombination(vector<int> &v, int n, int k, vector<int>& solution,...
  function combine2 (line 85) | vector<vector<int> > combine2(vector<int> &v, int k) {
  function printResult (line 134) | void printResult(vector<vector<int> >& result)
  function printArray (line 145) | void printArray(vector<int>& v){
  function main (line 153) | int main(int argc, char** argv)

FILE: algorithms/cpp/substringWithConcatenationOfAllWords/substringWithConcatenationOfAllWords.cpp
  function findSubstring (line 27) | vector<int> findSubstring(string S, vector<string> &L) {
  function main (line 93) | int main(int argc, char**argv)

FILE: algorithms/cpp/substringsOfSizeThreeWithDistinctCharacters/SubstringsOfSizeThreeWithDistinctCharacters.cpp
  class Solution (line 36) | class Solution {
    method countGoodSubstrings (line 38) | int countGoodSubstrings(string s) {

FILE: algorithms/cpp/sudokuSolver/sudokuSolver.cpp
  function initSudokuMask (line 33) | bool initSudokuMask(vector< vector<char> > &board){
  function recursiveSudoKu (line 60) | bool recursiveSudoKu(vector< vector<char> > &board, int row, int col){
  function solveSudoku (line 95) | void solveSudoku(vector<vector<char> > &board) {
  function main (line 103) | int main(int argc, char**argv) {

FILE: algorithms/cpp/sumOfBeautyOfAllSubstrings/SumOfBeautyOfAllSubstrings.cpp
  class Solution (line 32) | class Solution {
    method beauty (line 34) | int beauty(string& s, int start, int end) {
    method beautySum (line 48) | int beautySum(string s) {
    method beautySum01 (line 53) | int beautySum01(string& s) {
    method beautySum02 (line 64) | int beautySum02(string& s) {

FILE: algorithms/cpp/sumOfDigitsInBaseK/SumOfDigitsInBaseK.cpp
  class Solution (line 31) | class Solution {
    method sumBase (line 33) | int sumBase(int n, int k) {

FILE: algorithms/cpp/sumOfDigitsOfStringAfterConvert/SumOfDigitsOfStringAfterConvert.cpp
  class Solution (line 53) | class Solution {
    method sumChar (line 55) | int sumChar(char c) {
    method sumInt (line 59) | int sumInt(int x) {
    method getLucky (line 67) | int getLucky(string s, int k) {

FILE: algorithms/cpp/sumOfEvenNumbersAfterQueries/SumOfEvenNumbersAfterQueries.cpp
  class Solution (line 38) | class Solution {
    method sumEvenAfterQueries (line 40) | vector<int> sumEvenAfterQueries(vector<int>& A, vector<vector<int>>& q...

FILE: algorithms/cpp/sumOfFlooredPairs/SumOfFlooredPairs.cpp
  class Solution (line 35) | class Solution {
    method sumOfFlooredPairs (line 37) | int sumOfFlooredPairs(vector<int>& nums) {

FILE: algorithms/cpp/sumOfLeftLeaves/SumOfLeftLeaves.cpp
  class Solution (line 30) | class Solution {
    method sumOfLeftLeaves_recursion_v1 (line 34) | void sumOfLeftLeaves_recursion_v1(TreeNode* root, int& result) {
    method sumOfLeftLeaves_recursion_v2 (line 47) | int sumOfLeftLeaves_recursion_v2(TreeNode* root) {
    method sumOfLeftLeaves (line 60) | int sumOfLeftLeaves(TreeNode* root) {

FILE: algorithms/cpp/sumOfTwoIntegers/SumOfTwoIntegers.cpp
  class Solution (line 18) | class Solution {
    method getSum (line 20) | int getSum(int x, int y) {

FILE: algorithms/cpp/sumOfUniqueElements/SumOfUniqueElements.cpp
  class Solution (line 36) | class Solution {
    method sumOfUnique (line 38) | int sumOfUnique(vector<int>& nums) {
    method sumOfUnique_general (line 43) | int sumOfUnique_general(vector<int>& nums) {
    method sumOfUnique_special (line 62) | int sumOfUnique_special(vector<int>& nums) {

FILE: algorithms/cpp/sumRootToLeafNumber/sumRootToLeafNumber.cpp
  class Solution (line 35) | class Solution {
    method sumNumbers (line 37) | int sumNumbers(TreeNode *root) {

FILE: algorithms/cpp/summaryRanges/SummaryRanges.cpp
  class Solution (line 16) | class Solution {
    method string (line 18) | string makeRange(int start, int end) {
    method summaryRanges (line 28) | vector<string> summaryRanges(vector<int>& nums) {

FILE: algorithms/cpp/superUglyNumber/SuperUglyNumber.cpp
  class Solution (line 45) | class Solution {
    method nthSuperUglyNumber (line 48) | int nthSuperUglyNumber(int n, vector<int>& primes) {

FILE: algorithms/cpp/surroundedRegions/surroundedRegions.cpp
  function markOpen (line 38) | void markOpen(vector< vector<char> > &board, int row, int col, int r, in...
  function solve_recursively (line 47) | void solve_recursively(vector< vector<char> > &board) {
  type position (line 87) | struct position{
    method set (line 89) | void set(int r, int c) { row = r; col = c; }
    method position (line 90) | position(int r, int c): row(r), col(c) {}
  function solve_non_recursively (line 93) | void solve_non_recursively(vector< vector<char> > &board) {
  class UnionFind (line 173) | class UnionFind {
    method UnionFind (line 178) | UnionFind(int n) {
    method count (line 193) | int count() { return count_; }
    method find (line 195) | int find(int p) {
    method connected (line 203) | bool connected(int p, int q) {
    method connect (line 207) | void connect(int p, int q) {
  class Solution (line 221) | class Solution {
    method solve (line 223) | void solve(vector<vector<char> >& board) {
  function solve (line 254) | void solve(vector< vector<char> > &board) {
  function construct (line 263) | void construct(vector< vector<char> > &board, int row, int col) {
  function print (line 277) | void print(vector< vector<char> > &board) {
  function main (line 287) | int main(int argc, char** argv )

FILE: algorithms/cpp/swapNodesInPairs/swapNodesInPairs.cpp
  class Solution (line 26) | class Solution {
    method Solution (line 28) | Solution(){
    method ListNode (line 36) | ListNode *swapPairs(ListNode *head) {
    method ListNode (line 43) | ListNode *swapPairs1(ListNode *head) {
    method ListNode (line 52) | ListNode *swapPairs2(ListNode *head) {
    method ListNode (line 75) | ListNode* swapPairs3(ListNode* head) {

FILE: algorithms/cpp/symmetricTree/symmetricTree.cpp
  class Solution (line 59) | class Solution {
    method Solution (line 61) | Solution(){
    method isSymmetric (line 65) | bool isSymmetric(TreeNode *root) {
    method isSymmetric (line 71) | bool isSymmetric(TreeNode *p, TreeNode *q){
    method isSymmetric1 (line 78) | bool isSymmetric1(TreeNode *p, TreeNode *q){
    method isSymmetric2 (line 87) | bool isSymmetric2(TreeNode *p, TreeNode *q){

FILE: algorithms/cpp/targetSum/targetSum.cpp
  class Solution (line 25) | class Solution {
    method findTargetSumWays (line 27) | int findTargetSumWays(vector<int>& nums, int S) {

FILE: algorithms/cpp/textJustification/textJustification.cpp
  function fullJustify (line 50) | vector<string> fullJustify(vector<string> &words, int L) {
  function printVector (line 110) | void printVector(vector<string> &words, bool newline=false) {
  function test (line 118) | void test(const char* A[], int len, int L) {
  function main (line 131) | int main(int argc, char** argv)

FILE: algorithms/cpp/theSkylineProblem/TheSkylineProblem.cpp
  class Solution (line 92) | class Solution {
    method getSkyline (line 95) | vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) {

FILE: algorithms/cpp/thirdMaximumNumber/ThirdMaximumNumber.cpp
  class Solution (line 38) | class Solution {
    method nMax (line 40) | int nMax(vector<int>& nums, int n) {
    method thirdMax (line 48) | int thirdMax(vector<int>& nums) {

FILE: algorithms/cpp/thousandSeparator/ThousandSeparator.cpp
  class Solution (line 34) | class Solution {
    method string (line 36) | string thousandSeparator(int n) {

FILE: algorithms/cpp/threeConsecutiveOdds/ThreeConsecutiveOdds.cpp
  class Solution (line 28) | class Solution {
    method threeConsecutiveOdds (line 31) | bool threeConsecutiveOdds(vector<int>& arr) {

FILE: algorithms/cpp/timeBasedKeyValueStore/TimeBasedKeyValueStore.cpp
  class TimeMap (line 51) | class TimeMap {
    method TimeMap (line 57) | TimeMap() {
    method set (line 61) | void set(string key, string value, int timestamp) {
    method string (line 66) | string get(string key, int timestamp) {

FILE: algorithms/cpp/timeNeededToInformAllEmployees/TimeNeededToInformAllEmployees.cpp
  class Solution (line 37) | class Solution {
    method dfs (line 40) | long long int dfs(vector<vector<int>>& adj, vector<int>& informTime, i...
    method numOfMinutes (line 49) | int numOfMinutes(int n, int headID, vector<int>& manager, vector<int>&...

FILE: algorithms/cpp/topKFrequentElements/topKFrequentElements.cpp
  class Solution (line 19) | class Solution {
    type element (line 21) | struct element//structure consisting of every distinct number in the v...
    method topKFrequent (line 34) | vector<int> topKFrequent(vector<int>& nums, int k) {

FILE: algorithms/cpp/totalHammingDistance/totalHammingDistance.cpp
  class Solution (line 39) | class Solution {
    method totalHammingDistance (line 41) | int totalHammingDistance(vector<int>& nums) {

FILE: algorithms/cpp/trappingRainWater/trappingRainWater.cpp
  function trap (line 41) | int trap(int a[], int n) {
  function main (line 76) | int main()

FILE: algorithms/cpp/treeOfCoprimes/TreeOfCoprimes.cpp
  class Solution (line 54) | class Solution {
    method gcd (line 58) | int gcd(int a, int b) {
    method print (line 65) | void print(vector<int>& v, int len, vector<int>& nums){
    method getCoprimes (line 74) | vector<int> getCoprimes(vector<int>& nums, vector<vector<int>>& edges) {
    method getCoprimesDFS (line 95) | void getCoprimesDFS(int parent, int root,

FILE: algorithms/cpp/triangle/triangle.cpp
  class Solution (line 31) | class Solution {
    method minimumTotal (line 34) | int minimumTotal(vector<vector<int> > &triangle) {
    method min (line 79) | inline int min(int x, int y, int z){
  function main (line 86) | int main()

FILE: algorithms/cpp/triplesWithBitwiseANDEqualToZero/TriplesWithBitwiseAndEqualToZero.cpp
  class Solution (line 39) | class Solution {
    method countTriplets (line 41) | int countTriplets(vector<int>& A) {

FILE: algorithms/cpp/truncateSentence/TruncateSentence.cpp
  class Solution (line 47) | class Solution {
    method isAlpha (line 49) | bool isAlpha(const char& ch) {
    method string (line 53) | string truncateSentence(string s, int k) {

FILE: algorithms/cpp/tupleWithSameProduct/TupleWithSameProduct.cpp
  class Solution (line 45) | class Solution {
    method tupleSameProduct (line 47) | int tupleSameProduct(vector<int>& nums) {

FILE: algorithms/cpp/twoArraysEqualByReversingSubArrays/MakeTwoArraysEqualByReversingSubArrays.cpp
  class Solution (line 53) | class Solution {
    method canBeEqual (line 56) | bool canBeEqual(vector<int>& target, vector<int>& arr) {

FILE: algorithms/cpp/twoCityScheduling/TwoCityScheduling.cpp
  class Solution (line 33) | class Solution {
    method diff (line 35) | static int diff(vector<int>& x) {
    method cmpfunc (line 38) | static bool cmpfunc(vector<int>& lhs, vector<int>& rhs) {
    method twoCitySchedCost (line 46) | int twoCitySchedCost(vector<vector<int>>& costs) {

FILE: algorithms/cpp/twoSum/twoSum.II.cpp
  class Solution (line 23) | class Solution {
    method twoSum (line 25) | vector<int> twoSum(vector<int> &numbers, int target) {

FILE: algorithms/cpp/twoSum/twoSum.III.cpp
  class TwoSum (line 20) | class TwoSum {
    method add (line 26) | void add(int number) {
    method find (line 31) | bool find(int value) {

FILE: algorithms/cpp/twoSum/twoSum.cpp
  class Solution (line 21) | class Solution {
    method twoSum (line 52) | vector<int> twoSum(vector<int> &numbers, int target) {
    method twoSum (line 71) | vector<int> twoSum(vector<int>& nums, int target) {

FILE: algorithms/cpp/uglyNumber/UglyNumber.II.cpp
  class Solution (line 30) | class Solution {
    method min (line 33) | int min(int a, int b) {
    method min (line 37) | int min(int a, int b, int c) {
    method nthUglyNumber01 (line 69) | int nthUglyNumber01(int n) {
    method nthUglyNumber02 (line 86) | int nthUglyNumber02(int n) {
    method nthUglyNumber (line 103) | int nthUglyNumber(int n) {

FILE: algorithms/cpp/uglyNumber/UglyNumber.cpp
  class Solution (line 19) | class Solution {
    method isUgly (line 22) | bool isUgly(int num) {

FILE: algorithms/cpp/uniqueBinarySearchTrees/uniqueBinarySearchTrees.II.cpp
  type TreeNode (line 44) | struct TreeNode {
    method TreeNode (line 48) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function generateTrees (line 53) | vector<TreeNode*> generateTrees(int n) {
  function generateTrees (line 60) | vector<TreeNode*> generateTrees(int low, int high){
  function printTree (line 86) | void printTree(TreeNode *root){
  function main (line 98) | int main(int argc, char** argv)

FILE: algorithms/cpp/uniqueBinarySearchTrees/uniqueBinarySearchTrees.cpp
  function numTrees (line 26) | int numTrees(int n) {
  function numTrees1 (line 30) | int numTrees1(int n) {
  function numTrees2 (line 48) | int numTrees2(int n) {
  function main (line 63) | int main(int argc, char** argv)

FILE: algorithms/cpp/uniqueEmailAddresses/UniqueEmailAddresses.cpp
  class Solution (line 45) | class Solution {
    method numUniqueEmails (line 47) | int numUniqueEmails(vector<string>& emails) {

FILE: algorithms/cpp/uniqueMorseCodeWords/UniqueMorseCodeWords.cpp
  class Solution (line 49) | class Solution {
    method uniqueMorseRepresentations (line 51) | int uniqueMorseRepresentations(vector<string>& words) {

FILE: algorithms/cpp/uniqueNumberOfOccurrences/Unique-Number-of-Occurrences.cpp
  class Solution (line 30) | class Solution {
    method uniqueOccurrences (line 32) | bool uniqueOccurrences(vector<int>& arr) {

FILE: algorithms/cpp/uniquePaths/UniquePaths.III.cpp
  class Solution (line 48) | class Solution {
    method uniquePathsIII (line 50) | int uniquePathsIII(vector<vector<int>>& grid) {
    method findStartPoint (line 59) | bool findStartPoint(vector<vector<int>> &grid, int& x, int& y) {
    method check (line 70) | bool check(vector<vector<int>> &grid ) {
    method uniquePathsHelper (line 80) | void uniquePathsHelper(vector<vector<int>> &grid, int x, int y, int& p...

FILE: algorithms/cpp/uniquePaths/uniquePaths.II.cpp
  function uniquePathsWithObstacles (line 33) | int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
  function uniquePathsWithObstacles (line 58) | int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {

FILE: algorithms/cpp/uniquePaths/uniquePaths.cpp
  function printMatrix (line 40) | void printMatrix(int*a, int m, int n)
  function uniquePaths (line 61) | int uniquePaths(int m, int n) {
  function uniquePaths (line 85) | int uniquePaths(int m, int n) {
  function main (line 97) | int main(int argc, char** argv)

FILE: algorithms/cpp/validNumber/validNumber.cpp
  function isdigit (line 26) | bool isdigit(const char c){
  function isspace (line 29) | bool isspace(const char c) {
  function isNumber (line 33) | bool isNumber(const char *s) {
  function main (line 87) | int main(int argc, char** argv)

FILE: algorithms/cpp/validPalindrome/validPalindrome.cpp
  class Solution (line 21) | class Solution {
    method isPalindrome (line 23) | bool isPalindrome(string s) {
    method string (line 33) | string removeNoise(string& s){

FILE: algorithms/cpp/validParentheses/validParentheses.cpp
  function isValid (line 21) | bool isValid(string s) {
  function main (line 41) | int main(int argc, char**argv)

FILE: algorithms/cpp/validPerfectSquare/ValidPerfectSquare.cpp
  class Solution (line 31) | class Solution {
    method isPerfectSquare1 (line 34) | bool isPerfectSquare1(int num) {
    method isPerfectSquare2 (line 52) | bool isPerfectSquare2(int num) {
    method isPerfectSquare (line 61) | bool isPerfectSquare(int num) {

FILE: algorithms/cpp/validSudoku/validSudoku.cpp
  class Solution (line 20) | class Solution {
    method isValidSudoku (line 22) | bool isValidSudoku(vector<vector<char> > &board) {

FILE: algorithms/cpp/validateBinarySearchTree/validateBinarySearchTree.cpp
  type TreeNode (line 42) | struct TreeNode {
    method TreeNode (line 46) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function isValidBST (line 49) | bool isValidBST(TreeNode *root) {
  function TreeNode (line 78) | TreeNode* createTree(int a[], int n)
    method TreeNode (line 46) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function main (line 104) | int main()

FILE: algorithms/cpp/verifyPreorderSerializationOfABinaryTree/VerifyPreorderSerializationOfABinaryTree.cpp
  class Solution (line 46) | class Solution {
    method isValidSerialization (line 65) | bool isValidSerialization(string preorder) {
    method split (line 78) | void split(const string &s, char delim, vector<string> &elems) {

FILE: algorithms/cpp/verticalOrderTraversalOfABinaryTree/VerticalOrderTraversalOfABinaryTree.cpp
  class Item (line 86) | class Item {
    method Item (line 88) | Item(int _x, int _y, int _val):x(_x), y(_y),val(_val) {}
  class ItemCmp (line 93) | class ItemCmp {
  function getValue (line 100) | int getValue(const Item& i) {
  class Solution (line 104) | class Solution {
    method verticalTraversal (line 106) | vector<vector<int>> verticalTraversal(TreeNode* root) {
    method verticalTraversalHelper (line 120) | void verticalTraversalHelper(TreeNode* root, int x, int y,

FILE: algorithms/cpp/videoStitching/VideoStitching.cpp
  class Solution (line 58) | class Solution {
    method videoStitching (line 60) | int videoStitching(vector<vector<int>>& clips, int T) {
    method print (line 105) | void print(vector<vector<int>>& clips) {
    method print (line 112) | void print(vector<int>& v) {

FILE: algorithms/cpp/waysToSplitArrayIntoThreeSubarrays/WaysToSplitArrayIntoThreeSubarrays.cpp
  class Solution (line 46) | class Solution {
    method waysToSplit (line 48) | int waysToSplit(vector<int>& nums) {
    method binary_search (line 60) | int binary_search(vector<int>& presum, int left, int i, bool searchLef...
    method waysToSplit_BS (line 85) | int waysToSplit_BS(vector<int>& presum) {
    method waysToSplit_TLE (line 102) | int waysToSplit_TLE(vector<int>& presum) {

FILE: algorithms/cpp/wiggleSort/WiggleSort.II.cpp
  class Solution (line 24) | class Solution {
    method wiggleSort01 (line 48) | void wiggleSort01(vector<int>& nums) {
    method wiggleSort02 (line 67) | void wiggleSort02(vector<int>& nums) {
    method wiggleSort (line 89) | void wiggleSort(vector<int>& nums) {

FILE: algorithms/cpp/wiggleSubsequence/wiggleSubsequence.cpp
  class Solution (line 56) | class Solution {
    method wiggleMaxLength (line 58) | int wiggleMaxLength(vector<int>& nums) {

FILE: algorithms/cpp/wildcardMatching/wildcardMatching.cpp
  function isMatch (line 34) | bool isMatch(const char *s, const char *p) {
  function main (line 67) | int main(int argc, char** argv)

FILE: algorithms/cpp/wordBreak/wordBreak.II.cpp
  function wordBreak (line 61) | vector<string> wordBreak(string s, set<string> &dict, map<string, vector...
  function wordBreak (line 90) | void wordBreak(string s, set<string> &dict, string str, vector<string>& ...
  function wordBreak_dp (line 143) | vector<string> wordBreak_dp(string s, set<string> &dict) {
  function wordBreak (line 167) | vector<string> wordBreak(string s, set<string> &dict) {
  function printVector (line 197) | void printVector(vector<string>& v)
  function main (line 204) | int main()

FILE: algorithms/cpp/wordBreak/wordBreak.cpp
  function wordBreak (line 24) | bool wordBreak(string s, set<string> &dict) {
  function main (line 51) | int main()

FILE: algorithms/cpp/wordLadder/wordLadder.II.cpp
  function generatePath (line 127) | void generatePath( string start, string end,
  function findLadders (line 147) | vector< vector<string> >
  function printLadders (line 170) | void printLadders(vector< vector<string> > &ladders){
  function main (line 180) | int main(int argc, char** argv)

FILE: algorithms/cpp/wordLadder/wordLadder.cpp
  class Solution (line 76) | class Solution {
    method ladderLength (line 78) | int ladderLength(string start, string end, unordered_set<string> &dict) {

FILE: algorithms/cpp/wordPattern/WordPattern.cpp
  class Solution (line 27) | class Solution {
    method split (line 31) | vector<string> split(string str, char delimiter) {
    method wordPattern (line 45) | bool wordPattern(string pattern, string str) {

FILE: algorithms/cpp/wordSearch/wordSearch.II.cpp
  class TrieNode (line 41) | class TrieNode {
    method TrieNode (line 43) | TrieNode(string s):isWord(false), word(s) {
    method TrieNode (line 46) | TrieNode* & operator [] (char ch) {
    method TrieNode (line 49) | TrieNode* & operator [] (int idx) {
  class TrieTree (line 60) | class TrieTree {
    method TrieTree (line 62) | TrieTree():root(new TrieNode("")) { }
    method TrieNode (line 64) | TrieNode* getRoot() {
    method addWord (line 67) | void addWord(string& s){
    method freeTree (line 80) | void freeTree(TrieNode* node){
  class Solution (line 92) | class Solution {
    method findWords (line 94) | void findWords(vector<vector<char>>& board, TrieNode* root, int row, i...
    method findWords (line 125) | vector<string> findWords(vector<vector<char>>& board, vector<string>& ...

FILE: algorithms/cpp/wordSearch/wordSearch.cpp
  function exist (line 34) | bool exist(vector<vector<char> > &board, string& word, int idx, int row,...
  function exist (line 60) | bool exist(vector<vector<char> > &board, string word) {
  function buildBoard (line 77) | vector< vector<char> > buildBoard(char b[][5], int r, int c) {
  function main (line 88) | int main(int argc, char** argv)

FILE: algorithms/cpp/zigZagConversion/zigZagConversion.cpp
  function string (line 30) | string convert(string s, int nRows) {
  function main (line 52) | int main(int argc, char**argv){

FILE: algorithms/golang/twoSum/twoSum.go
  function twoSum (line 3) | func twoSum(nums []int, target int) []int {

FILE: algorithms/java/src/LargestNumberAfterMutatingSubstring/largestNumberAfterMutatingSubstring.java
  class Solution (line 49) | class Solution {
    method maximumNumber (line 50) | public String maximumNumber(String num, int[] change) {

FILE: algorithms/java/src/MaxSubArray/MaxSubarray.java
  class Solution (line 15) | class Solution {
    method maxSubArray (line 16) | public int maxSubArray(int[] nums) {

FILE: algorithms/java/src/RotateImage/rotateImage.java
  class Solution (line 27) | class Solution {
    method rotate (line 28) | public void rotate(int[][] matrix) {

FILE: algorithms/java/src/balancedBinaryTree/TreeNode.java
  class TreeNode (line 6) | public class TreeNode {
    method TreeNode (line 9) | public TreeNode(int val) {

FILE: algorithms/java/src/balancedBinaryTree/balancedBinaryTree.java
  class balancedBinaryTree (line 22) | public class balancedBinaryTree {
    method isBalanced (line 27) | public boolean isBalanced(TreeNode root) {
    class Result (line 33) | private class Result {
      method Result (line 36) | Result(boolean isBalanced, int height) {
    method helper (line 41) | private Result helper(TreeNode root, int depth) {

FILE: algorithms/java/src/balancedBinaryTree/balancedBinaryTreeTest.java
  class balancedBinaryTreeTest (line 11) | public class balancedBinaryTreeTest {
    method testIsBalanced (line 13) | @Test

FILE: algorithms/java/src/binarySearchTreeIterator/TreeNode.java
  class TreeNode (line 6) | public class TreeNode {
    method TreeNode (line 9) | public TreeNode(int val) {

FILE: algorithms/java/src/binarySearchTreeIterator/binarySearchTreeIterator.java
  class binarySearchTreeIterator (line 39) | public class binarySearchTreeIterator {
    method binarySearchTreeIterator (line 43) | public binarySearchTreeIterator(TreeNode root) {
    method hasNext (line 50) | public boolean hasNext() {
    method next (line 56) | public TreeNode next() {

FILE: algorithms/java/src/binarySearchTreeIterator/binarySearchTreeIteratorTest.java
  class binarySearchTreeIteratorTest (line 12) | public class binarySearchTreeIteratorTest {
    method testIterator (line 13) | @Test

FILE: algorithms/java/src/binaryTreeBFSTraversal/TreeNode.java
  class TreeNode (line 6) | public class TreeNode {
    method TreeNode (line 10) | TreeNode(int x) { val = x; }

FILE: algorithms/java/src/binaryTreeBFSTraversal/binaryTreeBFSTraversal.java
  class binaryTreeBFSTraversal (line 11) | public class binaryTreeBFSTraversal {
    method bfsTraversal (line 12) | public List<Integer> bfsTraversal(TreeNode root) {

FILE: algorithms/java/src/binaryTreeBFSTraversal/binaryTreeBFSTraversalTest.java
  class binaryTreeBFSTraversalTest (line 13) | public class binaryTreeBFSTraversalTest {
    method testPreorderTraversal (line 24) | @Test

FILE: algorithms/java/src/binaryTreeLevelOrderTraversal/TreeNode.java
  class TreeNode (line 6) | public class TreeNode {
    method TreeNode (line 10) | TreeNode(int x) { val = x; }

FILE: algorithms/java/src/binaryTreeLevelOrderTraversal/binaryTreeLevelOrderTraversal.java
  class binaryTreeLevelOrderTraversal (line 57) | public class binaryTreeLevelOrderTraversal {
    method levelOrder (line 62) | public List<List<Integer>> levelOrder(TreeNode root) {

FILE: algorithms/java/src/binaryTreeLevelOrderTraversal/binaryTreeLevelOrderTraversalTest.java
  class binaryTreeLevelOrderTraversalTest (line 14) | public class binaryTreeLevelOrderTraversalTest {
    method testLevelOrder (line 16) | @Test

FILE: algorithms/java/src/binaryTreeMaximumPathSum/TreeNode.java
  class TreeNode (line 6) | public class TreeNode {
    method TreeNode (line 10) | TreeNode(int x) { val = x; }

FILE: algorithms/java/src/binaryTreeMaximumPathSum/binaryTreeMaximumPathSum.java
  class binaryTreeMaximumPathSum (line 43) | public class binaryTreeMaximumPathSum {
    method maxPathSum (line 48) | public int maxPathSum(TreeNode root) {
    class Result (line 53) | private class Result {
      method Result (line 56) | Result(int sumToRoot, int sumToLeaf) {
    method helper (line 63) | private Result helper(TreeNode root) {

FILE: algorithms/java/src/binaryTreeMaximumPathSum/binaryTreeMaximumPathSumTest.java
  class binaryTreeMaximumPathSumTest (line 12) | public class binaryTreeMaximumPathSumTest {
    method testMaxPathSum (line 14) | @Test

FILE: algorithms/java/src/binaryTreePreorderTraversal/TreeNode.java
  class TreeNode (line 6) | public class TreeNode {
    method TreeNode (line 10) | TreeNode(int x) { val = x; }

FILE: algorithms/java/src/binaryTreePreorderTraversal/binaryTreePreorderTraversal.java
  class binaryTreePreorderTraversal (line 33) | public class binaryTreePreorderTraversal {
    method preorderTraversal (line 36) | public List<Integer> preorderTraversal(TreeNode root) {
    method traversal (line 43) | private void traversal(List<Integer> results, TreeNode root) {

FILE: algorithms/java/src/binaryTreePreorderTraversal/binaryTreePreorderTraversalTest.java
  class binaryTreePreorderTraversalTest (line 13) | public class binaryTreePreorderTraversalTest {
    method testPreorderTraversal (line 24) | @Test

FILE: algorithms/java/src/containerwithmostwater.java
  class Solution (line 10) | class Solution {
    method maxArea (line 11) | public int maxArea(int[] height) {

FILE: algorithms/java/src/countAndSay/CountAndSay.java
  class CountAndSay (line 34) | public class CountAndSay {
    method nextString (line 36) | public String nextString(String str) {
    method countAndSay (line 53) | public String countAndSay(int n) {

FILE: algorithms/java/src/countAndSay/TestCountAndSay.java
  class TestCountAndSay (line 8) | public class TestCountAndSay {
    method test (line 9) | @Test

FILE: algorithms/java/src/dynamicProgramming/climbStairs/climbStairs.java
  class climbStairs (line 17) | public class climbStairs {
    method climbStairs (line 22) | public int climbStairs(int n) {

FILE: algorithms/java/src/dynamicProgramming/climbStairs/climbStairsTest.java
  class climbStairsTest (line 10) | public class climbStairsTest {
    method testClimbStairs (line 12) | @Test

FILE: algorithms/java/src/dynamicProgramming/minimumPathSum/minimumPathSum.java
  class minimumPathSum (line 17) | public class minimumPathSum {
    method minPathSum (line 22) | public int minPathSum(int[][] grid) {

FILE: algorithms/java/src/dynamicProgramming/minimumPathSum/minimumPathSumTest.java
  class minimumPathSumTest (line 10) | public class minimumPathSumTest {
    method testMinPathSum (line 12) | @Test

FILE: algorithms/java/src/dynamicProgramming/triangle/triangle.java
  class triangle (line 35) | public class triangle {
    method minimumTotal1 (line 40) | public int minimumTotal1(List<List<Integer>> triangle) {
    method minimumTotal2 (line 69) | public int minimumTotal2(int[][] triangle) {

FILE: algorithms/java/src/dynamicProgramming/triangle/triangleTest.java
  class triangleTest (line 10) | public class triangleTest {
    method testMinimumTotal (line 12) | @Test

FILE: algorithms/java/src/dynamicProgramming/uniquePaths/uniquePaths.java
  class uniquePaths (line 38) | public class uniquePaths {
    method uniquePaths (line 43) | public int uniquePaths(int m, int n) {

FILE: algorithms/java/src/dynamicProgramming/uniquePaths/uniquePathsII.java
  class uniquePathsII (line 31) | public class uniquePathsII {
    method uniquePathsWithObstacles (line 36) | public int uniquePathsWithObstacles(int[][] obstacleGrid) {

FILE: algorithms/java/src/dynamicProgramming/uniquePaths/uniquePathsIITest.java
  class uniquePathsIITest (line 10) | public class uniquePathsIITest {
    method testUniquePathsWithObstacles (line 12) | @Test

FILE: algorithms/java/src/dynamicProgramming/uniquePaths/uniquePathsTest.java
  class uniquePathsTest (line 10) | public class uniquePathsTest {
    method testUniquePaths (line 12) | @Test

FILE: algorithms/java/src/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.java
  class findMinimumInRotatedSortedArray (line 20) | public class findMinimumInRotatedSortedArray {
    method findMin (line 21) | public int findMin(int[] num) {

FILE: algorithms/java/src/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArrayTest.java
  class findMinimumInRotatedSortedArrayTest (line 10) | public class findMinimumInRotatedSortedArrayTest {
    method testFindMin (line 12) | @Test

FILE: algorithms/java/src/findPeakElement/findPeakElement.java
  class findPeakElement (line 27) | public class findPeakElement {
    method findPeakElement (line 28) | public int findPeakElement(int[] nums) {

FILE: algorithms/java/src/findPeakElement/findPeakElementTest.java
  class findPeakElementTest (line 10) | public class findPeakElementTest {
    method testFindPeak (line 12) | @Test

FILE: algorithms/java/src/firstBadVersion/VersionControl.java
  class VersionControl (line 6) | public class VersionControl {
    method isBadVersion (line 8) | boolean isBadVersion(int version) {

FILE: algorithms/java/src/firstBadVersion/firstBadVersion.java
  class firstBadVersion (line 21) | public class firstBadVersion extends VersionControl {
    method firstBadVersion (line 22) | public int firstBadVersion(int n) {

FILE: algorithms/java/src/firstBadVersion/firstBadVersionTest.java
  class firstBadVersionTest (line 10) | public class firstBadVersionTest {
    method testFirstBadVersion (line 12) | @Test

FILE: algorithms/java/src/inorderSuccessorInBST/TreeNode.java
  class TreeNode (line 6) | public class TreeNode {
    method TreeNode (line 10) | TreeNode(int x) { val = x; }

FILE: algorithms/java/src/inorderSuccessorInBST/inorderSuccessorInBST.java
  class inorderSuccessorInBST (line 36) | public class inorderSuccessorInBST {
    method inorderSuccessor (line 37) | public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {

FILE: algorithms/java/src/inorderSuccessorInBST/inorderSuccessorInBSTTest.java
  class inorderSuccessorInBSTTest (line 12) | public class inorderSuccessorInBSTTest {
    method testInorderSuccessor (line 14) | @Test

FILE: algorithms/java/src/lengthOfLastWord/LengthOfLastWord.java
  class LengthOfLastWord (line 21) | public class LengthOfLastWord {
    method lengthOfLastWord (line 23) | public int lengthOfLastWord(String s) {

FILE: algorithms/java/src/lengthOfLastWord/TestLengthOfLastWord.java
  class TestLengthOfLastWord (line 9) | public class TestLengthOfLastWord {
    method test (line 10) | @Test

FILE: algorithms/java/src/lowestCommonAncestorOfABinaryTree/TreeNode.java
  class TreeNode (line 3) | public class TreeNode {
    method TreeNode (line 7) | TreeNode(int x) { val = x; }

FILE: algorithms/java/src/lowestCommonAncestorOfABinaryTree/lowestCommonAncestorOfABinaryTree.java
  class lowestCommonAncestorOfABinaryTree (line 47) | public class lowestCommonAncestorOfABinaryTree {
    method lowestCommonAncestor (line 53) | public TreeNode lowestCommonAncestor(TreeNode root, TreeNode A, TreeNo...

FILE: algorithms/java/src/lowestCommonAncestorOfABinaryTree/lowestCommonAncestorOfABinaryTreeTest.java
  class lowestCommonAncestorOfABinaryTreeTest (line 12) | public class lowestCommonAncestorOfABinaryTreeTest {
    method testLowestCommonAncestor (line 14) | @Test

FILE: algorithms/java/src/lruCache/LRUCache.java
  class LRUCache (line 15) | public class LRUCache {
    method LRUCache (line 20) | public LRUCache(int capacity) {
    method get (line 25) | public int get(int key) {
    method set (line 35) | public void set(int key, int value) {

FILE: algorithms/java/src/lruCache/LRUCacheTest.java
  class LRUCacheTest (line 6) | public class LRUCacheTest {
    method LRUCacheTest (line 10) | public LRUCacheTest() {
    method testCacheStartsEmpty (line 14) | @Test
    method testSetBelowCapacity (line 19) | @Test
    method testCapacityReachedOldestRemoved (line 29) | @Test
    method testGetRenewsEntry (line 39) | @Test

FILE: algorithms/java/src/maximumDepthOfBinaryTree/TreeNode.java
  class TreeNode (line 3) | public class TreeNode {
    method TreeNode (line 7) | TreeNode(int x) { val = x; }

FILE: algorithms/java/src/maximumDepthOfBinaryTree/maximumDepthOfBinaryTree.java
  class maximumDepthOfBinaryTree (line 27) | public class maximumDepthOfBinaryTree {
    method maxDepth (line 28) | public int maxDepth(TreeNode root) {
    method theDepth (line 35) | private int theDepth(TreeNode root) {

FILE: algorithms/java/src/maximumDepthOfBinaryTree/maximumDepthOfBinaryTreeTest.java
  class maximumDepthOfBinaryTreeTest (line 12) | public class maximumDepthOfBinaryTreeTest {
    method testMaxDepth (line 14) | @Test

FILE: algorithms/java/src/minStack/MinStack.java
  class MinStack (line 27) | public class MinStack {
    method MinStack (line 35) | public MinStack() {
    method push (line 39) | public void push(int x) {
    method pop (line 48) | public void pop() {
    method top (line 53) | public int top() {
    method getMin (line 57) | public int getMin() {

FILE: algorithms/java/src/minStack/TestMinStack.java
  class TestMinStack (line 9) | public class TestMinStack {
    method test (line 10) | @Test

FILE: algorithms/java/src/myQueue/MyQueue.java
  class MyQueue (line 63) | public class MyQueue {
    method MyQueue (line 67) | public MyQueue() {
    method push (line 73) | public void push(int x) {
    method pop (line 78) | public int pop() {
    method peek (line 89) | public int peek() {
    method empty (line 98) | public boolean empty() {

FILE: algorithms/java/src/myQueue/TestMyQueue.java
  class TestMyQueue (line 8) | public class TestMyQueue {
    method test (line 9) | @Test

FILE: algorithms/java/src/myStack/MyStack.java
  class MyStack (line 31) | public class MyStack {
    method MyStack (line 36) | public MyStack() {
    method push (line 43) | public void push(int x) {
    method pop (line 52) | public int pop() {
    method top (line 71) | public int top() {
    method empty (line 91) | public boolean empty() {

FILE: algorithms/java/src/myStack/TestMyStack.java
  class TestMyStack (line 8) | public class TestMyStack {
    method test (line 9) | @Test

FILE: algorithms/java/src/palindromeNumber/PalindromeNumber.java
  class PalindromeNumber (line 23) | public class PalindromeNumber {
    method isPalindrome (line 32) | public boolean isPalindrome(int x) {

FILE: algorithms/java/src/palindromeNumber/TestPalindromeNumber.java
  class TestPalindromeNumber (line 9) | public class TestPalindromeNumber {
    method test (line 10) | @Test

FILE: algorithms/java/src/powXn/PowXn.java
  class PowXn (line 22) | public class PowXn {
    method recursion (line 38) | public double recursion(double x, long n) {
    method myPow01 (line 51) | public double myPow01(double x, int n) {
    method myPow02 (line 65) | public double myPow02(double x, int n) {
    method bitFunction (line 86) | public double bitFunction(double x, long n) {

FILE: algorithms/java/src/powXn/TestPowXn.java
  class TestPowXn (line 9) | public class TestPowXn {
    method test (line 10) | @Test

FILE: algorithms/java/src/removeDuplicatesFromSortedArray/RemoveDuplicatesFromSortedArray.java
  class RemoveDuplicatesFromSortedArray (line 23) | public class RemoveDuplicatesFromSortedArray {
    method removeDuplicates (line 24) | public int removeDuplicates(int[] nums) {

FILE: algorithms/java/src/removeDuplicatesFromSortedArray/TestRemoveDuplicates.java
  class TestRemoveDuplicates (line 9) | public class TestRemoveDuplicates {
    method test (line 10) | @Test
    method assertSorted (line 22) | private void assertSorted(int[] array, int len) {

FILE: algorithms/java/src/reverseLinkedList/ListNode.java
  class ListNode (line 3) | public class ListNode {
    method ListNode (line 6) | public ListNode(int x) {
    method toString (line 9) | @Override
    method ListNode (line 13) | public ListNode(int val, ListNode next) {
    method listToString (line 21) | public static String listToString(ListNode head) {
    method arrayToList (line 37) | public static ListNode arrayToList(int[] array) {

FILE: algorithms/java/src/reverseLinkedList/ReverseLinkedList.java
  class ReverseLinkedList (line 15) | public class ReverseLinkedList {
    method reverseList (line 20) | public ListNode reverse

[
  {
    "path": ".gitignore",
    "chars": 34,
    "preview": ".idea\nalgorithms-java/out\n*.class\n"
  },
  {
    "path": "README.md",
    "chars": 103743,
    "preview": "\nLeetCode\n========\n\n### LeetCode Algorithm\n\n(Notes: \"🔒\" means you need to buy a book from Leetcode)\n\n\n| # | Title | Solu"
  },
  {
    "path": "algorithms/cpp/3Sum/3Sum.cpp",
    "chars": 5331,
    "preview": "// Source : https://oj.leetcode.com/problems/3sum/\n// Author : Hao Chen\n// Date   : 2014-07-22\n\n/***********************"
  },
  {
    "path": "algorithms/cpp/3SumClosest/3SumClosest.cpp",
    "chars": 3158,
    "preview": "// Source : https://oj.leetcode.com/problems/3sum-closest/\n// Author : Hao Chen\n// Date   : 2014-07-03\n\n/***************"
  },
  {
    "path": "algorithms/cpp/4Sum/4Sum.cpp",
    "chars": 3644,
    "preview": "// Source : https://oj.leetcode.com/problems/4sum/\n// Author : Hao Chen\n// Date   : 2014-07-03\n\n/***********************"
  },
  {
    "path": "algorithms/cpp/FindValidMatrixGivenRowAndColumnSums/FindValidMatrixGivenRowAndColumnSums.cpp",
    "chars": 2542,
    "preview": "// Source : https://leetcode.com/problems/find-valid-matrix-given-row-and-column-sums/\n// Author : Sudesh Chaudhary\n// D"
  },
  {
    "path": "algorithms/cpp/LRUCache/LRUCache.cpp",
    "chars": 6125,
    "preview": "// Source : https://oj.leetcode.com/problems/lru-cache/\n// Author : Hao Chen\n// Date   : 2014-10-12\n\n/******************"
  },
  {
    "path": "algorithms/cpp/NumberOfWaysToSplitString/NumberOfWaysToSplitString.cpp",
    "chars": 2302,
    "preview": "// Source : https://leetcode.com/problems/number-of-ways-to-split-a-string/\n// Author : Sudesh Chaudhary\n// Date   : 202"
  },
  {
    "path": "algorithms/cpp/UTF8Validation/UTF8Validation.cpp",
    "chars": 2932,
    "preview": "// Source : https://leetcode.com/problems/utf-8-validation/\n// Author : Hao Chen\n// Date   : 2016-09-08\n\n/**************"
  },
  {
    "path": "algorithms/cpp/accountsMerge/AccountsMerge.cpp",
    "chars": 6706,
    "preview": "// Source : https://leetcode.com/problems/accounts-merge/\n// Author : Hao Chen\n// Date   : 2019-03-29\n\n/****************"
  },
  {
    "path": "algorithms/cpp/addAndSearchWord/AddAndSearchWord.cpp",
    "chars": 4036,
    "preview": "// Source : https://leetcode.com/problems/add-and-search-word-data-structure-design/\n// Author : Hao Chen\n// Date   : 20"
  },
  {
    "path": "algorithms/cpp/addBinary/addBinary.cpp",
    "chars": 1207,
    "preview": "// Source : https://oj.leetcode.com/problems/add-binary/\n// Author : Hao Chen\n// Date   : 2014-07-05\n\n/*****************"
  },
  {
    "path": "algorithms/cpp/addDigits/addDigits.cpp",
    "chars": 2642,
    "preview": "// Source : https://leetcode.com/problems/add-digits/\n// Author : Timothy Lim, Hao Chen\n// Date   : 2015-10-1\n\n/********"
  },
  {
    "path": "algorithms/cpp/addStrings/AddStrings.cpp",
    "chars": 1497,
    "preview": "// Source : https://leetcode.com/problems/add-strings/\n// Author : Hao Chen\n// Date   : 2016-11-12\n\n/*******************"
  },
  {
    "path": "algorithms/cpp/addToArrayFormOfInteger/AddToArrayFormOfInteger.cpp",
    "chars": 1590,
    "preview": "// Source : https://leetcode.com/problems/add-to-array-form-of-integer/\n// Author : Hao Chen\n// Date   : 2019-03-25\n\n/**"
  },
  {
    "path": "algorithms/cpp/addTwoNumbers/addTwoNumbers.cpp",
    "chars": 1575,
    "preview": "// Source : https://oj.leetcode.com/problems/add-two-numbers/\n// Author : Hao Chen\n// Date   : 2014-06-18\n\n/************"
  },
  {
    "path": "algorithms/cpp/additiveNumber/AdditiveNumber.cpp",
    "chars": 2952,
    "preview": "// Source : https://leetcode.com/problems/additive-number/\n// Author : Hao Chen\n// Date   : 2015-11-22\n\n/***************"
  },
  {
    "path": "algorithms/cpp/anagrams/GroupAnagrams.cpp",
    "chars": 2888,
    "preview": "// Source : https://oj.leetcode.com/problems/anagrams/\n// Author : Hao Chen\n// Date   : 2014-07-18\n\n/*******************"
  },
  {
    "path": "algorithms/cpp/anagrams/ValidAnagram.cpp",
    "chars": 1567,
    "preview": "// Source : https://leetcode.com/problems/valid-anagram/\n// Author : Hao Chen\n// Date   : 2015-08-16\n\n/*****************"
  },
  {
    "path": "algorithms/cpp/arithmeticSlices/ArithmeticSlices.cpp",
    "chars": 2444,
    "preview": "// Source : https://leetcode.com/problems/arithmetic-slices/\n// Author : Hao Chen\n// Date   : 2016-11-13\n\n/*************"
  },
  {
    "path": "algorithms/cpp/backspaceStringCompare/BackspaceStringCompare.cpp",
    "chars": 1648,
    "preview": "// Source : https://leetcode.com/problems/backspace-string-compare/description/\n// Author : Hao Chen\n// Date   : 2018-06"
  },
  {
    "path": "algorithms/cpp/balancedBinaryTree/balancedBinaryTree.cpp",
    "chars": 2008,
    "preview": "// Source : https://oj.leetcode.com/problems/balanced-binary-tree/\n// Author : Hao Chen\n// Date   : 2014-06-28\n\n/*******"
  },
  {
    "path": "algorithms/cpp/basicCalculator/BasicCalculator.II.cpp",
    "chars": 2964,
    "preview": "// Source : https://leetcode.com/problems/basic-calculator-ii/\n// Author : Hao Chen\n// Date   : 2015-06-24\n\n/***********"
  },
  {
    "path": "algorithms/cpp/basicCalculator/BasicCalculator.cpp",
    "chars": 8557,
    "preview": "// Source : https://leetcode.com/problems/basic-calculator/\n// Author : Hao Chen\n// Date   : 2015-06-12\n\n/**************"
  },
  {
    "path": "algorithms/cpp/bestTimeToBuyAndSellStock/BestTimeToBuyAndSellStockWithCooldown.cpp",
    "chars": 2354,
    "preview": "// Source : https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/\n// Author : Hao Chen\n// Date   "
  },
  {
    "path": "algorithms/cpp/bestTimeToBuyAndSellStock/BestTimeToBuyAndSellStockWithTransactionFee.cpp",
    "chars": 7900,
    "preview": "// Source : https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee\n// Author : Hao Chen\n// D"
  },
  {
    "path": "algorithms/cpp/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.II.cpp",
    "chars": 2674,
    "preview": "// Source : https://oj.leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/\n// Author : Hao Chen\n// Date   : 2014-0"
  },
  {
    "path": "algorithms/cpp/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.III.cpp",
    "chars": 2846,
    "preview": "// Source : https://oj.leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/\n// Author : Hao Chen\n// Date   : 2014-"
  },
  {
    "path": "algorithms/cpp/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.IV.cpp",
    "chars": 5299,
    "preview": "// Source : https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/\n// Author : Hao Chen\n// Date   : 2015-03-3"
  },
  {
    "path": "algorithms/cpp/bestTimeToBuyAndSellStock/bestTimeToBuyAndSellStock.cpp",
    "chars": 2482,
    "preview": "// Source : https://oj.leetcode.com/problems/best-time-to-buy-and-sell-stock/\n// Author : Hao Chen\n// Date   : 2014-06-1"
  },
  {
    "path": "algorithms/cpp/binarySearchTreeIterator/binarySearchTreeIterator.cpp",
    "chars": 1594,
    "preview": "// Source : https://oj.leetcode.com/problems/binary-search-tree-iterator/\n// Author : Hao Chen\n// Date   : 2014-12-31\n\n/"
  },
  {
    "path": "algorithms/cpp/binaryTreeInorderTraversal/binaryTreeInorderTraversal.cpp",
    "chars": 1757,
    "preview": "// Source : https://oj.leetcode.com/problems/binary-tree-inorder-traversal/\n// Author : Hao Chen\n// Date   : 2014-06-27\n"
  },
  {
    "path": "algorithms/cpp/binaryTreeLevelOrderTraversal/binaryTreeLevelOrderTraversal.II.cpp",
    "chars": 2405,
    "preview": "// Source : https://oj.leetcode.com/problems/binary-tree-level-order-traversal-ii/\n// Author : Hao Chen\n// Date   : 2014"
  },
  {
    "path": "algorithms/cpp/binaryTreeLevelOrderTraversal/binaryTreeLevelOrderTraversal.cpp",
    "chars": 6075,
    "preview": "// Source : https://oj.leetcode.com/problems/binary-tree-level-order-traversal/\n// Author : Hao Chen\n// Date   : 2014-07"
  },
  {
    "path": "algorithms/cpp/binaryTreeMaximumPathSum/binaryTreeMaximumPathSum.cpp",
    "chars": 1804,
    "preview": "// Source : https://oj.leetcode.com/problems/binary-tree-maximum-path-sum/\n// Author : Hao Chen\n// Date   : 2014-10-10\n\n"
  },
  {
    "path": "algorithms/cpp/binaryTreePaths/binaryTreePaths.cpp",
    "chars": 2600,
    "preview": "// Source : https://leetcode.com/problems/binary-tree-paths/\n// Author : Calinescu Valentin, Hao Chen\n// Date   : 2015-1"
  },
  {
    "path": "algorithms/cpp/binaryTreePostorderTraversal/binaryTreePostorderTraversal.cpp",
    "chars": 3829,
    "preview": "// Source : https://oj.leetcode.com/problems/binary-tree-postorder-traversal/\n// Author : Hao Chen\n// Date   : 2014-07-2"
  },
  {
    "path": "algorithms/cpp/binaryTreePreorderTraversal/binaryTreePreorderTraversal.cpp",
    "chars": 3173,
    "preview": "// Source : https://oj.leetcode.com/problems/binary-tree-preorder-traversal/\n// Author : Hao Chen\n// Date   : 2014-07-21"
  },
  {
    "path": "algorithms/cpp/binaryTreeRightSideView/binaryTreeRightSideView.cpp",
    "chars": 2254,
    "preview": "// Source : https://leetcode.com/problems/binary-tree-right-side-view/\n// Author : Hao Chen\n// Date   : 2015-04-07\n\n/***"
  },
  {
    "path": "algorithms/cpp/binaryTreeUpsideDown/binaryTreeUpsideDown.cpp",
    "chars": 1873,
    "preview": "// Source : https://oj.leetcode.com/problems/binary-tree-upside-down/\n// Author : Hao Chen\n// Date   : 2014-11-17\n\n/****"
  },
  {
    "path": "algorithms/cpp/binaryTreeZigzagLevelOrderTraversal/binaryTreeZigzagLevelOrderTraversal.cpp",
    "chars": 4974,
    "preview": "// Source : https://oj.leetcode.com/problems/binary-tree-zigzag-level-order-traversal/\n// Author : Hao Chen\n// Date   : "
  },
  {
    "path": "algorithms/cpp/binaryWatch/BinaryWatch.cpp",
    "chars": 3442,
    "preview": "// Source : https://leetcode.com/problems/binary-watch/\n// Author : Hao Chen\n// Date   : 2016-11-05\n\n/******************"
  },
  {
    "path": "algorithms/cpp/bitwiseANDOfNumbersRange/BitwiseAndOfNumbersRange.cpp",
    "chars": 1713,
    "preview": "// Source : https://leetcode.com/problems/bitwise-and-of-numbers-range/\n// Author : Hao Chen\n// Date   : 2015-06-08\n\n/**"
  },
  {
    "path": "algorithms/cpp/brokenCalculator/BrokenCalculator.cpp",
    "chars": 1433,
    "preview": "// Source : https://leetcode.com/problems/broken-calculator/\n// Author : Hao Chen\n// Date   : 2019-05-01\n\n/*************"
  },
  {
    "path": "algorithms/cpp/buddyStrings/BuddyStrings.cpp",
    "chars": 1764,
    "preview": "// Source : https://leetcode.com/problems/buddy-strings/description/\n// Author : Hao Chen\n// Date   : 2018-06-27\n\n/*****"
  },
  {
    "path": "algorithms/cpp/buildingBoxes/BuildingBoxes.cpp",
    "chars": 3813,
    "preview": "// Source : https://leetcode.com/problems/building-boxes/\n// Author : Hao Chen\n// Date   : 2021-04-09\n\n/****************"
  },
  {
    "path": "algorithms/cpp/bulbSwitcher/BulbSwitcher.II.cpp",
    "chars": 2573,
    "preview": "// Source : https://leetcode.com/problems/bulb-switcher-ii/\n// Author : Hao Chen\n// Date   : 2021-03-29\n\n/**************"
  },
  {
    "path": "algorithms/cpp/bulbSwitcher/BulbSwitcher.III.cpp",
    "chars": 1993,
    "preview": "// Source : https://leetcode.com/problems/bulb-switcher-iii\n// Author : Hao Chen\n// Date   : 2021-03-29\n\n/**************"
  },
  {
    "path": "algorithms/cpp/bulbSwitcher/BulbSwitcher.IV.cpp",
    "chars": 1945,
    "preview": "// Source : https://leetcode.com/problems/bulb-switcher-iv/\n// Author : Hao Chen\n// Date   : 2021-03-29\n\n/**************"
  },
  {
    "path": "algorithms/cpp/bulbSwitcher/bulbSwitcher.cpp",
    "chars": 2886,
    "preview": "// Source : https://leetcode.com/problems/bulb-switcher/\n// Author : Calinescu Valentin, Hao Chen\n// Date   : 2015-12-28"
  },
  {
    "path": "algorithms/cpp/bullsAndCows/bullsAndCows.cpp",
    "chars": 3419,
    "preview": "// Source : https://leetcode.com/problems/bulls-and-cows/\n// Author : Calinescu Valentin, Hao Chen\n// Date   : 2015-11-0"
  },
  {
    "path": "algorithms/cpp/burstBalloons/BurstBalloons.cpp",
    "chars": 3551,
    "preview": "// Source : https://leetcode.com/problems/burst-balloons/\n// Author : Hao Chen\n// Date   : 2016-01-17\n\n/****************"
  },
  {
    "path": "algorithms/cpp/calculateMoneyInLeetcodeBank/CalculateMoneyInLeetcodeBank.cpp",
    "chars": 2087,
    "preview": "// Source : https://leetcode.com/problems/calculate-money-in-leetcode-bank/\n// Author : Hao Chen\n// Date   : 2021-03-28\n"
  },
  {
    "path": "algorithms/cpp/candy/candy.cpp",
    "chars": 3059,
    "preview": "// Source : https://oj.leetcode.com/problems/candy/\n// Author : Hao Chen\n// Date   : 2014-10-12\n\n/**********************"
  },
  {
    "path": "algorithms/cpp/checkIfArrayIsSortedAndRotated/CheckIfArrayIsSortedAndRotated.cpp",
    "chars": 2273,
    "preview": "// Source : https://leetcode.com/problems/check-if-array-is-sorted-and-rotated/\n// Author : Hao Chen\n// Date   : 2021-02"
  },
  {
    "path": "algorithms/cpp/checkIfBinaryStringHasAtMostOneSegmentOfOnes/CheckIfBinaryStringHasAtMostOneSegmentOfOnes.cpp",
    "chars": 1024,
    "preview": "// Source : https://leetcode.com/problems/check-if-binary-string-has-at-most-one-segment-of-ones/\n// Author : Hao Chen\n/"
  },
  {
    "path": "algorithms/cpp/checkIfNumberIsASumOfPowersOfThree/CheckIfNumberIsASumOfPowersOfThree.cpp",
    "chars": 1781,
    "preview": "// Source : https://leetcode.com/problems/check-if-number-is-a-sum-of-powers-of-three/\n// Author : Hao Chen\n// Date   : "
  },
  {
    "path": "algorithms/cpp/checkIfOneStringSwapCanMakeStringsEqual/CheckIfOneStringSwapCanMakeStringsEqual.cpp",
    "chars": 1796,
    "preview": "// Source : https://leetcode.com/problems/check-if-one-string-swap-can-make-strings-equal/\n// Author : Hao Chen\n// Date "
  },
  {
    "path": "algorithms/cpp/checkIfTheSentenceIsPangram/CheckIfTheSentenceIsPangram.cpp",
    "chars": 1210,
    "preview": "// Source : https://leetcode.com/problems/check-if-the-sentence-is-pangram/\n// Author : Hao Chen\n// Date   : 2021-04-20\n"
  },
  {
    "path": "algorithms/cpp/checkIfWordEqualsSummationOfTwoWords/CheckIfWordEqualsSummationOfTwoWords.cpp",
    "chars": 2665,
    "preview": "// Source : https://leetcode.com/problems/check-if-word-equals-summation-of-two-words/\n// Author : Hao Chen\n// Date   : "
  },
  {
    "path": "algorithms/cpp/climbStairs/climbStairs.cpp",
    "chars": 865,
    "preview": "// Source : https://oj.leetcode.com/problems/climbing-stairs/\n// Author : Hao Chen\n// Date   : 2014-06-27\n\n/************"
  },
  {
    "path": "algorithms/cpp/cloneGraph/cloneGraph.cpp",
    "chars": 2759,
    "preview": "// Source : https://oj.leetcode.com/problems/clone-graph/\n// Author : Hao Chen\n// Date   : 2014-10-12\n\n/****************"
  },
  {
    "path": "algorithms/cpp/closestDessertCost/ClosestDessertCost.cpp",
    "chars": 3782,
    "preview": "// Source : https://leetcode.com/problems/closest-dessert-cost/\n// Author : Hao Chen\n// Date   : 2021-03-14\n\n/**********"
  },
  {
    "path": "algorithms/cpp/closestRoom/ClosestRoom.cpp",
    "chars": 4090,
    "preview": "// Source : https://leetcode.com/problems/closest-room/\n// Author : Hao Chen\n// Date   : 2021-05-03\n\n/******************"
  },
  {
    "path": "algorithms/cpp/closestSubsequenceSum/ClosestSubsequenceSum.cpp",
    "chars": 3670,
    "preview": "// Source : https://leetcode.com/problems/closest-subsequence-sum/\n// Author : Hao Chen\n// Date   : 2021-02-15\n\n/*******"
  },
  {
    "path": "algorithms/cpp/coinChange/CoinChange2.cpp",
    "chars": 2319,
    "preview": "// Source : https://leetcode.com/problems/coin-change-2/\n// Author : Hao Chen\n// Date   : 2019-03-18\n\n/*****************"
  },
  {
    "path": "algorithms/cpp/coinChange/coinChange.cpp",
    "chars": 3354,
    "preview": "// Source : https://leetcode.com/problems/coin-change/\n// Author : Calinescu Valentin, Hao Chen\n// Date   : 2015-12-28\n\n"
  },
  {
    "path": "algorithms/cpp/combinationSum/combinationSum.II.cpp",
    "chars": 2849,
    "preview": "// Source : https://oj.leetcode.com/problems/combination-sum-ii/\n// Author : Hao Chen\n// Date   : 2014-07-19\n\n/*********"
  },
  {
    "path": "algorithms/cpp/combinationSum/combinationSum.III.cpp",
    "chars": 2384,
    "preview": "// Source : https://leetcode.com/problems/combination-sum-iii/\n// Author : Hao Chen\n// Date   : 2015-06-11\n\n/***********"
  },
  {
    "path": "algorithms/cpp/combinationSum/combinationSum.cpp",
    "chars": 2563,
    "preview": "// Source : https://oj.leetcode.com/problems/combination-sum/\n// Author : Hao Chen\n// Date   : 2014-07-19\n\n/************"
  },
  {
    "path": "algorithms/cpp/combinationSumIV/combinationSumIV.cpp",
    "chars": 2466,
    "preview": "// Source : https://leetcode.com/problems/combination-sum-iv/\n// Author : Calinescu Valentin\n// Date   : 2016-08-07\n\n/**"
  },
  {
    "path": "algorithms/cpp/combinations/combinations.cpp",
    "chars": 3247,
    "preview": "// Source : https://oj.leetcode.com/problems/combinations/\n// Author : Hao Chen\n// Date   : 2014-07-03\n\n/***************"
  },
  {
    "path": "algorithms/cpp/compareStringsByFrequencyOfTheSmallestCharacter/CompareStringsByFrequencyOfTheSmallestCharacter.cpp",
    "chars": 2686,
    "preview": "// Source : https://leetcode.com/problems/compare-strings-by-frequency-of-the-smallest-character/\n// Author : Hao Chen\n/"
  },
  {
    "path": "algorithms/cpp/compareVersionNumbers/compareVersionNumbers.cpp",
    "chars": 2517,
    "preview": "// Source : https://oj.leetcode.com/problems/compare-version-numbers/\n// Author : Hao Chen\n// Date   : 2014-12-16\n\n/****"
  },
  {
    "path": "algorithms/cpp/constructBinaryTreeFromInorderAndPostorderTraversal/constructBinaryTreeFromInorderAndPostorderTraversal.cpp",
    "chars": 4118,
    "preview": "// Source : https://oj.leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/\n// Author : Hao"
  },
  {
    "path": "algorithms/cpp/constructBinaryTreeFromPreorderAndInorderTraversal/constructBinaryTreeFromPreorderAndInorderTraversal.cpp",
    "chars": 3024,
    "preview": "// Source : https://oj.leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/\n// Author : Hao "
  },
  {
    "path": "algorithms/cpp/constructTheLexicographicallyLargestValidSequence/ConstructTheLexicographicallyLargestValidSequence.cpp",
    "chars": 3345,
    "preview": "// Source : https://leetcode.com/problems/construct-the-lexicographically-largest-valid-sequence/\n// Author : Hao Chen\n/"
  },
  {
    "path": "algorithms/cpp/containerWithMostWater/containerWithMostWater.cpp",
    "chars": 1906,
    "preview": "// Source : https://oj.leetcode.com/problems/container-with-most-water/\n// Author : Hao Chen\n// Date   : 2014-06-22\n\n/**"
  },
  {
    "path": "algorithms/cpp/containsDuplicate/ContainsDuplicate.II.cpp",
    "chars": 873,
    "preview": "// Source : https://leetcode.com/problems/contains-duplicate-ii/\n// Author : Hao Chen\n// Date   : 2015-06-12\n\n/*********"
  },
  {
    "path": "algorithms/cpp/containsDuplicate/ContainsDuplicate.III.cpp",
    "chars": 1379,
    "preview": "// Source : https://leetcode.com/problems/contains-duplicate-iii/\n// Author : Hao Chen\n// Date   : 2015-06-12\n\n/********"
  },
  {
    "path": "algorithms/cpp/containsDuplicate/ContainsDuplicate.cpp",
    "chars": 786,
    "preview": "// Source : https://leetcode.com/problems/contains-duplicate/\n// Author : Hao Chen\n// Date   : 2015-06-11\n\n/************"
  },
  {
    "path": "algorithms/cpp/convertANumberToHexadecimal/ConvertANumberToHexadecimal.cpp",
    "chars": 1448,
    "preview": "// Source : https://leetcode.com/problems/convert-a-number-to-hexadecimal/\n// Author : Hao Chen\n// Date   : 2016-11-12\n\n"
  },
  {
    "path": "algorithms/cpp/convertSortedArrayToBinarySearchTree/convertSortedArrayToBinarySearchTree.cpp",
    "chars": 1436,
    "preview": "// Source : https://oj.leetcode.com/problems/convert-sorted-array-to-binary-search-tree/\n// Author : Hao Chen\n// Date   "
  },
  {
    "path": "algorithms/cpp/convertSortedListToBinarySearchTree/convertSortedListToBinarySearchTree.cpp",
    "chars": 2558,
    "preview": "// Source : https://oj.leetcode.com/problems/convert-sorted-list-to-binary-search-tree/\n// Author : Hao Chen\n// Date   :"
  },
  {
    "path": "algorithms/cpp/copyListWithRandomPointer/copyListWithRandomPointer.cpp",
    "chars": 5429,
    "preview": "// Source : https://oj.leetcode.com/problems/copy-list-with-random-pointer/\n// Author : Hao Chen\n// Date   : 2014-06-18\n"
  },
  {
    "path": "algorithms/cpp/countAndSay/countAndSay.cpp",
    "chars": 1852,
    "preview": "// Source : https://oj.leetcode.com/problems/count-and-say/\n// Author : Hao Chen\n// Date   : 2014-07-03\n\n/**************"
  },
  {
    "path": "algorithms/cpp/countCompleteTreeNodes/CountCompleteTreeNodes.cpp",
    "chars": 1576,
    "preview": "// Source : https://leetcode.com/problems/count-complete-tree-nodes/\n// Author : Hao Chen\n// Date   : 2015-06-12\n\n/*****"
  },
  {
    "path": "algorithms/cpp/countGoodMeals/CountGoodMeals.cpp",
    "chars": 2190,
    "preview": "// Source : https://leetcode.com/problems/count-good-meals/\n// Author : Hao Chen\n// Date   : 2021-03-30\n\n/**************"
  },
  {
    "path": "algorithms/cpp/countItemsMatchingARule/CountItemsMatchingARule.cpp",
    "chars": 2203,
    "preview": "// Source : https://leetcode.com/problems/count-items-matching-a-rule/\n// Author : Hao Chen\n// Date   : 2021-03-14\n\n/***"
  },
  {
    "path": "algorithms/cpp/countNicePairsInAnArray/CountNicePairsInAnArray.cpp",
    "chars": 2504,
    "preview": "// Source : https://leetcode.com/problems/count-nice-pairs-in-an-array/\n// Author : Hao Chen\n// Date   : 2021-04-06\n\n/**"
  },
  {
    "path": "algorithms/cpp/countNumberOfHomogenousSubstrings/CountNumberOfHomogenousSubstrings.cpp",
    "chars": 1759,
    "preview": "// Source : https://leetcode.com/problems/count-number-of-homogenous-substrings/\n// Author : Hao Chen\n// Date   : 2021-0"
  },
  {
    "path": "algorithms/cpp/countNumbersWithUniqueDigits/CountNumbersWithUniqueDigits.cpp",
    "chars": 1962,
    "preview": "// Source : https://leetcode.com/problems/count-numbers-with-unique-digits/\n// Author : Hao Chen\n// Date   : 2019-03-24\n"
  },
  {
    "path": "algorithms/cpp/countOddNumbersInAnIntervalRange/CountOddNumbersInAnIntervalRange.cpp",
    "chars": 1229,
    "preview": "// Source : https://leetcode.com/problems/count-odd-numbers-in-an-interval-range/\n// Author : Hao Chen\n// Date   : 2020-"
  },
  {
    "path": "algorithms/cpp/countOfRangeSum/CountOfRangeSum.cpp",
    "chars": 5343,
    "preview": "// Source : https://leetcode.com/problems/count-of-range-sum/\n// Author : Hao Chen\n// Date   : 2016-01-15\n\n/************"
  },
  {
    "path": "algorithms/cpp/countOfSmallerNumbersAfterSelf/countOfSmallerNumbersAfterSelf.cpp",
    "chars": 4807,
    "preview": "// Source : https://leetcode.com/problems/count-of-smaller-numbers-after-self/\n// Author : Calinescu Valentin, Hao Chen\n"
  },
  {
    "path": "algorithms/cpp/countPairsOfNodes/CountPairsOfNodes.cpp",
    "chars": 4878,
    "preview": "// Source : https://leetcode.com/problems/count-pairs-of-nodes/\n// Author : Hao Chen\n// Date   : 2021-03-23\n\n/**********"
  },
  {
    "path": "algorithms/cpp/countPairsWithXorInARange/CountPairsWithXorInARange.cpp",
    "chars": 6008,
    "preview": "// Source : https://leetcode.com/problems/count-pairs-with-xor-in-a-range/\n// Author : Hao Chen\n// Date   : 2021-03-21\n\n"
  },
  {
    "path": "algorithms/cpp/countPrimes/CountPrimes.cpp",
    "chars": 5840,
    "preview": "// Source : https://leetcode.com/problems/count-primes/\n// Author : Hao Chen\n// Date   : 2015-06-09\n\n/******************"
  },
  {
    "path": "algorithms/cpp/countingBits/CountingBits.cpp",
    "chars": 2491,
    "preview": "// Source : https://leetcode.com/problems/counting-bits/\n// Author : Hao Chen\n// Date   : 2016-05-30\n\n/*****************"
  },
  {
    "path": "algorithms/cpp/courseSchedule/CourseSchedule.II.cpp",
    "chars": 3963,
    "preview": "// Source : https://leetcode.com/problems/course-schedule-ii/\n// Author : Hao Chen\n// Date   : 2015-06-10\n\n/************"
  },
  {
    "path": "algorithms/cpp/courseSchedule/CourseSchedule.cpp",
    "chars": 3256,
    "preview": "// Source : https://leetcode.com/problems/course-schedule/\n// Author : Hao Chen\n// Date   : 2015-06-09\n\n/***************"
  },
  {
    "path": "algorithms/cpp/courseSchedule/non-recursive/course_schedule.cpp",
    "chars": 5015,
    "preview": "//\n//  course_schedule.cpp\n//  LeeteCodeOJ#207\n//\n//  Created by Wang Yi on 28/11/16.\n//  Copyright (c) 2016 Wang Yi. Al"
  },
  {
    "path": "algorithms/cpp/courseSchedule/non-recursive/main.cpp",
    "chars": 686,
    "preview": "//\n//  main.cpp\n//  LeeteCodeOJ#207\n//\n//  Created by Wang Yi on 28/11/16.\n//  Copyright (c) 2016 Wang Yi. All rights re"
  },
  {
    "path": "algorithms/cpp/cousinsInBinaryTree/CousinsInBinaryTree.cpp",
    "chars": 2087,
    "preview": "// Source : https://leetcode.com/problems/cousins-in-binary-tree/\n// Author : Hao Chen\n// Date   : 2019-04-30\n\n/********"
  },
  {
    "path": "algorithms/cpp/createMaximumNumber/CreateMaximumNumber.cpp",
    "chars": 4815,
    "preview": "// Source : https://leetcode.com/problems/create-maximum-number/\n// Author : Hao Chen\n// Date   : 2016-01-21\n\n/*********"
  },
  {
    "path": "algorithms/cpp/decodeString/DecodeString.cpp",
    "chars": 3023,
    "preview": "// Source : https://leetcode.com/problems/decode-string/\n// Author : Hao Chen\n// Date   : 2016-09-08\n\n/*****************"
  },
  {
    "path": "algorithms/cpp/decodeWays/decodeWays.cpp",
    "chars": 1887,
    "preview": "// Source : https://oj.leetcode.com/problems/decode-ways/\n// Author : Hao Chen\n// Date   : 2014-07-16\n\n/****************"
  },
  {
    "path": "algorithms/cpp/decodeXORedPermutation/DecodeXoredPermutation.cpp",
    "chars": 3386,
    "preview": "// Source : https://leetcode.com/problems/decode-xored-permutation/\n// Author : Hao Chen\n// Date   : 2021-02-17\n\n/******"
  },
  {
    "path": "algorithms/cpp/deleteNodeInALinkedList/DeleteNodeInALinkedList.cpp",
    "chars": 1023,
    "preview": "// Source : https://leetcode.com/problems/delete-node-in-a-linked-list/\n// Author : Hao Chen\n// Date   : 2015-07-17\n\n/**"
  },
  {
    "path": "algorithms/cpp/designAuthenticationManager/DesignAuthenticationManager.cpp",
    "chars": 4804,
    "preview": "// Source : https://leetcode.com/problems/design-authentication-manager/\n// Author : Hao Chen\n// Date   : 2021-03-22\n\n/*"
  },
  {
    "path": "algorithms/cpp/detectCapital/DetectCapital.cpp",
    "chars": 1603,
    "preview": "// Source : https://leetcode.com/problems/detect-capital/\n// Author : Hao Chen\n// Date   : 2019-02-04\n\n/****************"
  },
  {
    "path": "algorithms/cpp/determineColorOfAChessboardSquare/DetermineColorOfAChessboardSquare.cpp",
    "chars": 1393,
    "preview": "// Source : https://leetcode.com/problems/determine-color-of-a-chessboard-square/\n// Author : Hao Chen\n// Date   : 2021-"
  },
  {
    "path": "algorithms/cpp/diameterOfBinaryTree/diameterOfBinaryTree.cpp",
    "chars": 914,
    "preview": "// Source : https://leetcode.com/problems/add-and-search-word-data-structure-design/\n// Author : Arshdeep Singh\n// Date "
  },
  {
    "path": "algorithms/cpp/differentWaysToAddParentheses/DifferentWaysToAddParentheses.cpp",
    "chars": 3002,
    "preview": "// Source : https://leetcode.com/problems/different-ways-to-add-parentheses/\n// Author : Hao Chen\n// Date   : 2015-08-15"
  },
  {
    "path": "algorithms/cpp/distinctSubsequences/distinctSubsequences.cpp",
    "chars": 5111,
    "preview": "// Source : https://oj.leetcode.com/problems/distinct-subsequences/\n// Author : Hao Chen\n// Date   : 2014-07-06\n\n/******"
  },
  {
    "path": "algorithms/cpp/distributeCoinsInBinaryTree/DistributeCoinsInBinaryTree.cpp",
    "chars": 2767,
    "preview": "// Source : https://leetcode.com/problems/distribute-coins-in-binary-tree/\n// Author : Hao Chen\n// Date   : 2019-03-29\n\n"
  },
  {
    "path": "algorithms/cpp/divideTwoInt/divideTwoInt.cpp",
    "chars": 2310,
    "preview": "// Source : https://oj.leetcode.com/problems/divide-two-integers/\n// Author : Hao Chen\n// Date   : 2014-06-20\n\n/********"
  },
  {
    "path": "algorithms/cpp/dungeonGame/dungeonGame.cpp",
    "chars": 3602,
    "preview": "// Source : https://oj.leetcode.com/problems/dungeon-game/\n// Author : Hao Chen\n// Date   : 2015-01-16\n\n/***************"
  },
  {
    "path": "algorithms/cpp/editDistance/editDistance.cpp",
    "chars": 3851,
    "preview": "// Source : https://oj.leetcode.com/problems/edit-distance/\n// Author : Hao Chen\n// Date   : 2014-08-22\n\n/**************"
  },
  {
    "path": "algorithms/cpp/eggDropWith2EggsAndNFloors/EggDropWith2EggsAndNFloors.cpp",
    "chars": 2679,
    "preview": "// Source : https://leetcode.com/problems/egg-drop-with-2-eggs-and-n-floors/\n// Author : Hao Chen\n// Date   : 2021-11-15"
  },
  {
    "path": "algorithms/cpp/eliminationGame/EliminationGame.cpp",
    "chars": 1155,
    "preview": "// Source : https://leetcode.com/problems/elimination-game\n// Author : Hao Chen\n// Date   : 2016-09-07-\n\n/**************"
  },
  {
    "path": "algorithms/cpp/equalSumArraysWithMinimumNumberOfOperations/EqualSumArraysWithMinimumNumberOfOperations.cpp",
    "chars": 4833,
    "preview": "// Source : https://leetcode.com/problems/equal-sum-arrays-with-minimum-number-of-operations/\n// Author : Hao Chen\n// Da"
  },
  {
    "path": "algorithms/cpp/evaluateDivision/EvaluateDivision.cpp",
    "chars": 3366,
    "preview": "// Source : https://leetcode.com/problems/evaluate-division/\n// Author : Hao Chen\n// Date   : 2016-11-05\n\n/*************"
  },
  {
    "path": "algorithms/cpp/evaluateReversePolishNotation/evaluateReversePolishNotation.cpp",
    "chars": 2894,
    "preview": "// Source : https://oj.leetcode.com/problems/evaluate-reverse-polish-notation/\n// Author : Hao Chen\n// Date   : 2014-06-"
  },
  {
    "path": "algorithms/cpp/evaluateTheBracketPairsOfAString/EvaluateTheBracketPairsOfAString.cpp",
    "chars": 3740,
    "preview": "// Source : https://leetcode.com/problems/evaluate-the-bracket-pairs-of-a-string/\n// Author : Hao Chen\n// Date   : 2021-"
  },
  {
    "path": "algorithms/cpp/excelSheetColumnNumber/excelSheetColumnNumber.cpp",
    "chars": 1544,
    "preview": "// Source : https://oj.leetcode.com/problems/excel-sheet-column-number/\n// Author : Hao Chen\n// Date   : 2014-12-29\n\n/**"
  },
  {
    "path": "algorithms/cpp/excelSheetColumnTitle/excelSheetColumnTitle.cpp",
    "chars": 1507,
    "preview": "// Source : https://oj.leetcode.com/problems/excel-sheet-column-title/\n// Author : Hao Chen\n// Date   : 2014-12-25\n\n/***"
  },
  {
    "path": "algorithms/cpp/expressionAddOperators/ExpressionAddOperators.cpp",
    "chars": 3363,
    "preview": "// Source : https://leetcode.com/problems/expression-add-operators/\n// Author : Hao Chen\n// Date   : 2016-01-16\n\n/******"
  },
  {
    "path": "algorithms/cpp/factorialTrailingZeroes/factorialTrailingZeroes.cpp",
    "chars": 2853,
    "preview": "// Source : https://oj.leetcode.com/problems/factorial-trailing-zeroes/\n// Author : Hao Chen\n// Date   : 2014-12-30\n\n/**"
  },
  {
    "path": "algorithms/cpp/fibonacciNumber/FibonacciNumber.cpp",
    "chars": 1190,
    "preview": "// Source : https://leetcode.com/problems/fibonacci-number/\n// Author : Hao Chen\n// Date   : 2019-03-26\n\n/**************"
  },
  {
    "path": "algorithms/cpp/filterRestaurantsByVeganFriendlyPriceAndDistance/FilterRestaurantsByVeganFriendlyPriceAndDistance.cpp",
    "chars": 3538,
    "preview": "// Source : https://leetcode.com/problems/filter-restaurants-by-vegan-friendly-price-and-distance/\n// Author : Sharvil K"
  },
  {
    "path": "algorithms/cpp/findAllAnagramsInAString/Find-All-Anagrams-in-a-String.cpp",
    "chars": 1725,
    "preview": "// Source : https://leetcode.com/problems/find-all-anagrams-in-a-string/\n// Author : Manu Gond\n// Date   : 2019-10-06\n\n/"
  },
  {
    "path": "algorithms/cpp/findCenterOfStarGraph/FindCenterOfStarGraph.cpp",
    "chars": 1172,
    "preview": "// Source : https://leetcode.com/problems/find-center-of-star-graph/\n// Author : Hao Chen\n// Date   : 2021-03-19\n\n/*****"
  },
  {
    "path": "algorithms/cpp/findKthLargestXorCoordinateValue/FindKthLargestXorCoordinateValue.cpp",
    "chars": 2922,
    "preview": "// Source : https://leetcode.com/problems/find-kth-largest-xor-coordinate-value/\n// Author : Hao Chen\n// Date   : 2021-0"
  },
  {
    "path": "algorithms/cpp/findMedianFromDataStream/FindMedianFromDataStream.cpp",
    "chars": 2109,
    "preview": "// Source : https://leetcode.com/problems/find-median-from-data-stream/\n// Author : Hao Chen\n// Date   : 2015-11-14\n\n/**"
  },
  {
    "path": "algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.II.cpp",
    "chars": 3504,
    "preview": "// Source : https://oj.leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/\n// Author : Hao Chen\n// Date   : 2"
  },
  {
    "path": "algorithms/cpp/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp",
    "chars": 3184,
    "preview": "// Source : https://oj.leetcode.com/problems/find-minimum-in-rotated-sorted-array/\n// Author : Hao Chen\n// Date   : 2014"
  },
  {
    "path": "algorithms/cpp/findNearestPointThatHasTheSameXOrYCoordinate/FindNearestPointThatHasTheSameXOrYCoordinate.cpp",
    "chars": 2261,
    "preview": "// Source : https://leetcode.com/problems/find-nearest-point-that-has-the-same-x-or-y-coordinate/\n// Author : Hao Chen\n/"
  },
  {
    "path": "algorithms/cpp/findPeakElement/findPeakElement.cpp",
    "chars": 3300,
    "preview": "// Source : https://oj.leetcode.com/problems/find-peak-element/\n// Author : Hao Chen\n// Date   : 2014-12-05\n\n/**********"
  },
  {
    "path": "algorithms/cpp/findTheDifference/FindTheDifference.cpp",
    "chars": 919,
    "preview": "// Source : https://leetcode.com/problems/find-the-difference/\n// Author : Hao Chen\n// Date   : 2016-09-08\n\n/***********"
  },
  {
    "path": "algorithms/cpp/findTheDuplicateNumber/findTheDuplicateNumber.cpp",
    "chars": 1656,
    "preview": "// Source : https://leetcode.com/problems/find-the-duplicate-number/\n// Author : Hao Chen, Calinescu Valentin\n// Date   "
  },
  {
    "path": "algorithms/cpp/findTheHighestAltitude/FindTheHighestAltitude.cpp",
    "chars": 1318,
    "preview": "// Source : https://leetcode.com/problems/find-the-highest-altitude/\n// Author : Hao Chen\n// Date   : 2021-02-17\n\n/*****"
  },
  {
    "path": "algorithms/cpp/findTheWinnerOfAnArrayGame/FindTheWinnerOfAnArrayGame.cpp",
    "chars": 2902,
    "preview": "// Source : https://leetcode.com/problems/find-the-winner-of-an-array-game/\n// Author : Hao Chen\n// Date   : 2020-10-02\n"
  },
  {
    "path": "algorithms/cpp/findTheWinnerOfTheCircularGame/FindTheWinnerOfTheCircularGame.cpp",
    "chars": 2477,
    "preview": "// Source : https://leetcode.com/problems/find-the-winner-of-the-circular-game/\n// Author : Hao Chen\n// Date   : 2021-04"
  },
  {
    "path": "algorithms/cpp/findXorSumOfAllPairsBitwiseAnd/FindXorSumOfAllPairsBitwiseAnd.cpp",
    "chars": 1722,
    "preview": "// Source : https://leetcode.com/problems/find-xor-sum-of-all-pairs-bitwise-and/\n// Author : Hao Chen\n// Date   : 2021-0"
  },
  {
    "path": "algorithms/cpp/findingMkAverage/FindingMkAverage.cpp",
    "chars": 7864,
    "preview": "// Source : https://leetcode.com/problems/finding-mk-average/\n// Author : Hao Chen\n// Date   : 2021-04-20\n\n/************"
  },
  {
    "path": "algorithms/cpp/findingTheUsersActiveMinutes/FindingTheUsersActiveMinutes.cpp",
    "chars": 2580,
    "preview": "// Source : https://leetcode.com/problems/finding-the-users-active-minutes/\n// Author : Hao Chen\n// Date   : 2021-04-05\n"
  },
  {
    "path": "algorithms/cpp/firstBadVersion/FirstBadVersion.cpp",
    "chars": 1587,
    "preview": "// Source : https://leetcode.com/problems/first-bad-version/\n// Author : Hao Chen\n// Date   : 2015-10-19\n\n/*************"
  },
  {
    "path": "algorithms/cpp/firstMissingPositive/firstMissingPositive.cpp",
    "chars": 4068,
    "preview": "// Source : https://oj.leetcode.com/problems/first-missing-positive/\n// Author : Hao Chen\n// Date   : 2014-07-18\n\n/*****"
  },
  {
    "path": "algorithms/cpp/firstUniqueCharacterInAString/FirstUniqueCharacterInAString.cpp",
    "chars": 1795,
    "preview": "// Source : https://leetcode.com/problems/first-unique-character-in-a-string/\n// Author : Hao Chen\n// Date   : 2016-08-2"
  },
  {
    "path": "algorithms/cpp/fizzBuzz/FizzBuzz.cpp",
    "chars": 2268,
    "preview": "// Source : https://leetcode.com/problems/fizz-buzz/\n// Author : Hao Chen\n// Date   : 2016-11-13\n\n/*********************"
  },
  {
    "path": "algorithms/cpp/flattenBinaryTreeToLinkedList/flattenBinaryTreeToLinkedList.cpp",
    "chars": 1688,
    "preview": "// Source : https://oj.leetcode.com/problems/flatten-binary-tree-to-linked-list/\n// Author : Hao Chen\n// Date   : 2014-0"
  },
  {
    "path": "algorithms/cpp/flattenNestedListIterator/FlattenNestedListIterator.cpp",
    "chars": 2317,
    "preview": "// Source : https://leetcode.com/problems/flatten-nested-list-iterator/\n// Author : Hao Chen\n// Date   : 2016-05-30\n\n/**"
  },
  {
    "path": "algorithms/cpp/formArrayByConcatenatingSubarraysOfAnotherArray/FormArrayByConcatenatingSubarraysOfAnotherArray.cpp",
    "chars": 3862,
    "preview": "// Source : https://leetcode.com/problems/form-array-by-concatenating-subarrays-of-another-array/\n// Author : Hao Chen\n/"
  },
  {
    "path": "algorithms/cpp/fractionToRecurringDecimal/fractionToRecurringDecimal.cpp",
    "chars": 3267,
    "preview": "// Source : https://oj.leetcode.com/problems/fraction-to-recurring-decimal/\n// Author : Hao Chen\n// Date   : 2014-12-16\n"
  },
  {
    "path": "algorithms/cpp/frequencyOfTheMostFrequentElement/FrequencyOfTheMostFrequentElement.cpp",
    "chars": 2000,
    "preview": "// Source : https://leetcode.com/problems/frequency-of-the-most-frequent-element/\n// Author : Hao Chen\n// Date   : 2021-"
  },
  {
    "path": "algorithms/cpp/friendCircles/FriendCircles.cpp",
    "chars": 3783,
    "preview": "// Source : https://leetcode.com/problems/friend-circles/\n// Author : Hao Chen\n// Date   : 2019-03-26\n\n/****************"
  },
  {
    "path": "algorithms/cpp/frogJump/FrogJump.cpp",
    "chars": 4835,
    "preview": "// Source : https://leetcode.com/problems/frog-jump/\n// Author : Hao Chen\n// Date   : 2016-11-12\n\n/*********************"
  },
  {
    "path": "algorithms/cpp/gameOfLife/GameOfLife.cpp",
    "chars": 3326,
    "preview": "// Source : https://leetcode.com/problems/game-of-life/\n// Author : Hao Chen\n// Date   : 2019-03-20\n\n/******************"
  },
  {
    "path": "algorithms/cpp/gasStation/gasStation.cpp",
    "chars": 1446,
    "preview": "// Source : https://oj.leetcode.com/problems/gas-station/\n// Author : Hao Chen\n// Date   : 2014-10-11\n\n/****************"
  },
  {
    "path": "algorithms/cpp/generateParentheses/generateParentheses.cpp",
    "chars": 1436,
    "preview": "// Source : https://oj.leetcode.com/problems/generate-parentheses/\n// Author : Hao Chen\n// Date   : 2014-06-29\n\n/*******"
  },
  {
    "path": "algorithms/cpp/grayCode/grayCode.cpp",
    "chars": 3445,
    "preview": "// Source : https://oj.leetcode.com/problems/gray-code/\n// Author : Hao Chen\n// Date   : 2014-06-20\n\n/******************"
  },
  {
    "path": "algorithms/cpp/greatestCommonDivisorOfStrings/GreatestCommonDivisorOfStrings.cpp",
    "chars": 2156,
    "preview": "// Source : https://leetcode.com/problems/greatest-common-divisor-of-strings/\n// Author : Hao Chen\n// Date   : 2020-07-1"
  },
  {
    "path": "algorithms/cpp/h-Index/h-Index.II.cpp",
    "chars": 935,
    "preview": "// Source : https://leetcode.com/problems/h-index-ii/\n// Author : Hao Chen\n// Date   : 2015-11-08\n\n/********************"
  },
  {
    "path": "algorithms/cpp/h-Index/h-Index.cpp",
    "chars": 2482,
    "preview": "// Source : https://leetcode.com/problems/h_index/\n// Author : Calinescu Valentin, Hao Chen\n// Date   : 2015-10-22\n\n/***"
  },
  {
    "path": "algorithms/cpp/happyNumber/HappyNumber.cpp",
    "chars": 1661,
    "preview": "// Source : https://leetcode.com/problems/happy-number/\n// Author : Hao Chen\n// Date   : 2015-06-08\n\n/******************"
  },
  {
    "path": "algorithms/cpp/houseRobber/houseRobber.II.cpp",
    "chars": 1963,
    "preview": "// Source : https://leetcode.com/problems/house-robber-ii/\n// Author : Hao Chen\n// Date   : 2015-06-10\n\n/***************"
  },
  {
    "path": "algorithms/cpp/houseRobber/houseRobber.cpp",
    "chars": 2641,
    "preview": "// Source : https://leetcode.com/problems/house-robber/\n// Author : Hao Chen\n// Date   : 2015-04-07\n\n/******************"
  },
  {
    "path": "algorithms/cpp/houseRobber/houseRobberIII.cpp",
    "chars": 4918,
    "preview": "// Source : https://leetcode.com/problems/house-robber-iii/\n// Author : Calinescu Valentin, Hao Chen\n// Date   : 2016-04"
  },
  {
    "path": "algorithms/cpp/implementQueueUsingStacks/ImplementQueueUsingStacks.cpp",
    "chars": 1787,
    "preview": "// Source : https://leetcode.com/problems/implement-queue-using-stacks/\n// Author : Hao Chen\n// Date   : 2015-07-16\n\n/**"
  },
  {
    "path": "algorithms/cpp/implementStackUsingQueues/ImplementStackUsingQueues.cpp",
    "chars": 2045,
    "preview": "// Source : https://leetcode.com/problems/implement-stack-using-queues/\n// Author : Hao Chen\n// Date   : 2015-06-13\n\n/**"
  },
  {
    "path": "algorithms/cpp/implementTriePrefixTree/ImplementTriePrefixTree.cpp",
    "chars": 1951,
    "preview": "// Source : https://leetcode.com/problems/implement-trie-prefix-tree/\n// Author : Hao Chen\n// Date   : 2015-06-09\n\n/****"
  },
  {
    "path": "algorithms/cpp/increasingTripletSubsequence/increasingTripletSubsequence.cpp",
    "chars": 1977,
    "preview": "// Source : https://leetcode.com/problems/increasing-triplet-subsequence/\n// Author : Calinescu Valentin, Hao Chen\n// Da"
  },
  {
    "path": "algorithms/cpp/incrementalMemoryLeak/IncrementalMemoryLeak.cpp",
    "chars": 2801,
    "preview": "// Source : https://leetcode.com/problems/incremental-memory-leak/\n// Author : Hao Chen\n// Date   : 2021-05-22\n\n/*******"
  },
  {
    "path": "algorithms/cpp/insertDeleteGetRandom/InsertDeleteGetrandomO1.cpp",
    "chars": 2896,
    "preview": "// Source : https://leetcode.com/problems/insert-delete-getrandom-o1/\n// Author : Hao Chen\n// Date   : 2016-08-25\n\n/****"
  },
  {
    "path": "algorithms/cpp/insertDeleteGetRandom/InsertDeleteGetrandomO1DuplicatesAllowed.cpp",
    "chars": 3387,
    "preview": "// Source : https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/\n// Author : Hao Chen\n// Date   "
  },
  {
    "path": "algorithms/cpp/insertInterval/insertInterval.cpp",
    "chars": 2602,
    "preview": "// Source : https://oj.leetcode.com/problems/insert-interval/\n// Author : Hao Chen\n// Date   : 2014-08-26\n\n/************"
  },
  {
    "path": "algorithms/cpp/insertionSortList/insertionSortList.cpp",
    "chars": 1954,
    "preview": "// Source : https://oj.leetcode.com/problems/insertion-sort-list/\n// Author : Hao Chen\n// Date   : 2014-07-19\n\n/********"
  },
  {
    "path": "algorithms/cpp/integerBreak/IntegerBreak.cpp",
    "chars": 1758,
    "preview": "// Source : https://leetcode.com/problems/integer-break/\n// Author : Hao Chen\n// Date   : 2016-05-29\n\n/*****************"
  },
  {
    "path": "algorithms/cpp/integerReplacement/IntegerReplacement.cpp",
    "chars": 2236,
    "preview": "// Source : https://leetcode.com/problems/integer-replacement/\n// Author : Hao Chen\n// Date   : 2016-11-04\n\n/***********"
  },
  {
    "path": "algorithms/cpp/integerToEnglishWords/IntegerToEnglishWords.cpp",
    "chars": 3510,
    "preview": "// Source : https://leetcode.com/problems/integer-to-english-words/\n// Author : Hao Chen\n// Date   : 2015-10-22\n\n/******"
  },
  {
    "path": "algorithms/cpp/integerToRoman/integerToRoman.cpp",
    "chars": 1080,
    "preview": "// Source : https://oj.leetcode.com/problems/integer-to-roman/\n// Author : Hao Chen\n// Date   : 2014-07-17\n\n/***********"
  },
  {
    "path": "algorithms/cpp/interleavingString/interleavingString.cpp",
    "chars": 3888,
    "preview": "// Source : https://oj.leetcode.com/problems/interleaving-string/\n// Author : Hao Chen\n// Date   : 2014-08-27\n\n/********"
  },
  {
    "path": "algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArrays.cpp",
    "chars": 2233,
    "preview": "// Source : https://leetcode.com/problems/intersection-of-two-arrays/\n// Author : Calinescu Valentin, Hao Chen\n// Date  "
  },
  {
    "path": "algorithms/cpp/intersectionOfTwoArrays/intersectionOfTwoArraysII.cpp",
    "chars": 2955,
    "preview": "// Source : https://leetcode.com/problems/intersection-of-two-arrays-ii/\n// Author : Calinescu Valentin, Hao Chen\n// Dat"
  },
  {
    "path": "algorithms/cpp/intersectionOfTwoLinkedLists/intersectionOfTwoLinkedLists.cpp",
    "chars": 2220,
    "preview": "// Source : https://oj.leetcode.com/problems/intersection-of-two-linked-lists/\n// Author : Hao Chen\n// Date   : 2014-12-"
  },
  {
    "path": "algorithms/cpp/intervalListIntersectons/IntervalListIntersections.cpp",
    "chars": 3422,
    "preview": "// Source : https://leetcode.com/problems/interval-list-intersections/\n// Author : Hao Chen\n// Date   : 2019-02-05\n\n/***"
  },
  {
    "path": "algorithms/cpp/invertBinaryTree/InvertBinaryTree.cpp",
    "chars": 1885,
    "preview": "// Source : https://leetcode.com/problems/invert-binary-tree/\n// Author : Hao Chen\n// Date   : 2015-06-12\n\n/************"
  },
  {
    "path": "algorithms/cpp/isSubsequence/IsSubsequence.cpp",
    "chars": 1546,
    "preview": "// Source : https://leetcode.com/problems/is-subsequence/\n// Author : Hao Chen\n// Date   : 2016-09-08\n\n/****************"
  },
  {
    "path": "algorithms/cpp/islandPerimeter/IslandPerimeter.cpp",
    "chars": 1929,
    "preview": "// Source : https://leetcode.com/problems/island-perimeter/\n// Author : Hao Chen\n// Date   : 2019-02-04\n\n/**************"
  },
  {
    "path": "algorithms/cpp/isomorphicStrings/IsomorphicStrings.cpp",
    "chars": 1554,
    "preview": "// Source : https://leetcode.com/problems/isomorphic-strings/\n// Author : Hao Chen\n// Date   : 2015-06-09\n\n/************"
  },
  {
    "path": "algorithms/cpp/jewelsAndStones/JewelsAndStones.cpp",
    "chars": 1280,
    "preview": "// Source : https://leetcode.com/problems/jewels-and-stones/description\n// Author : Hao Chen\n// Date   : 2018-06-23\n\n/**"
  },
  {
    "path": "algorithms/cpp/jumpGame/jumpGame.II.cpp",
    "chars": 2129,
    "preview": "// Source : https://oj.leetcode.com/problems/jump-game-ii/\n// Author : Hao Chen\n// Date   : 2014-07-18\n\n/***************"
  },
  {
    "path": "algorithms/cpp/jumpGame/jumpGame.VII.cpp",
    "chars": 1154,
    "preview": "// Source : https://leetcode.com/problems/jump-game-vii/\n// Author : Hao Chen\n// Date   : 2021-05-30\n\n/*****************"
  },
  {
    "path": "algorithms/cpp/jumpGame/jumpGame.cpp",
    "chars": 1181,
    "preview": "// Source : https://oj.leetcode.com/problems/jump-game/\n// Author : Hao Chen\n// Date   : 2014-06-27\n\n/******************"
  },
  {
    "path": "algorithms/cpp/kthLargestElementInAnArray/KthLargestElementInAnArray.cpp",
    "chars": 1919,
    "preview": "// Source : https://leetcode.com/problems/kth-largest-element-in-an-array/\n// Author : Hao Chen\n// Date   : 2015-06-11\n\n"
  },
  {
    "path": "algorithms/cpp/kthSmallestElementInaBST/KthSmallestElementInABst.cpp",
    "chars": 2216,
    "preview": "// Source : https://leetcode.com/problems/kth-smallest-element-in-a-bst/\n// Author : Hao Chen\n// Date   : 2015-07-03\n\n/*"
  },
  {
    "path": "algorithms/cpp/largestColorValueInADirectedGraph/LargestColorValueInADirectedGraph.cpp",
    "chars": 5559,
    "preview": "// Source : https://leetcode.com/problems/largest-color-value-in-a-directed-graph/\n// Author : Hao Chen\n// Date   : 2021"
  },
  {
    "path": "algorithms/cpp/largestMergeOfTwoStrings/LargestMergeOfTwoStrings.cpp",
    "chars": 3128,
    "preview": "// Source : https://leetcode.com/problems/largest-merge-of-two-strings/\n// Author : Hao Chen\n// Date   : 2021-02-11\n\n/**"
  },
  {
    "path": "algorithms/cpp/largestNumber/largestNumber.cpp",
    "chars": 1392,
    "preview": "// Source : https://oj.leetcode.com/problems/largest-number/\n// Author : Hao Chen\n// Date   : 2015-01-16\n\n/*************"
  }
]

// ... and 530 more files (download for full content)