├── .gitattributes ├── .gitignore ├── LeetCode.Test ├── 0001-0050 │ ├── 001-TwoSume-Test.cs │ ├── 002-AddTwoNumbers-Test.cs │ ├── 003-LongestSubstringWithoutRepeatingCharacters-Test.cs │ ├── 004-MedianOfTwoSortedArrays-Test.cs │ ├── 005-LongestPalindromicSubstring-Test.cs │ ├── 006-ZigZagConversion-Test.cs │ ├── 007-ReverseInteger-Test.cs │ ├── 008-StringToInteger-Test.cs │ ├── 009-PalindromeNumber-Test.cs │ ├── 010-RegularExpressionMatching-Test.cs │ ├── 011_ContainerWithMostWater-Test.cs │ ├── 012-IntegerToRoman-Test.cs │ ├── 013-RomanToInteger-Test.cs │ ├── 014-LongestCommonPrefix_Test.cs │ ├── 015-3Sum-Test.cs │ ├── 016-3SumClosest-Test.cs │ ├── 017-LetterCombinationsOfAPhoneNumber-Test.cs │ ├── 018-FourSum-Test.cs │ ├── 019-RemoveNthNodeFromEndOfList-Test.cs │ ├── 020-ValidParentheses-Test.cs │ ├── 021-MergeTwoSortedLists-Test.cs │ ├── 022-GenerateParentheses-Test.cs │ ├── 023-MergeKSortedLists-Test.cs │ ├── 024-SwapNodesInPairs-Test.cs │ ├── 025-ReverseNodesInKGroup-TEst.cs │ ├── 026-RemoveDuplicatesFromSortedArray-Test.cs │ ├── 027-RemoveElement-Test.cs │ ├── 028-ImplementStrStr-Test.cs │ ├── 029-DivideTwoIntegers-Test.cs │ ├── 030-SubstringWithConcatenationOfAllWords-Test.cs │ ├── 031-NextPermutation-Test.cs │ ├── 032-LongestValidParentheses-Test.cs │ ├── 033-SearchInRotatedSortedArray-Test.cs │ ├── 034-SearchForARange-Test.cs │ ├── 035-SearchInsertPosition-Test.cs │ ├── 036-ValidSudoku-Test.cs │ ├── 037-SudokuSolver-Test.cs │ ├── 038-CountAndSay-Test.cs │ ├── 039-CombinationSum-Test.cs │ ├── 040-CombinationSum2-Test.cs │ ├── 041-FirstMissingPositive-Test.cs │ ├── 042-TrappingRainWater-Test.cs │ ├── 043-MultiplyStrings-Test.cs │ ├── 044-WildcardMatching-Test.cs │ ├── 045-JumpGame2-Test.cs │ ├── 046-Permutations-Test.cs │ ├── 047-Permutations2-Test.cs │ ├── 048-RotateImage-Test.cs │ ├── 049-GroupAnagrams-Test.cs │ └── 050-Pow-Test.cs ├── 0051-0100 │ ├── 051-NQueens-Test.cs │ ├── 052-NQueens2-Test.cs │ ├── 053-MaximumSubarray-Test.cs │ ├── 054-SpiralMatrix-Test.cs │ ├── 055-JumpGame-Test.cs │ ├── 056-MergeIntervals-Test.cs │ ├── 057-InsertInterval-Test.cs │ ├── 058-LengthOfLastWord-Test.cs │ ├── 059-SpiralMatrix2-Test.cs │ ├── 060-PermutationSequence-Test.cs │ ├── 061-RotateList-Test.cs │ ├── 062-UniquePaths-Test.cs │ ├── 063-UniquePaths2-Test.cs │ ├── 064-MinimumPathSum-Test.cs │ ├── 065-ValidNumber-Test.cs │ ├── 066-PlusOne-Test.cs │ ├── 067-AddBinary-Test.cs │ ├── 068-TextJustification-Test.cs │ ├── 069-Sqrt(x)-Test.cs │ ├── 070-ClimbingStairs-Test.cs │ ├── 071-SimplifyPath-Test.cs │ ├── 072-EditDistance-Test.cs │ ├── 073-SetMatrixZeroes-Test.cs │ ├── 074-SearchA2DMatrix-Test.cs │ ├── 075-SortColors-Test.cs │ ├── 076-MinimumWindowSubstring-Test.cs │ ├── 077-Combinations-Test.cs │ ├── 078-Subsets-Test.cs │ ├── 079-WordSearch-Test.cs │ ├── 080-RemoveDuplicatesFromSortedArray2-Test.cs │ ├── 081-SearchInRotatedSortedArray2-Test.cs │ ├── 082-RemoveDuplicatesFromSortedList2-Test.cs │ ├── 083-RemoveDuplicatesFromSortedList-Test.cs │ ├── 084-LargestRectangleInHistogram-Test.cs │ ├── 085-MaximalRectangle-Test.cs │ ├── 086-PartitionList-Test.cs │ ├── 087-ScrambleString-Test.cs │ ├── 088-MergeSortedArray-Test.cs │ ├── 089-GrayCode-Test.cs │ ├── 090-Subsets2-Test.cs │ ├── 091-DecodeWays-Test.cs │ ├── 092-ReverseLinkedList2-Test.cs │ ├── 093-RestoreIPAddresses-Test.cs │ ├── 094-BinaryTreeInorderTraversal-Test.cs │ ├── 095-UniqueBinarySearchTree2-Test.cs │ ├── 096-UniqueBinarySearchTree-Test.cs │ ├── 097-InterleavingString-Test.cs │ ├── 098-ValidateBinarySearchTree-Test.cs │ ├── 099-RecoverBinarySearchTree-Test.cs │ └── 100-SameTree-Test.cs ├── 0101-0150 │ ├── 0116-PopulatingNextRightPointersInEachNode-Test.cs │ ├── 0121-BestTimeToBuyAndSellStock-Test.cs │ ├── 0122-BestTimeToBuyAndSellStock2-Test.cs │ ├── 0123-BestTimeToBuyAndSellStock3-Test.cs │ ├── 0124-BinaryTreeMaximumPathSum-Test.cs │ ├── 0125-ValidPalindrome-Test.cs │ ├── 0126-WordLadderII-Test.cs │ ├── 0127-WordLadder-Test.cs │ ├── 0128-LongestConsecutiveSequence-Test.cs │ ├── 0129-SumRootToLeafNumbersTest.cs │ ├── 0130-SurroundedRegions-Test.cs │ ├── 0131-PalindromePartitioning-Test.cs │ ├── 0133-CloneGraph-Test.cs │ ├── 0134-GasStation-Test.cs │ ├── 0136-SingleNumber-Test.cs │ ├── 0137-SingleNumberII-Test.cs │ ├── 0138-CopyListWithRandomPointer-Test.cs │ ├── 0139-WordBreak-Test.cs │ ├── 0140-WordBreakII-Test.cs │ ├── 0141-LinkedListCycle-Test.cs │ ├── 0143-ReorderList-Test.cs │ ├── 0146-LRUCache-Test.cs │ ├── 0148-SortList-Test.cs │ ├── 101-SymmetricTree-Test.cs │ ├── 102-BinaryTreeLevelOrderTraversal-Test.cs │ ├── 103-BinaryTreeZigzagLevelOrderTraversal-Test.cs │ ├── 104-MaximumDepthOfBinaryTree-Test.cs │ ├── 105-ConstructBinaryTreeFromPreorderAndInorderTraversal-Test.cs │ ├── 106-ConstructBinaryTreeFromInorderAndPostorderTraversal-Test.cs │ ├── 107-BinaryTreeLevelOrderTraversal2-Test.cs │ ├── 108-ConvertSortedArrayToBinarySearchTree-Test.cs │ ├── 109-ConvertSortedListToBinarySearchTree-Test.cs │ ├── 110-BalancedBinaryTree-Test.cs │ ├── 111-MinimumDepthOfBinaryTree-Test.cs │ ├── 112-PathSum-Test.cs │ ├── 113-PathSum2-Test.cs │ ├── 114-FlattenBinaryTreeToLinkedList-Test.cs │ ├── 115-DistinctSubsequences-Test.cs │ ├── 117-PopulatingNextRightPointersInEachNode2-Test.cs │ ├── 118-PascalsTriangle-Test.cs │ ├── 119-PascalsTriangle2-Test.cs │ └── 120-Triangle-Test.cs ├── 0151-0200 │ ├── 0151-ReverseWordsInAString-Test.cs │ ├── 0152-MaximumProductSubarray-Test.cs │ ├── 0153-FindMinimumInRotatedSortedArray-Test.cs │ ├── 0154-FindMinimumInRotatedSortedArrayII-Test.cs │ ├── 0155-MinStack-Test.cs │ ├── 0157-ReadNCharactersGivenRead4-Test.cs │ ├── 0158-ReadNCharactersGivenRead4II-Test.cs │ ├── 0159-LongestSubstringWithAtMostTwoDistinctCharacters-Test.cs │ ├── 0160-IntersectionOfTwoLinkedLists-Test.cs │ ├── 0162-FindPeakElement-Test.cs │ ├── 0165-CompareVersionNumbers-Test.cs │ ├── 0166-FractionToRecurringDecimal-Test.cs │ ├── 0167-TwoSumII-Test.cs │ ├── 0168-ExcelSheetColumnTitle-Test.cs │ ├── 0169-MajorityElement-Test.cs │ ├── 0170-TwoSumIIIDataStructureDesign-Test.cs │ ├── 0171-ExcelSheetColumnNumber-Test.cs │ ├── 0172-FactorialTrailingZeroes-Test.cs │ ├── 0173-BinarySearchTreeIterator-Test.cs │ ├── 0174-DungeonGame-Test.cs │ ├── 0179-LargestNumber-Test.cs │ ├── 0189-RotateArray-Test.cs │ ├── 0190-ReverseBits-Test.cs │ ├── 0191-NumberOf1Bits-Test.cs │ ├── 0198-HouseRobber-Test.cs │ ├── 0199-BinaryTreeRightSideView-Test.cs │ └── 0200-NumberOfIslands-Test.cs ├── 0201-0250 │ ├── 0201-BitwiseANDOfNumbersRange-Test.cs │ ├── 0202-HappyNumber-Test.cs │ ├── 0203-RemoveLinkedListElements-Test.cs │ ├── 0204-CountPrimes-Test.cs │ ├── 0205-IsomorphicStrings-Test.cs │ ├── 0206-ReverseLinkedList-Test.cs │ ├── 0207-CourseSchedule-Test.cs │ ├── 0208-ImplementTrie-Test.cs │ ├── 0209-MinimumSizeSubarraySum-Test.cs │ ├── 0210-CourseScheduleII-Test.cs │ ├── 0211-AddAndSearchWordDataStructureDesign-Test.cs │ ├── 0212-WordSearchII-Test.cs │ ├── 0213-HouseRobberII-Test.cs │ ├── 0215-KthLargestElementInAnArray-Test.cs │ ├── 0216-CombinationSumIII-Test.cs │ ├── 0217-ContainsDuplicate-Test.cs │ ├── 0218-TheSkylineProblem-Test.cs │ ├── 0219-ContainsDuplicateII-Test.cs │ ├── 0220-ContainsDuplicateIII-Test.cs │ ├── 0221-MaximalSquare-Test.cs │ ├── 0222-CountCompleteTreeNodes-Test.cs │ ├── 0224-BasicCalculator-Test.cs │ ├── 0225-ImplementStackUsingQueues-Test.cs │ ├── 0226-InvertBinaryTree-Test.cs │ ├── 0227-BasicCalculatorII-Test.cs │ ├── 0229-MajorityElementII-Test.cs │ ├── 0230-KthSmallestElementInABST-Test.cs │ ├── 0231-PowerOfTwo-Test.cs │ ├── 0232-ImplementQueueUsingStacks-Test.cs │ ├── 0234-PalindromeLinkedList-Test.cs │ ├── 0235-LowestCommonAncestorOfABinarySearchTree-Test.cs │ ├── 0236-LowestCommonAncestorOfABinaryTree-Test.cs │ ├── 0237-DeleteNodeInALinkedList-Test.cs │ ├── 0238-ProductOfArrayExceptSelf-Test.cs │ ├── 0239-SlidingWindowMaximum-Test.cs │ ├── 0240-SearchA2DMatrixII-Test.cs │ ├── 0242-ValidAnagram-Test.cs │ ├── 0243-ShortestWordDistance-Test.cs │ └── 0246-StrobogrammaticNumber-Test.cs ├── 0251-0300 │ ├── 0252-MeetingRooms-Test.cs │ ├── 0253-MeetingRoomsII-Test.cs │ ├── 0256-PaintHouse-Test.cs │ ├── 0257-BinaryTreePaths-Test.cs │ ├── 0258-AddDigits-Test.cs │ ├── 0260-SingleNumberIII-Test.cs │ ├── 0263-UglyNumber-Test.cs │ ├── 0264-UglyNumberII-Test.cs │ ├── 0266-PalindromePermutation-Test.cs │ ├── 0268-MissingNumber-Test.cs │ ├── 0269-AlienDictionary-Test.cs │ ├── 0270-ClosestBinarySearchTreeValue-Test.cs │ ├── 0271-EncodeAndDecodeStrings-Test.cs │ ├── 0273-IntegerToEnglishWords-Test.cs │ ├── 0274-HIndex-Test.cs │ ├── 0275-HIndexII-Test.cs │ ├── 0276-PaintFence-Test.cs │ ├── 0278-FirstBadVersion-Test.cs │ ├── 0279-PerfectSquares-Test.cs │ ├── 0280-WiggleSort-Test.cs │ ├── 0283-MoveZeroes-Test.cs │ ├── 0285-InorderSuccessorInBST-Test.cs │ ├── 0287-FindTheDuplicateNumber-Test.cs │ ├── 0289-GameOfLife-Test.cs │ ├── 0290-WordPattern-Test.cs │ ├── 0292-NimGame-Test.cs │ ├── 0293-FlipGame-Test.cs │ ├── 0295-FindMedianFromDataStream-Test.cs │ ├── 0297-SerializeandDeserializeBinaryTree-Test.cs │ ├── 0299-BullsAndCows-Test.cs │ └── 0300-LongestIncreasingSubsequence-Test.cs ├── 0301-0350 │ ├── 0301-RemoveInvalidParentheses-Test.cs │ ├── 0303-RangeSumQueryImmutable-Test.cs │ ├── 0305-NumberOfIslandsII-Test.cs │ ├── 0309-BestTimeToBuyAndSellStockWithCooldown-Test.cs │ ├── 0311-SparseMatrixMultiplication-Test.cs │ ├── 0312-BurstBalloons-Test.cs │ ├── 0314-BinaryTreeVerticalOrderTraversal-Test.cs │ ├── 0315-CountOfSmallerNumbersAfterSelf-Test.cs │ ├── 0316-RemoveDuplicateLetters-Test.cs │ ├── 0317-ShortestDistanceFromAllBuildings-Test.cs │ ├── 0322-CoinChange-Test.cs │ ├── 0326-PowerOfThree-Test.cs │ ├── 0327-CountOfRangeSum-Test.cs │ ├── 0328-OddEvenLinkedList-Test.cs │ ├── 0329-LongestIncreasingPathInAMatrix-Test.cs │ ├── 0332-ReconstructItinerary-Test.cs │ ├── 0336-PalindromePairs-Test.cs │ ├── 0338-CountingBits-Test.cs │ ├── 0339-NestedListWeightSum-Test.cs │ ├── 0340-LongestSubstringWithAtMostKDistinctCharacters-Test.cs │ ├── 0341-FlattenNestedListIterator-Test.cs │ ├── 0342-PowerOfFour-Test.cs │ ├── 0344-ReverseString-Test.cs │ ├── 0345-ReverseVowelsOfAString-Test.cs │ ├── 0346-MovingAverageFromDataStream-Test.cs │ ├── 0347-TopKFrequentElements-Test.cs │ ├── 0348-DesignTicTacToe-Test.cs │ ├── 0349-IntersectionOfTwoArrays-Test.cs │ └── 0350-IntersectionOfTwoArraysII-Test.cs ├── 0351-0400 │ ├── 0352-DataStreamAsDisjointIntervals-Test.cs │ ├── 0355-DesignTwitter-Test.cs │ ├── 0359-LoggerRateLimiter-Test.cs │ ├── 0362-DesignHitCounter-Test.cs │ ├── 0364-NestedListWeightSumII-Test.cs │ ├── 0366-FindLeavesOfBinaryTree-Test.cs │ ├── 0367-ValidPerfectSquare-Test.cs │ ├── 0368-LargestDivisibleSubset-Test.cs │ ├── 0370-RangeAddition-Test.cs │ ├── 0371-SumOfTwoIntegers-Test.cs │ ├── 0374-GuessNumberHigherOrLower-Test.cs │ ├── 0375-GuessNumberHigherOrLowerII-Test.cs │ ├── 0380-InsertDeleteGetRandom-Test.cs │ ├── 0381-InsertDeleteGetrandomDuplicatesAllowed-Test.cs │ ├── 0383-RansomNote-Test.cs │ ├── 0387-FirstUniqueCharacterInAString-Test.cs │ ├── 0389-FindTheDifference-Test.cs │ ├── 0392-IsSubsequence-Test.cs │ ├── 0393-UTF8Validation-Test.cs │ ├── 0394-DecodeString-Test.cs │ └── 0399-EvaluateDivision-Test.cs ├── 0401-0450 │ ├── 0401-BinaryWatch-Test.cs │ ├── 0402-RemoveKDigits-Test.cs │ ├── 0403-FrogJump-Test.cs │ ├── 0404-SumOfLeftLeaves-Test.cs │ ├── 0405-ConvertANumberToHexadecimal-Test.cs │ ├── 0406-QueueReconstructionByHeight-Test.cs │ ├── 0408-ValidWordAbbreviation-Test.cs │ ├── 0409-LongestPalindrome-Test.cs │ ├── 0410-SplitArrayLargestSum-Test.cs │ ├── 0412-FizzBuzz-Test.cs │ ├── 0414-ThirdMaximumNumber-Test.cs │ ├── 0415-AddStrings-Test.cs │ ├── 0416-PartitionEqualSubsetSum-Test.cs │ ├── 0419-BattleshipsInABoard-Test.cs │ ├── 0420-StrongPasswordChecker-Test.cs │ ├── 0421-MaximumXOROfTwoNumbersInAnArray-Test.cs │ ├── 0422-ValidWordSquare-Test.cs │ ├── 0425-WordSquares-Test.cs │ ├── 0426-ConvertBinarySearchTreeToSortedDoublyLinkedList-Test.cs │ ├── 0427-ConstructQuadTree-Test.cs │ ├── 0428-SerializeAndDeserializeNAryTree-Test.cs │ ├── 0429-NAryTreeLevelOrderTraversal-Test.cs │ ├── 0430-FlattenAMultilevelDoublyLinkedList-Test.cs │ ├── 0432-AllOOneDataStructure-Test.cs │ ├── 0434-NumberOfSegmentsInAString-Test.cs │ ├── 0435-NonOverlappingIntervals-Test.cs │ ├── 0436-FindRightInterval-Test.cs │ ├── 0437-PathSumIII-Test.cs │ ├── 0438-FindAllAnagramsInAString-Test.cs │ ├── 0441-ArrangingCoins-Test.cs │ ├── 0442-FindAllDuplicatesInAnArray-Test.cs │ ├── 0443-StringCompression-Test.cs │ ├── 0445-AddTwoNumbersII-Test.cs │ ├── 0447-NumberOfBoomerangs-Test.cs │ ├── 0448-FindAllNumbersDisappearedInAnArray-Test.cs │ ├── 0449-SerializeAndDeserializeBST-Test.cs │ └── 0450-DeleteNodeInABST-Test.cs ├── 0451-0500 │ ├── 0451-SortCharactersByFrequency-Test.cs │ ├── 0452-MinimumNumberOfArrowsToBurstBalloons-Test.cs │ ├── 0453-MinimumMovesToEqualArrayElements-Test.cs │ ├── 0455-AssignCookies-Test.cs │ ├── 0458-PoorPigs-Test.cs │ ├── 0459-RepeatedSubstringPattern-Test.cs │ ├── 0460-LFUCache-Test.cs │ ├── 0461-HammingDistance-Test.cs │ ├── 0463-IslandPerimeter-Test.cs │ ├── 0465-OptimalAccountBalancing-Test.cs │ ├── 0468-ValidateIPAddress-Test.cs │ ├── 0470-ImplementRand10UsingRand7-Test.cs │ ├── 0472-ConcatenatedWords-Test.cs │ ├── 0475-Heaters-Test.cs │ ├── 0476-NumberComplement-Test.cs │ ├── 0480-SlidingWindowMedian-Test.cs │ ├── 0482-LicenseKeyFormatting-Test.cs │ ├── 0484-FindPermutation-Test.cs │ ├── 0485-MaxConsecutiveOnes-Test.cs │ ├── 0489-RobotRoomCleaner-Test.cs │ ├── 0490-TheMaze-Test.cs │ ├── 0492-ConstructTheRectangle-Test.cs │ ├── 0493-ReversePairs-Test.cs │ ├── 0495-TeemoAttacking-Test.cs │ ├── 0496-NextGreaterElementI-Test.cs │ ├── 0497-RandomPointInNonOverlappingRectangles-Test.cs │ ├── 0498-DiagonalTraverse-Test.cs │ └── 0500-KeyboardRow-Test.cs ├── 0501-0550 │ ├── 0501-FindModeInBinarySearchTree-Test.cs │ ├── 0503-NextGreaterElementII-Test.cs │ ├── 0504-Base7-Test.cs │ ├── 0506-RelativeRanks-Test.cs │ ├── 0507-PerfectNumber-Test.cs │ ├── 0509-FibonacciNumber-Test.cs │ ├── 0510-InorderSuccessorInBSTII-Test.cs │ ├── 0513-FindBottomLeftTreeValue-Test.cs │ ├── 0515-FindLargestValueInEachTreeRow-Test.cs │ ├── 0518-CoinChange2-Test.cs │ ├── 0520-DetectCapital-Test.cs │ ├── 0521-LongestUncommonSubsequenceI-Test.cs │ ├── 0523-ContinuousSubarraySum-Test.cs │ ├── 0525-ContiguousArray-Test.cs │ ├── 0528-RandomPickWithWeight-Test.cs │ ├── 0529-Minesweeper-Test.cs │ ├── 0530-MinimumAbsoluteDifferenceInBST-Test.cs │ ├── 0532-KDiffPairsInAnArray-Test.cs │ ├── 0535-EncodeAndDecodeTinyURL-Test.cs │ ├── 0537-ComplexNumberMultiplication-Test.cs │ ├── 0538-ConvertBSTToGreaterTree-Test.cs │ ├── 0540-SingleElementInASortedArray-Test.cs │ ├── 0541-ReverseStringII-Test.cs │ ├── 0543-DiameterOfBinaryTree-Test.cs │ ├── 0544-OutputContestMatches-Test.cs │ ├── 0545-BoundaryOfBinaryTree-Test.cs │ └── 0547-FriendCircles-Test.cs ├── 0551-0600 │ ├── 0551-StudentAttendanceRecordI-Test.cs │ ├── 0552-StudentAttendanceRecordII-Test.cs │ ├── 0557-ReverseWordsInAStringIII-Test.cs │ ├── 0559-MaximumDepthOfNAryTree-Test.cs │ ├── 0560-SubarraySumEqualsK-Test.cs │ ├── 0561-ArrayPartitionI-Test.cs │ ├── 0563-BinaryTreeTilt-Test.cs │ ├── 0566-ReshapeTheMatrix-Test.cs │ ├── 0567-PermutationInString-Test.cs │ ├── 0572-SubtreeOfAnotherTree-Test.cs │ ├── 0575-DistributeCandies-Test.cs │ ├── 0581-ShortestUnsortedContinuousSubarray-Test.cs │ ├── 0582-KillProcess-Test.cs │ ├── 0588-DesignInMemoryFileSystem-Test.cs │ ├── 0589-NAryTreePreorderTraversal-Test.cs │ ├── 0590-NAryTreePostorderTraversal-Test.cs │ ├── 0594-LongestHarmoniousSubsequence-Test.cs │ ├── 0598-RangeAdditionII-Test.cs │ └── 0599-MinimumIndexSumOfTwoLists-Test.cs ├── 0601-0650 │ ├── 0604-DesignCompressedStringIterator-Test.cs │ ├── 0605-CanPlaceFlowers-Test.cs │ ├── 0606-ConstructStringFromBinaryTree-Test.cs │ ├── 0609-FindDuplicateFileInSystem-Test.cs │ ├── 0616-AddBoldTagInString-Test.cs │ ├── 0617-MergeTwoBinaryTrees-Test.cs │ ├── 0621-TaskScheduler-Test.cs │ ├── 0624-MaximumDistanceInArrays-Test.cs │ ├── 0628-MaximumProductOfThreeNumbers-Test.cs │ ├── 0633-SumOfSquareNumbers-Test.cs │ ├── 0636-ExclusiveTimeOfFunctions-Test.cs │ ├── 0637-AverageOfLevelsInBinaryTree-Test.cs │ ├── 0642-DesignSearchAutocompleteSystem-Test.cs │ ├── 0643-MaximumAverageSubarrayI-Test.cs │ ├── 0645-SetMismatch-Test.cs │ └── 0647-PalindromicSubstrings-Test.cs ├── 0651-0700 │ ├── 0653-TwoSumIVInputIsABST-Test.cs │ ├── 0654-MaximumBinaryTree-Test.cs │ ├── 0657-RobotReturnToOrigin-Test.cs │ ├── 0661-ImageSmoother-Test.cs │ ├── 0662-MaximumWidthOfBinaryTree-Test.cs │ ├── 0665-NonDecreasingArray-Test.cs │ ├── 0668-KthSmallestNumberInMultiplicationTable-Test.cs │ ├── 0669-TrimABinarySearchTree-Test.cs │ ├── 0671-SecondMinimumNodeInABinaryTree-Test.cs │ ├── 0674-LongestContinuousIncreasingSubsequence-Test.cs │ ├── 0678-ValidParenthesisString-Test.cs │ ├── 0680-ValidPalindromeII-Test.cs │ ├── 0681-NextClosestTime-Test.cs │ ├── 0682-BaseballGame-Test.cs │ ├── 0683-KEmptySlots-Test.cs │ ├── 0686-RepeatedStringMatch-Test.cs │ ├── 0687-LongestUnivaluePath-Test.cs │ ├── 0690-EmployeeImportance-Test.cs │ ├── 0692-TopKFrequentWords-Test.cs │ ├── 0693-BinaryNumberWithAlternatingBits-Test.cs │ ├── 0695-MaxAreaOfIsland-Test.cs │ ├── 0696-CountBinarySubstrings-Test.cs │ ├── 0697-DegreeOfAnArray-Test.cs │ ├── 0698-PartitionToKEqualSumSubsets-Test.cs │ └── 0700-SearchInABinarySearchTree-Test.cs ├── 0701-0750 │ ├── 0701-InsertIntoABinarySearchTree-Test.cs │ ├── 0702-SearchInASortedArrayOfUnknownSize-Test.cs │ ├── 0703-KthLargestElementInAStream-Test.cs │ ├── 0704-BinarySearch-Test.cs │ ├── 0705-DesignHashset-Test.cs │ ├── 0706-DesignHashmap-Test.cs │ ├── 0708-InsertIntoASortedCircularLinkedList-Test.cs │ ├── 0709-ToLowerCase-Test.cs │ ├── 0713-SubarrayProductLessThanK-Test.cs │ ├── 0715-RangeModule-Test.cs │ ├── 0716-MaxStack-Test.cs │ ├── 0717-1BitAnd2BitCharacters-Test.cs │ ├── 0720-LongestWordInDictionary-Test.cs │ ├── 0721-AccountsMerge-Test.cs │ ├── 0722-RemoveComments-Test.cs │ ├── 0723-CandyCrush-Test.cs │ ├── 0724-FindPivotIndex-Test.cs │ ├── 0726-NumberOfAtoms-Test.cs │ ├── 0727-MinimumWindowSubsequence-Test.cs │ ├── 0728-SelfDividingNumbers-Test.cs │ ├── 0733-FloodFill-Test.cs │ ├── 0734-SentenceSimilarity-Test.cs │ ├── 0735-AsteroidCollision-Test.cs │ ├── 0739-DailyTemperatures-Test.cs │ ├── 0742-ClosestLeafInABinaryTree-Test.cs │ ├── 0743-NetworkDelayTime-Test.cs │ ├── 0744-FindSmallestLetterGreaterThanTarget-Test.cs │ ├── 0746-MinCostClimbingStairs-Test.cs │ ├── 0747-LargestNumberAtLeastTwiceOfOthers-Test.cs │ ├── 0748-ShortestCompletingWord-Test.cs │ └── 0750-NumberOfCornerRectangles-Test.cs ├── 0751-0800 │ ├── 0751-IPToCIDR-Test.cs │ ├── 0753-CrackingtheSafe-Test.cs │ ├── 0758-BoldWordsInString-Test.cs │ ├── 0759-EmployeeFreeTime-Test.cs │ ├── 0760-FindAnagramMappings-Test.cs │ ├── 0762-PrimeNumberOfSetBitsInBinaryRepresentation-Test.cs │ ├── 0763-PartitionLabels-Test.cs │ ├── 0765-CouplesHoldingHands-Test.cs │ ├── 0766-ToeplitzMatrix-Test.cs │ ├── 0767-ReorganizeString-Test.cs │ ├── 0771-JewelsAndStones-Test.cs │ ├── 0772-BasicCalculatorIII-Test.cs │ ├── 0773-SlidingPuzzle-Test.cs │ ├── 0777-SwapAdjacentInLRString-Test.cs │ ├── 0780-ReachingPoints-Test.cs │ ├── 0783-MinimumDistanceBetweenBSTNodes-Test.cs │ ├── 0784-LetterCasePermutation-Test.cs │ ├── 0787-CheapestFlightsWithinKStops-Test.cs │ ├── 0788-RotatedDigits-Test.cs │ ├── 0791-CustomSortString-Test.cs │ ├── 0794-ValidTicTacToeState-Test.cs │ ├── 0796-RotateString-Test.cs │ ├── 0797-AllPathsFromSourceToTarget-Test.cs │ └── 0800-SimilarRGBColor-Test.cs ├── 0801-0850 │ ├── 0804-UniqueMorseCodeWords-Test.cs │ ├── 0806-NumberOfLinesToWriteString-Test.cs │ ├── 0807-MaxIncreaseToKeepCitySkyline-Test.cs │ ├── 0809-ExpressiveWords-Test.cs │ ├── 0811-SubdomainVisitCount-Test.cs │ ├── 0812-LargestTriangleArea-Test.cs │ ├── 0814-BinaryTreePruning-Test.cs │ ├── 0818-RaceCar-Test.cs │ ├── 0819-MostCommonWord-Test.cs │ ├── 0821-ShortestDistanceToACharacter-Test.cs │ ├── 0824-GoatLatin-Test.cs │ ├── 0829-ConsecutiveNumbersSum-Test.cs │ ├── 0830-PositionsOfLargeGroups-Test.cs │ ├── 0832-FlippingAnImage-Test.cs │ ├── 0833-FindAndReplaceInString-Test.cs │ ├── 0835-ImageOverlap-Test.cs │ ├── 0836-RectangleOverlap-Test.cs │ ├── 0837-New21Game-Test.cs │ ├── 0840-MagicSquaresInGrid-Test.cs │ ├── 0841-KeysAndRooms-Test.cs │ ├── 0843-GuesstheWord-Test.cs │ ├── 0844-BackspaceStringCompare-Test.cs │ ├── 0846-HandOfStraights-Test.cs │ └── 0849-MaximizeDistanceToClosestPerson-Test.cs ├── 0851-0900 │ ├── 0852-PeakIndexInAMountainArray-Test.cs │ ├── 0856-ScoreOfParentheses-Test.cs │ ├── 0857-MinimumCostToHireKWorkers-Test.cs │ ├── 0859-BuddyStrings-Test.cs │ ├── 0860-LemonadeChange-Test.cs │ ├── 0861-ScoreAfterFlippingMatrix-Test.cs │ ├── 0863-AllNodesDistanceKInBinaryTree-Test.cs │ ├── 0865-SmallestSubtreeWithAllTheDeepestNodes-Test.cs │ ├── 0867-TransposeMatrix-Test.cs │ ├── 0868-BinaryGap-Test.cs │ ├── 0872-LeafSimilarTrees-Test.cs │ ├── 0874-WalkingRobotSimulation-Test.cs │ ├── 0876-MiddleOfTheLinkedList-Test.cs │ ├── 0877-StoneGame-Test.cs │ ├── 0883-ProjectionAreaOf3DShapes-Test.cs │ ├── 0884-UncommonWordsFromTwoSentences-Test.cs │ ├── 0885-SpiralMatrixIII-Test.cs │ ├── 0886-PossibleBipartition-Test.cs │ ├── 0888-FairCandySwap-Test.cs │ ├── 0889-ConstructBinaryTreeFromPreorderAndPostorderTraversal-Test.cs │ ├── 0890-FindAndReplacePattern-Test.cs │ ├── 0892-SurfaceAreaOf3DShapes-Test.cs │ ├── 0893-GroupsOfSpecialEquivalentStrings-Test.cs │ ├── 0894-AllPossibleFullBinaryTrees-Test.cs │ ├── 0895-MaximumFrequencyStack-Test.cs │ ├── 0896-MonotonicArray-Test.cs │ └── 0897-IncreasingOrderSearchTree-Test.cs ├── 0901-0950 │ ├── 0901-OnlineStockSpan-Test.cs │ ├── 0904-FruitIntoBaskets-Test.cs │ ├── 0905-SortArrayByParity-Test.cs │ ├── 0908-SmallestRangeI-Test.cs │ ├── 0912-SortAnArray-Test.cs │ ├── 0913-CatAndMouse-Test.cs │ ├── 0914-XOfAKindInADeckOfCards-Test.cs │ ├── 0917-ReverseOnlyLetters-Test.cs │ ├── 0918-MaximumSumCircularSubarray-Test.cs │ ├── 0921-MinimumAddToMakeParenthesesValid-Test.cs │ ├── 0922-SortArrayByParityII-Test.cs │ ├── 0925-LongPressedName-Test.cs │ ├── 0929-UniqueEmailAddresses-Test.cs │ ├── 0931-MinimumFallingPathSum-Test.cs │ ├── 0933-NumberOfRecentCalls-Test.cs │ ├── 0937-ReorderDataInLogFiles-Test.cs │ ├── 0938-RangeSumOfBST-Test.cs │ ├── 0939-MinimumAreaRectangle-Test.cs │ ├── 0941-ValidMountainArray-Test.cs │ ├── 0942-DIStringMatch-Test.cs │ ├── 0944-DeleteColumnsToMakeSorted-Test.cs │ ├── 0946-ValidateStackSequences-Test.cs │ ├── 0947-MostStonesRemovedWithSameRoworColumn-Test.cs │ ├── 0949-LargestTimeForGivenDigits-Test.cs │ └── 0950-RevealCardsInIncreasingOrder-Test.cs ├── 0951-1000 │ ├── 0951-FlipEquivalentBinaryTrees-Test.cs │ ├── 0952-LargestComponentSizeByCommonFactor-Test.cs │ ├── 0953-VerifyingAnAlienDictionary-Test.cs │ ├── 0957-PrisonCellsAfterNDays-Test.cs │ ├── 0959-RegionsCutBySlashes-Test.cs │ ├── 0961-NRepeatedElementInSize2NArray-Test.cs │ ├── 0965-UnivaluedBinaryTree-Test.cs │ ├── 0967-NumbersWithSameConsecutiveDifferences-Test.cs │ ├── 0969-PancakeSorting-Test.cs │ ├── 0970-PowerfulIntegers-Test.cs │ ├── 0973-KClosestPointsToOrigin-Test.cs │ ├── 0975-OddEvenJump-Test.cs │ ├── 0976-LargestPerimeterTriangle-Test.cs │ ├── 0977-SquaresOfASortedArray-Test.cs │ ├── 0979-DistributeCoinsInBinaryTree-Test.cs │ ├── 0980-UniquePathsIII-Test.cs │ ├── 0981-TimeBasedKeyValueStore-Test.cs │ ├── 0983-MinimumCostForTickets-Test.cs │ ├── 0985-SumOfEvenNumbersAfterQueries-Test.cs │ ├── 0986-IntervalListIntersections-Test.cs │ ├── 0987-VerticalOrderTraversalOfABinaryTree-Test.cs │ ├── 0989-AddToArrayFormOfInteger-Test.cs │ ├── 0993-CousinsInBinaryTree-Test.cs │ ├── 0994-RottingOranges-Test.cs │ ├── 0997-FindTheTownJudge-Test.cs │ ├── 0998-MaximumBinaryTreeII-Test.cs │ └── 0999-AvailableCapturesForRook-Test.cs ├── 1001-1050 │ ├── 1002-FindCommonCharacters-Test.cs │ ├── 1005-MaximizeSumOfArrayAfterKNegations-Test.cs │ ├── 1007-MinimumDominoRotationsForEqualRow-Test.cs │ ├── 1008-ConstructBinarySearchTreeFromPreorderTraversal-Test.cs │ ├── 1009-ComplementOfBase10Integer-Test.cs │ ├── 1010-PairsOfSongsWithTotalDurationsDivisibleBy60-Test.cs │ ├── 1011-CapacityToShipPackagesWithinDDays-Test.cs │ ├── 1013-PartitionArrayIntoThreePartsWithEqualSum-Test.cs │ ├── 1018-BinaryPrefixDivisibleBy5-Test.cs │ ├── 1021-RemoveOutermostParentheses-Test.cs │ ├── 1022-SumOfRootToLeafBinaryNumbers-Test.cs │ ├── 1024-VideoStitching-Test.cs │ ├── 1025-DivisorGame-Test.cs │ ├── 1026-MaximumDifferenceBetweenNodeAndAncestor-Test.cs │ ├── 1029-TwoCityScheduling-Test.cs │ ├── 1030-MatrixCellsInDistanceOrder-Test.cs │ ├── 1032-StreamOfCharacters-Test.cs │ ├── 1033-MovingStonesUntilConsecutive-Test.cs │ ├── 1035-UncrossedLines-Test.cs │ ├── 1037-ValidBoomerang-Test.cs │ ├── 1038-BinarySearchTreeToGreaterSumTree-Test.cs │ ├── 1041-RobotBoundedInCircle-Test.cs │ ├── 1042-FlowerPlantingWithNoAdjacent-Test.cs │ ├── 1043-PartitionArrayForMaximumSum-Test.cs │ ├── 1044-LongestDuplicateSubstring-Test.cs │ ├── 1046-LastStoneWeight-Test.cs │ ├── 1047-RemoveAllAdjacentDuplicatesInString-Test.cs │ └── 1048-LongestStringChain-Test.cs ├── 1051-1100 │ ├── 1051-HeightChecker-Test.cs │ ├── 1055-ShortestWaytoFormString-Test.cs │ ├── 1056-ConfusingNumber-Test.cs │ ├── 1057-CampusBikes-Test.cs │ ├── 1061-LexicographicallySmallestEquivalentString-Test.cs │ ├── 1062-LongestRepeatingSubstring-Test.cs │ ├── 1064-FixedPoint-Test.cs │ ├── 1065-IndexPairsOfAString-Test.cs │ ├── 1066-CampusBikesII-Test.cs │ ├── 1071-GreatestCommonDivisorOfStrings-Test.cs │ ├── 1072-FlipColumnsForMaximumNumberOfEqualRows-Test.cs │ ├── 1078-OccurrencesAfterBigram-Test.cs │ ├── 1079-LetterTilePossibilities-Test.cs │ ├── 1081-SmallestSubsequenceOfDistinctCharacters-Test.cs │ ├── 1085-SumOfDigitsInTheMinimumNumber-Test.cs │ ├── 1086-HighFive-Test.cs │ ├── 1087-BraceExpansion-Test.cs │ ├── 1089-DuplicateZeros-Test.cs │ ├── 1094-CarPooling-Test.cs │ ├── 1096-BraceExpansionII-Test.cs │ ├── 1099-TwoSumLessThanK-Test.cs │ └── 1100-FindKLengthSubstringsWithNoRepeatedCharacters-Test.cs ├── 1101-1150 │ ├── 1101-TheEarliestMomentWhenEveryoneBecomeFriends-Test.cs │ ├── 1102-PathWithMaximumMinimumValue-Test.cs │ ├── 1103-DistributeCandiesToPeople-Test.cs │ ├── 1104-PathInZigzagLabelledBinaryTree-Test.cs │ ├── 1108-DefangingAnIPAddress-Test.cs │ ├── 1110-DeleteNodesAndReturnForest-Test.cs │ ├── 1111-MaximumNestingDepthOfTwoValidParenthesesStrings-Test.cs │ ├── 1118-NumberOfDaysInAMonth-Test.cs │ ├── 1119-RemoveVowelsFromAString-Test.cs │ ├── 1120-MaximumAverageSubtree-Test.cs │ ├── 1122-RelativeSortArray-Test.cs │ ├── 1123-LowestCommonAncestorOfDeepestLeaves-Test.cs │ ├── 1128-NumberOfEquivalentDominoPairs-Test.cs │ ├── 1130-MinimumCostTreeFromLeafValues-Test.cs │ ├── 1133-LargestUniqueNumber-Test.cs │ ├── 1134-ArmstrongNumber-Test.cs │ ├── 1137-NThTribonacciNumber-Test.cs │ ├── 1140-StoneGameII-Test.cs │ ├── 1143-LongestCommonSubsequence-Test.cs │ └── 1150-CheckIfANumberIsMajorityElementInASortedArray-Test.cs ├── 1151-1200 │ ├── 1152-AnalyzeUserWebsiteVisitPattern-Test.cs │ ├── 1154-DayOfTheYear-Test.cs │ ├── 1160-FindWordsThatCanBeFormedByCharacters-Test.cs │ ├── 1161-MaximumLevelSumOfABinaryTree-Test.cs │ ├── 1165-SingleRowKeyboard-Test.cs │ ├── 1167-MinimumCostToConnectSticks-Test.cs │ ├── 1170-CompareStringsByFrequencyOfTheSmallestCharacter-Test.cs │ ├── 1175-PrimeArrangements-Test.cs │ ├── 1176-DietPlanPerformance-Test.cs │ ├── 1180-CountSubstringsWithOnlyOneDistinctLetter-Test.cs │ ├── 1184-DistanceBetweenBusStops-Test.cs │ ├── 1185-DayOfTheWeek-Test.cs │ ├── 1189-MaximumNumberOfBalloons-Test.cs │ ├── 1190-ReverseSubstringsBetweenEachPairOfParentheses-Test.cs │ ├── 1192-CriticalConnectionsInANetwork-Test.cs │ ├── 1196-HowManyApplesCanYouPutIntoTheBasket-Test.cs │ ├── 1197-MinimumKnightMoves-Test.cs │ ├── 1198-FindSmallestCommonElementInAllRows-Test.cs │ └── 1200-MinimumAbsoluteDifference-Test.cs ├── 1201-1250 │ ├── 1207-UniqueNumberOfOccurrences-Test.cs │ ├── 1213-IntersectionOfThreeSortedArrays-Test.cs │ ├── 1214-TwoSumBsts-Test.cs │ ├── 1217-PlayWithChips-Test.cs │ ├── 1219-PathWithMaximumGold-Test.cs │ ├── 1221-SplitAStringInBalancedStrings-Test.cs │ ├── 1222-QueensThatCanAttackTheKing-Test.cs │ ├── 1227-AirplaneSeatAssignmentProbability-Test.cs │ ├── 1228-MissingNumberInArithmeticProgression-Test.cs │ ├── 1229-MeetingScheduler-Test.cs │ ├── 1232-CheckIfItIsAStraightLine-Test.cs │ ├── 1235-MaximumProfitInJobScheduling-Test.cs │ ├── 1236-WebCrawler-Test.cs │ ├── 1237-FindPositiveIntegerSolutionForAGivenEquation-Test.cs │ ├── 1238-CircularPermutationInBinaryRepresentation-Test.cs │ ├── 1242-WebCrawlerMultithreaded-Test.cs │ ├── 1243-ArrayTransformation-Test.cs │ ├── 1245-TreeDiameter-Test.cs │ ├── 1247-MinimumSwapsToMakeStringsEqual-Test.cs │ └── 1249-MinimumRemoveToMakeValidParentheses-Test.cs ├── 1251-1300 │ ├── 1252-CellsWithOddValuesInAMatrix-Test.cs │ ├── 1254-NumberOfClosedIslands-Test.cs │ ├── 1256-EncodeNumber-Test.cs │ ├── 1258-SynonymousSentences-Test.cs │ ├── 1260-Shift2DGrid-Test.cs │ ├── 1261-FindElementsInAContaminatedBinaryTree-Test.cs │ ├── 1265-PrintImmutableLinkedListInReverse-Test.cs │ ├── 1266-MinimumTimeVisitingAllPoints-Test.cs │ ├── 1268-SearchSuggestionsSystem-Test.cs │ ├── 1271-Hexspeak-Test.cs │ ├── 1273-DeleteTreeNodes-Test.cs │ ├── 1275-FindWinnerOnATicTacToeGame-Test.cs │ ├── 1277-CountSquareSubmatricesWithAllOnes-Test.cs │ ├── 1281-SubtractTheProductAndSumOfDigitsOfAnInteger-Test.cs │ ├── 1282-GroupThePeopleGivenTheGroupSizeTheyBelongTo-Test.cs │ ├── 1286-IteratorForCombination-Test.cs │ ├── 1287-ElementAppearingMoreThan25InSortedArray-Test.cs │ ├── 1288-RemoveCoveredIntervals-Test.cs │ ├── 1290-ConvertBinaryNumberInALinkedListToInteger-Test.cs │ ├── 1291-SequentialDigits-Test.cs │ ├── 1295-FindNumbersWithEvenNumberOfDigits-Test.cs │ ├── 1296-DivideArrayInSetsOfKConsecutiveNumbers-Test.cs │ └── 1299-ReplaceElementsWithGreatestElementOnRightSide-Test.cs ├── 1301-1350 │ ├── 1302-DeepestLeavesSum-Test.cs │ ├── 1304-FindNUniqueIntegersSumUpToZero-Test.cs │ ├── 1305-AllElementsInTwoBinarySearchTrees-Test.cs │ ├── 1306-JumpGameIII-Test.cs │ ├── 1309-DecryptStringFromAlphabetToIntegerMapping-Test.cs │ ├── 1310-XORQueriesOfASubarray-Test.cs │ ├── 1313-DecompressRunLengthEncodedList-Test.cs │ ├── 1314-MatrixBlockSum-Test.cs │ ├── 1315-SumOfNodesWithEvenValuedGrandparent-Test.cs │ ├── 1317-ConvertIntegerToTheSumOfTwoNoZeroIntegers-Test.cs │ ├── 1318-MinimumFlipsToMakeAORBEqualToC-Test.cs │ ├── 1323-Maximum69Numberr-Test.cs │ ├── 1325-DeleteLeavesWithAGivenValue-Test.cs │ ├── 1326-MinimumNumberOfTapsToOpenToWaterAGarden-Test.cs │ ├── 1329-SortTheMatrixDiagonally-Test.cs │ ├── 1331-RankTransformOfAnArray-Test.cs │ ├── 1332-RemovePalindromicSubsequences-Test.cs │ ├── 1337-TheKWeakestRowsInAMatrix-Test.cs │ ├── 1338-ReduceArraySizeToTheHalf-Test.cs │ ├── 1342-NumberOfStepsToReduceANumberToZero-Test.cs │ ├── 1343-NumberOfSubArraysOfSizeKAndAverageGreaterThanOrEqualToThreshold-Test.cs │ ├── 1344-AngleBetweenHandsOfAClock-Test.cs │ ├── 1346-CheckIfNAndItsDoubleExist-Test.cs │ └── 1347-MinimumNumberOfStepsToMakeTwoStringsAnagram-Test.cs ├── 1351-1400 │ ├── 1351-CountNegativeNumbersInASortedMatrix-Test.cs │ ├── 1353-MaximumNumberOfEventsThatCanBeAttended-Test.cs │ ├── 1356-SortIntegersByTheNumberOf1Bits-Test.cs │ ├── 1357-ApplyDiscountEveryNOrders-Test.cs │ ├── 1360-NumberOfDaysBetweenTwoDates-Test.cs │ ├── 1365-HowManyNumbersAreSmallerThanTheCurrentNumber-Test.cs │ ├── 1370-IncreasingDecreasingString-Test.cs │ ├── 1374-GenerateAStringWithCharactersThatHaveOddCounts-Test.cs │ ├── 1375-BulbSwitcherIII-Test.cs │ ├── 1379-FindACorrespondingNodeOfABinaryTreeInACloneOfThatTree-Test.cs │ ├── 1380-LuckyNumbersInAMatrix-Test.cs │ ├── 1381-DesignAStackWithIncrementOperation-Test.cs │ ├── 1382-BalanceABinarySearchTree-Test.cs │ ├── 1385-FindTheDistanceValueBetweenTwoArrays-Test.cs │ ├── 1387-SortIntegersByThePowerValue-Test.cs │ ├── 1389-CreateTargetArrayInTheGivenOrder-Test.cs │ ├── 1394-FindLuckyIntegerInAnArray-Test.cs │ ├── 1395-CountNumberOfTeams-Test.cs │ ├── 1396-DesignUndergroundSystem-Test.cs │ ├── 1399-CountLargestGroup-Test.cs │ └── 1400-ConstructKPalindromeStrings-Test.cs ├── 1401-1450 │ ├── 1403-MinimumSubsequenceInNonIncreasingOrder-Test.cs │ ├── 1408-StringMatchingInAnArray-Test.cs │ ├── 1409-QueriesOnAPermutationWithKey-Test.cs │ ├── 1413-MinimumValueToGetPositiveStepByStepSum-Test.cs │ ├── 1414-FindTheMinimumNumberOfFibonacciNumbersWhoseSumIsK-Test.cs │ ├── 1415-TheKThLexicographicalStringOfAllHappyStringsOfLengthN-Test.cs │ ├── 1417-ReformatTheString-Test.cs │ ├── 1418-DisplayTableOfFoodOrdersInARestaurant-Test.cs │ ├── 1422-MaximumScoreAfterSplittingAString-Test.cs │ ├── 1426-CountingElements-Test.cs │ ├── 1427-PerformStringShifts-Test.cs │ ├── 1428-LeftmostColumnWithAtLeastAOne-Test.cs │ ├── 1429-FirstUniqueNumber-Test.cs │ ├── 1430-CheckIfAStringIsAValidSequenceFromRootToLeavesPathInABinaryTree-Test.cs │ ├── 1431-KidsWithTheGreatestNumberOfCandies-Test.cs │ ├── 1433-CheckIfAStringCanBreakAnotherString-Test.cs │ ├── 1436-DestinationCity-Test.cs │ ├── 1437-CheckIfAll1SAreAtLeastLengthKPlacesAway-Test.cs │ ├── 1441-BuildAnArrayWithStackOperations-Test.cs │ ├── 1442-CountTripletsThatCanFormTwoArraysOfEqualXOR-Test.cs │ ├── 1446-ConsecutiveCharacters-Test.cs │ ├── 1447-SimplifiedFractions-Test.cs │ ├── 1448-CountGoodNodesInBinaryTree-Test.cs │ └── 1450-NumberOfStudentsDoingHomeworkAtAGivenTime-Test.cs ├── 1451-1500 │ ├── 1455-CheckIfAWordOccursAsAPrefixOfAnyWordInASentence-Test.cs │ ├── 1457-PseudoPalindromicPathsInABinaryTree-Test.cs │ ├── 1460-MakeTwoArraysEqualByReversingSubArrays-Test.cs │ ├── 1464-MaximumProductOfTwoElementsInAnArray-Test.cs │ ├── 1466-ReorderRoutesToMakeAllPathsLeadToTheCityZero-Test.cs │ ├── 1469-FindAllTheLonelyNodes-Test.cs │ ├── 1470-ShuffleTheArray-Test.cs │ ├── 1472-DesignBrowserHistory-Test.cs │ ├── 1474-DeleteNNodesAfterMNodesOfALinkedList-Test.cs │ ├── 1475-FinalPricesWithASpecialDiscountInAShop-Test.cs │ ├── 1476-SubrectangleQueries-Test.cs │ ├── 1480-RunningSumOf1DArray-Test.cs │ ├── 1485-CloneBinaryTreeWithRandomPointer-Test.cs │ ├── 1486-XOROperationInAnArray-Test.cs │ ├── 1490-CloneNAryTree-Test.cs │ ├── 1491-AverageSalaryExcludingTheMinimumAndMaximumSalary-Test.cs │ ├── 1492-TheKthFactorOfN-Test.cs │ └── 1496-PathCrossing-Test.cs ├── 1501-1550 │ ├── 1502-CanMakeArithmeticProgressionFromSequence-Test.cs │ ├── 1504-CountSubmatricesWithAllOnes-Test.cs │ ├── 1506-FindRootOfNAryTree-Test.cs │ ├── 1507-ReformatDate-Test.cs │ ├── 1508-RangeSumOfSortedSubarraySums-Test.cs │ ├── 1512-NumberOfGoodPairs-Test.cs │ └── 1518-WaterBottles-Test.cs ├── AssertHelper.cs ├── LeetCode.Test.csproj ├── Properties │ └── AssemblyInfo.cs └── TestHelper.cs ├── LeetCode.sln ├── LeetCode ├── 0001-0050 │ ├── 001-TwoSum.cs │ ├── 002-AddTwoNumbers.cs │ ├── 003-LongestSubstringWithoutRepeatingCharacters.cs │ ├── 004-MedianOfTwoSortedArrays.cs │ ├── 005-LongestPalindromicSubstring.cs │ ├── 006-ZigZagConversion.cs │ ├── 007-ReverseInteger.cs │ ├── 008-StringToInteger(atoi).cs │ ├── 009-PalindromeNumber.cs │ ├── 010-RegularExpressionMatching.cs │ ├── 011-ContainerWithMostWater.cs │ ├── 012-IntegerToRoman.cs │ ├── 013-RomanToInteger.cs │ ├── 014-LongestCommonPrefix.cs │ ├── 015-3Sum.cs │ ├── 016-3SumClosest.cs │ ├── 017-LetterCombinationsOfAPhoneNumber.cs │ ├── 018-4Sum.cs │ ├── 019-RemoveNthNodeFromEndOfList.cs │ ├── 020-ValidParentheses.cs │ ├── 021-MergeTwoSortedLists.cs │ ├── 022-GenerateParentheses.cs │ ├── 023-MergeKSortedLists.cs │ ├── 024-SwapNodesInPairs.cs │ ├── 025-ReverseNodesInKGroup.cs │ ├── 026-RemoveDuplicatesFromSortedArray.cs │ ├── 027-RemoveElement.cs │ ├── 028-ImplementStrStr.cs │ ├── 029-DivideTwoIntegers.cs │ ├── 030-SubstringWithConcatenationOfAllWords.cs │ ├── 031-NextPermutation.cs │ ├── 032-LongestValidParentheses.cs │ ├── 033-SearchInRotatedSortedArray.cs │ ├── 034-SearchForARange.cs │ ├── 035-SearchInsertPosition.cs │ ├── 036-ValidSudoku.cs │ ├── 037-SudokuSolver.cs │ ├── 038-CountAndSay.cs │ ├── 039-CombinationSum.cs │ ├── 040-CombinationSum2.cs │ ├── 041-FirstMissingPositive.cs │ ├── 042-TrappingRainWater.cs │ ├── 043-MultiplyStrings.cs │ ├── 044-WildcardMatching.cs │ ├── 045-JumpGame2.cs │ ├── 046-Permutations.cs │ ├── 047-Permutations2.cs │ ├── 048-RotateImage.cs │ ├── 049-GroupAnagrams.cs │ └── 050-Pow.cs ├── 0051-0100 │ ├── 051-NQueens.cs │ ├── 052-NQueens2.cs │ ├── 053-MaximumSubarray.cs │ ├── 054-SpiralMatrix.cs │ ├── 055-JumpGame.cs │ ├── 056-MergeIntervals.cs │ ├── 057-InsertInterval.cs │ ├── 058-LengthOfLastWord.cs │ ├── 059-SpiralMatrix2.cs │ ├── 060-PermutationSequence.cs │ ├── 061-RotateList.cs │ ├── 062-UniquePaths.cs │ ├── 063-UniquePaths2.cs │ ├── 064-MinimumPathSum.cs │ ├── 065-ValidNumber.cs │ ├── 066-PlusOne.cs │ ├── 067-AddBinary.cs │ ├── 068-TextJustification.cs │ ├── 069-Sqrt(x).cs │ ├── 070-ClimbingStairs.cs │ ├── 071-SimplifyPath.cs │ ├── 072-EditDistance.cs │ ├── 073-SetMatrixZeroes.cs │ ├── 074-SearchA2DMatrix.cs │ ├── 075-SortColors.cs │ ├── 076-MinimumWindowSubstring.cs │ ├── 077-Combinations.cs │ ├── 078-Subsets.cs │ ├── 079-WordSearch.cs │ ├── 080-RemoveDuplicatesFromSortedArray2.cs │ ├── 081-SearchInRotatedSortedArray2.cs │ ├── 082-RemoveDuplicatesFromSortedList2.cs │ ├── 083-RemoveDuplicatesFromSortedList.cs │ ├── 084-LargestRectangleInHistogram.cs │ ├── 085-MaximalRectangle.cs │ ├── 086-PartitionList.cs │ ├── 087-ScrambleString.cs │ ├── 088-MergeSortedArray.cs │ ├── 089-GrayCode.cs │ ├── 090-Subsets2.cs │ ├── 091-DecodeWays.cs │ ├── 092-ReverseLinkedList2.cs │ ├── 093-RestoreIPAddresses.cs │ ├── 094-BinaryTreeInorderTraversal.cs │ ├── 095-UniqueBinarySearchTree2.cs │ ├── 096-UniqueBinarySearchTree.cs │ ├── 097-InterleavingString.cs │ ├── 098-ValidateBinarySearchTree.cs │ ├── 099-RecoverBinarySearchTree.cs │ └── 100-SameTree.cs ├── 0101-0150 │ ├── 0116-PopulatingNextRightPointersInEachNode.cs │ ├── 0117-PopulatingNextRightPointersInEachNode2.cs │ ├── 0121-BestTimeToBuyAndSellStock.cs │ ├── 0122-BestTimeToBuyAndSellStock2.cs │ ├── 0123-BestTimeToBuyAndSellStock3.cs │ ├── 0124-BinaryTreeMaximumPathSum.cs │ ├── 0125-ValidPalindrome.cs │ ├── 0126-WordLadderII.cs │ ├── 0127-WordLadder.cs │ ├── 0128-LongestConsecutiveSequence.cs │ ├── 0129-SumRootToLeafNumbers.cs │ ├── 0130-SurroundedRegions.cs │ ├── 0131-PalindromePartitioning.cs │ ├── 0133-CloneGraph.cs │ ├── 0134-GasStation.cs │ ├── 0136-SingleNumber.cs │ ├── 0137-SingleNumberII.cs │ ├── 0138-CopyListWithRandomPointer.cs │ ├── 0139-WordBreak.cs │ ├── 0140-WordBreakII.cs │ ├── 0141-LinkedListCycle.cs │ ├── 0143-ReorderList.cs │ ├── 0146-LRUCache.cs │ ├── 0148-SortList.cs │ ├── 101-SymmetricTree.cs │ ├── 102-BinaryTreeLevelOrderTraversal.cs │ ├── 103-BinaryTreeZigzagLevelOrderTraversal.cs │ ├── 104-MaximumDepthOfBinaryTree.cs │ ├── 105-ConstructBinaryTreeFromPreorderAndInorderTraversal.cs │ ├── 106-ConstructBinaryTreeFromInorderAndPostorderTraversal.cs │ ├── 107-BinaryTreeLevelOrderTraversal2.cs │ ├── 108-ConvertSortedArrayToBinarySearchTree.cs │ ├── 109-ConvertSortedListToBinarySearchTree.cs │ ├── 110-BalancedBinaryTree.cs │ ├── 111-MinimumDepthOfBinaryTree.cs │ ├── 112-PathSum.cs │ ├── 113-PathSum2.cs │ ├── 114-FlattenBinaryTreeToLinkedList.cs │ ├── 115-DistinctSubsequences.cs │ ├── 118-PascalsTriangle.cs │ ├── 119-PascalsTriangle2.cs │ └── 120-Triangle.cs ├── 0151-0200 │ ├── 0151-ReverseWordsInAString.cs │ ├── 0152-MaximumProductSubarray.cs │ ├── 0153-FindMinimumInRotatedSortedArray.cs │ ├── 0154-FindMinimumInRotatedSortedArrayII.cs │ ├── 0155-MinStack.cs │ ├── 0157-ReadNCharactersGivenRead4.cs │ ├── 0158-ReadNCharactersGivenRead4II.cs │ ├── 0159-LongestSubstringWithAtMostTwoDistinctCharacters.cs │ ├── 0160-IntersectionOfTwoLinkedLists.cs │ ├── 0162-FindPeakElement.cs │ ├── 0165-CompareVersionNumbers.cs │ ├── 0166-FractionToRecurringDecimal.cs │ ├── 0167-TwoSumII.cs │ ├── 0168-ExcelSheetColumnTitle.cs │ ├── 0169-MajorityElement.cs │ ├── 0170-TwoSumIIIDataStructureDesign.cs │ ├── 0171-ExcelSheetColumnNumber.cs │ ├── 0172-FactorialTrailingZeroes.cs │ ├── 0173-BinarySearchTreeIterator.cs │ ├── 0174-DungeonGame.cs │ ├── 0179-LargestNumber.cs │ ├── 0189-RotateArray.cs │ ├── 0190-ReverseBits.cs │ ├── 0191-NumberOf1Bits.cs │ ├── 0198-HouseRobber.cs │ ├── 0199-BinaryTreeRightSideView.cs │ └── 0200-NumberOfIslands.cs ├── 0201-0250 │ ├── 0201-BitwiseANDOfNumbersRange.cs │ ├── 0202-HappyNumber.cs │ ├── 0203-RemoveLinkedListElements.cs │ ├── 0204-CountPrimes.cs │ ├── 0205-IsomorphicStrings.cs │ ├── 0206-ReverseLinkedList.cs │ ├── 0207-CourseSchedule.cs │ ├── 0208-ImplementTrie.cs │ ├── 0209-MinimumSizeSubarraySum.cs │ ├── 0210-CourseScheduleII.cs │ ├── 0211-AddAndSearchWordDataStructureDesign.cs │ ├── 0212-WordSearchII.cs │ ├── 0213-HouseRobberII.cs │ ├── 0215-KthLargestElementInAnArray.cs │ ├── 0216-CombinationSumIII.cs │ ├── 0217-ContainsDuplicate.cs │ ├── 0218-TheSkylineProblem.cs │ ├── 0219-ContainsDuplicateII.cs │ ├── 0220-ContainsDuplicateIII.cs │ ├── 0221-MaximalSquare.cs │ ├── 0222-CountCompleteTreeNodes.cs │ ├── 0224-BasicCalculator.cs │ ├── 0225-ImplementStackUsingQueues.cs │ ├── 0226-InvertBinaryTree.cs │ ├── 0227-BasicCalculatorII.cs │ ├── 0229-MajorityElementII.cs │ ├── 0230-KthSmallestElementInABST.cs │ ├── 0231-PowerOfTwo.cs │ ├── 0232-ImplementQueueUsingStacks.cs │ ├── 0234-PalindromeLinkedList.cs │ ├── 0235-LowestCommonAncestorOfABinarySearchTree.cs │ ├── 0236-LowestCommonAncestorOfABinaryTree.cs │ ├── 0237-DeleteNodeInALinkedList.cs │ ├── 0238-ProductOfArrayExceptSelf.cs │ ├── 0239-SlidingWindowMaximum.cs │ ├── 0240-SearchA2DMatrixII.cs │ ├── 0242-ValidAnagram.cs │ ├── 0243-ShortestWordDistance.cs │ └── 0246-StrobogrammaticNumber.cs ├── 0251-0300 │ ├── 0252-MeetingRooms.cs │ ├── 0253-MeetingRoomsII.cs │ ├── 0256-PaintHouse.cs │ ├── 0257-BinaryTreePaths.cs │ ├── 0258-AddDigits.cs │ ├── 0260-SingleNumberIII.cs │ ├── 0263-UglyNumber.cs │ ├── 0264-UglyNumberII.cs │ ├── 0266-PalindromePermutation.cs │ ├── 0268-MissingNumber.cs │ ├── 0269-AlienDictionary.cs │ ├── 0270-ClosestBinarySearchTreeValue.cs │ ├── 0271-EncodeAndDecodeStrings.cs │ ├── 0273-IntegerToEnglishWords.cs │ ├── 0274-HIndex.cs │ ├── 0275-HIndexII.cs │ ├── 0276-PaintFence.cs │ ├── 0278-FirstBadVersion.cs │ ├── 0279-PerfectSquares.cs │ ├── 0280-WiggleSort.cs │ ├── 0283-MoveZeroes.cs │ ├── 0285-InorderSuccessorInBST.cs │ ├── 0287-FindTheDuplicateNumber.cs │ ├── 0289-GameOfLife.cs │ ├── 0290-WordPattern.cs │ ├── 0292-NimGame.cs │ ├── 0293-FlipGame.cs │ ├── 0295-FindMedianFromDataStream.cs │ ├── 0297-SerializeandDeserializeBinaryTree.cs │ ├── 0299-BullsAndCows.cs │ └── 0300-LongestIncreasingSubsequence.cs ├── 0301-0350 │ ├── 0301-RemoveInvalidParentheses.cs │ ├── 0303-RangeSumQueryImmutable.cs │ ├── 0305-NumberOfIslandsII.cs │ ├── 0309-BestTimeToBuyAndSellStockWithCooldown.cs │ ├── 0311-SparseMatrixMultiplication.cs │ ├── 0312-BurstBalloons.cs │ ├── 0314-BinaryTreeVerticalOrderTraversal.cs │ ├── 0315-CountOfSmallerNumbersAfterSelf.cs │ ├── 0316-RemoveDuplicateLetters.cs │ ├── 0317-ShortestDistanceFromAllBuildings.cs │ ├── 0322-CoinChange.cs │ ├── 0326-PowerOfThree.cs │ ├── 0327-CountOfRangeSum.cs │ ├── 0328-OddEvenLinkedList.cs │ ├── 0329-LongestIncreasingPathInAMatrix.cs │ ├── 0332-ReconstructItinerary.cs │ ├── 0336-PalindromePairs.cs │ ├── 0338-CountingBits.cs │ ├── 0339-NestedListWeightSum.cs │ ├── 0340-LongestSubstringWithAtMostKDistinctCharacters.cs │ ├── 0341-FlattenNestedListIterator.cs │ ├── 0342-PowerOfFour.cs │ ├── 0344-ReverseString.cs │ ├── 0345-ReverseVowelsOfAString.cs │ ├── 0346-MovingAverageFromDataStream.cs │ ├── 0347-TopKFrequentElements.cs │ ├── 0348-DesignTicTacToe.cs │ ├── 0349-IntersectionOfTwoArrays.cs │ └── 0350-IntersectionOfTwoArraysII.cs ├── 0351-0400 │ ├── 0352-DataStreamAsDisjointIntervals.cs │ ├── 0355-DesignTwitter.cs │ ├── 0359-LoggerRateLimiter.cs │ ├── 0362-DesignHitCounter.cs │ ├── 0364-NestedListWeightSumII.cs │ ├── 0366-FindLeavesOfBinaryTree.cs │ ├── 0367-ValidPerfectSquare.cs │ ├── 0368-LargestDivisibleSubset.cs │ ├── 0370-RangeAddition.cs │ ├── 0371-SumOfTwoIntegers.cs │ ├── 0374-GuessNumberHigherOrLower.cs │ ├── 0375-GuessNumberHigherOrLowerII.cs │ ├── 0380-InsertDeleteGetRandom.cs │ ├── 0381-InsertDeleteGetrandomDuplicatesAllowed.cs │ ├── 0383-RansomNote.cs │ ├── 0387-FirstUniqueCharacterInAString.cs │ ├── 0389-FindTheDifference.cs │ ├── 0392-IsSubsequence.cs │ ├── 0393-UTF8Validation.cs │ ├── 0394-DecodeString.cs │ └── 0399-EvaluateDivision.cs ├── 0401-0450 │ ├── 0401-BinaryWatch.cs │ ├── 0402-RemoveKDigits.cs │ ├── 0403-FrogJump.cs │ ├── 0404-SumOfLeftLeaves.cs │ ├── 0405-ConvertANumberToHexadecimal.cs │ ├── 0406-QueueReconstructionByHeight.cs │ ├── 0408-ValidWordAbbreviation.cs │ ├── 0409-LongestPalindrome.cs │ ├── 0410-SplitArrayLargestSum.cs │ ├── 0412-FizzBuzz.cs │ ├── 0414-ThirdMaximumNumber.cs │ ├── 0415-AddStrings.cs │ ├── 0416-PartitionEqualSubsetSum.cs │ ├── 0419-BattleshipsInABoard.cs │ ├── 0420-StrongPasswordChecker.cs │ ├── 0421-MaximumXOROfTwoNumbersInAnArray.cs │ ├── 0422-ValidWordSquare.cs │ ├── 0425-WordSquares.cs │ ├── 0426-ConvertBinarySearchTreeToSortedDoublyLinkedList.cs │ ├── 0427-ConstructQuadTree.cs │ ├── 0428-SerializeAndDeserializeNAryTree.cs │ ├── 0429-NAryTreeLevelOrderTraversal.cs │ ├── 0430-FlattenAMultilevelDoublyLinkedList.cs │ ├── 0432-AllOOneDataStructure.cs │ ├── 0434-NumberOfSegmentsInAString.cs │ ├── 0435-NonOverlappingIntervals.cs │ ├── 0436-FindRightInterval.cs │ ├── 0437-PathSumIII.cs │ ├── 0438-FindAllAnagramsInAString.cs │ ├── 0441-ArrangingCoins.cs │ ├── 0442-FindAllDuplicatesInAnArray.cs │ ├── 0443-StringCompression.cs │ ├── 0445-AddTwoNumbersII.cs │ ├── 0447-NumberOfBoomerangs.cs │ ├── 0448-FindAllNumbersDisappearedInAnArray.cs │ ├── 0449-SerializeAndDeserializeBST.cs │ └── 0450-DeleteNodeInABST.cs ├── 0451-0500 │ ├── 0451-SortCharactersByFrequency.cs │ ├── 0452-MinimumNumberOfArrowsToBurstBalloons.cs │ ├── 0453-MinimumMovesToEqualArrayElements.cs │ ├── 0455-AssignCookies.cs │ ├── 0458-PoorPigs.cs │ ├── 0459-RepeatedSubstringPattern.cs │ ├── 0460-LFUCache.cs │ ├── 0461-HammingDistance.cs │ ├── 0463-IslandPerimeter.cs │ ├── 0465-OptimalAccountBalancing.cs │ ├── 0468-ValidateIPAddress.cs │ ├── 0470-ImplementRand10UsingRand7.cs │ ├── 0472-ConcatenatedWords.cs │ ├── 0475-Heaters.cs │ ├── 0476-NumberComplement.cs │ ├── 0480-SlidingWindowMedian.cs │ ├── 0482-LicenseKeyFormatting.cs │ ├── 0484-FindPermutation.cs │ ├── 0485-MaxConsecutiveOnes.cs │ ├── 0489-RobotRoomCleaner.cs │ ├── 0490-TheMaze.cs │ ├── 0492-ConstructTheRectangle.cs │ ├── 0493-ReversePairs.cs │ ├── 0495-TeemoAttacking.cs │ ├── 0496-NextGreaterElementI.cs │ ├── 0497-RandomPointInNonOverlappingRectangles.cs │ ├── 0498-DiagonalTraverse.cs │ └── 0500-KeyboardRow.cs ├── 0501-0550 │ ├── 0501-FindModeInBinarySearchTree.cs │ ├── 0503-NextGreaterElementII.cs │ ├── 0504-Base7.cs │ ├── 0506-RelativeRanks.cs │ ├── 0507-PerfectNumber.cs │ ├── 0509-FibonacciNumber.cs │ ├── 0510-InorderSuccessorInBSTII.cs │ ├── 0513-FindBottomLeftTreeValue.cs │ ├── 0515-FindLargestValueInEachTreeRow.cs │ ├── 0518-CoinChange2.cs │ ├── 0520-DetectCapital.cs │ ├── 0521-LongestUncommonSubsequenceI.cs │ ├── 0523-ContinuousSubarraySum.cs │ ├── 0525-ContiguousArray.cs │ ├── 0528-RandomPickWithWeight.cs │ ├── 0529-Minesweeper.cs │ ├── 0530-MinimumAbsoluteDifferenceInBST.cs │ ├── 0532-KDiffPairsInAnArray.cs │ ├── 0535-EncodeAndDecodeTinyURL.cs │ ├── 0537-ComplexNumberMultiplication.cs │ ├── 0538-ConvertBSTToGreaterTree.cs │ ├── 0540-SingleElementInASortedArray.cs │ ├── 0541-ReverseStringII.cs │ ├── 0543-DiameterOfBinaryTree.cs │ ├── 0544-OutputContestMatches.cs │ ├── 0545-BoundaryOfBinaryTree.cs │ └── 0547-FriendCircles.cs ├── 0551-0600 │ ├── 0551-StudentAttendanceRecordI.cs │ ├── 0552-StudentAttendanceRecordII.cs │ ├── 0557-ReverseWordsInAStringIII.cs │ ├── 0559-MaximumDepthOfNAryTree.cs │ ├── 0560-SubarraySumEqualsK.cs │ ├── 0561-ArrayPartitionI.cs │ ├── 0563-BinaryTreeTilt.cs │ ├── 0566-ReshapeTheMatrix.cs │ ├── 0567-PermutationInString.cs │ ├── 0572-SubtreeOfAnotherTree.cs │ ├── 0575-DistributeCandies.cs │ ├── 0581-ShortestUnsortedContinuousSubarray.cs │ ├── 0582-KillProcess.cs │ ├── 0588-DesignInMemoryFileSystem.cs │ ├── 0589-NAryTreePreorderTraversal.cs │ ├── 0590-NAryTreePostorderTraversal.cs │ ├── 0594-LongestHarmoniousSubsequence.cs │ ├── 0598-RangeAdditionII.cs │ └── 0599-MinimumIndexSumOfTwoLists.cs ├── 0601-0650 │ ├── 0604-DesignCompressedStringIterator.cs │ ├── 0605-CanPlaceFlowers.cs │ ├── 0606-ConstructStringFromBinaryTree.cs │ ├── 0609-FindDuplicateFileInSystem.cs │ ├── 0616-AddBoldTagInString.cs │ ├── 0617-MergeTwoBinaryTrees.cs │ ├── 0621-TaskScheduler.cs │ ├── 0624-MaximumDistanceInArrays.cs │ ├── 0628-MaximumProductOfThreeNumbers.cs │ ├── 0633-SumOfSquareNumbers.cs │ ├── 0636-ExclusiveTimeOfFunctions.cs │ ├── 0637-AverageOfLevelsInBinaryTree.cs │ ├── 0642-DesignSearchAutocompleteSystem.cs │ ├── 0643-MaximumAverageSubarrayI.cs │ ├── 0645-SetMismatch.cs │ └── 0647-PalindromicSubstrings.cs ├── 0651-0700 │ ├── 0653-TwoSumIVInputIsABST.cs │ ├── 0654-MaximumBinaryTree.cs │ ├── 0657-RobotReturnToOrigin.cs │ ├── 0661-ImageSmoother.cs │ ├── 0662-MaximumWidthOfBinaryTree.cs │ ├── 0665-NonDecreasingArray.cs │ ├── 0668-KthSmallestNumberInMultiplicationTable.cs │ ├── 0669-TrimABinarySearchTree.cs │ ├── 0671-SecondMinimumNodeInABinaryTree.cs │ ├── 0674-LongestContinuousIncreasingSubsequence.cs │ ├── 0678-ValidParenthesisString.cs │ ├── 0680-ValidPalindromeII.cs │ ├── 0681-NextClosestTime.cs │ ├── 0682-BaseballGame.cs │ ├── 0683-KEmptySlots.cs │ ├── 0686-RepeatedStringMatch.cs │ ├── 0687-LongestUnivaluePath.cs │ ├── 0690-EmployeeImportance.cs │ ├── 0692-TopKFrequentWords.cs │ ├── 0693-BinaryNumberWithAlternatingBits.cs │ ├── 0695-MaxAreaOfIsland.cs │ ├── 0696-CountBinarySubstrings.cs │ ├── 0697-DegreeOfAnArray.cs │ ├── 0698-PartitionToKEqualSumSubsets.cs │ └── 0700-SearchInABinarySearchTree.cs ├── 0701-0750 │ ├── 0701-InsertIntoABinarySearchTree.cs │ ├── 0702-SearchInASortedArrayOfUnknownSize.cs │ ├── 0703-KthLargestElementInAStream.cs │ ├── 0704-BinarySearch.cs │ ├── 0705-DesignHashset.cs │ ├── 0706-DesignHashmap.cs │ ├── 0708-InsertIntoASortedCircularLinkedList.cs │ ├── 0709-ToLowerCase.cs │ ├── 0713-SubarrayProductLessThanK.cs │ ├── 0715-RangeModule.cs │ ├── 0716-MaxStack.cs │ ├── 0717-1BitAnd2BitCharacters.cs │ ├── 0720-LongestWordInDictionary.cs │ ├── 0721-AccountsMerge.cs │ ├── 0722-RemoveComments.cs │ ├── 0723-CandyCrush.cs │ ├── 0724-FindPivotIndex.cs │ ├── 0726-NumberOfAtoms.cs │ ├── 0727-MinimumWindowSubsequence.cs │ ├── 0728-SelfDividingNumbers.cs │ ├── 0733-FloodFill.cs │ ├── 0734-SentenceSimilarity.cs │ ├── 0735-AsteroidCollision.cs │ ├── 0739-DailyTemperatures.cs │ ├── 0742-ClosestLeafInABinaryTree.cs │ ├── 0743-NetworkDelayTime.cs │ ├── 0744-FindSmallestLetterGreaterThanTarget.cs │ ├── 0746-MinCostClimbingStairs.cs │ ├── 0747-LargestNumberAtLeastTwiceOfOthers.cs │ ├── 0748-ShortestCompletingWord.cs │ └── 0750-NumberOfCornerRectangles.cs ├── 0751-0800 │ ├── 0751-IPToCIDR.cs │ ├── 0753-CrackingtheSafe.cs │ ├── 0758-BoldWordsInString.cs │ ├── 0759-EmployeeFreeTime.cs │ ├── 0760-FindAnagramMappings.cs │ ├── 0762-PrimeNumberOfSetBitsInBinaryRepresentation.cs │ ├── 0763-PartitionLabels.cs │ ├── 0765-CouplesHoldingHands.cs │ ├── 0766-ToeplitzMatrix.cs │ ├── 0767-ReorganizeString.cs │ ├── 0771-JewelsAndStones.cs │ ├── 0772-BasicCalculatorIII.cs │ ├── 0773-SlidingPuzzle.cs │ ├── 0777-SwapAdjacentInLRString.cs │ ├── 0780-ReachingPoints.cs │ ├── 0783-MinimumDistanceBetweenBSTNodes.cs │ ├── 0784-LetterCasePermutation.cs │ ├── 0787-CheapestFlightsWithinKStops.cs │ ├── 0788-RotatedDigits.cs │ ├── 0791-CustomSortString.cs │ ├── 0794-ValidTicTacToeState.cs │ ├── 0796-RotateString.cs │ ├── 0797-AllPathsFromSourceToTarget.cs │ └── 0800-SimilarRGBColor.cs ├── 0801-0850 │ ├── 0804-UniqueMorseCodeWords.cs │ ├── 0806-NumberOfLinesToWriteString.cs │ ├── 0807-MaxIncreaseToKeepCitySkyline.cs │ ├── 0809-ExpressiveWords.cs │ ├── 0811-SubdomainVisitCount.cs │ ├── 0812-LargestTriangleArea.cs │ ├── 0814-BinaryTreePruning.cs │ ├── 0818-RaceCar.cs │ ├── 0819-MostCommonWord.cs │ ├── 0821-ShortestDistanceToACharacter.cs │ ├── 0824-GoatLatin.cs │ ├── 0829-ConsecutiveNumbersSum.cs │ ├── 0830-PositionsOfLargeGroups.cs │ ├── 0832-FlippingAnImage.cs │ ├── 0833-FindAndReplaceInString.cs │ ├── 0835-ImageOverlap.cs │ ├── 0836-RectangleOverlap.cs │ ├── 0837-New21Game.cs │ ├── 0840-MagicSquaresInGrid.cs │ ├── 0841-KeysAndRooms.cs │ ├── 0843-GuesstheWord.cs │ ├── 0844-BackspaceStringCompare.cs │ ├── 0846-HandOfStraights.cs │ └── 0849-MaximizeDistanceToClosestPerson.cs ├── 0851-0900 │ ├── 0852-PeakIndexInAMountainArray.cs │ ├── 0856-ScoreOfParentheses.cs │ ├── 0857-MinimumCostToHireKWorkers.cs │ ├── 0859-BuddyStrings.cs │ ├── 0860-LemonadeChange.cs │ ├── 0861-ScoreAfterFlippingMatrix.cs │ ├── 0863-AllNodesDistanceKInBinaryTree.cs │ ├── 0865-SmallestSubtreeWithAllTheDeepestNodes.cs │ ├── 0867-TransposeMatrix.cs │ ├── 0868-BinaryGap.cs │ ├── 0872-LeafSimilarTrees.cs │ ├── 0874-WalkingRobotSimulation.cs │ ├── 0876-MiddleOfTheLinkedList.cs │ ├── 0877-StoneGame.cs │ ├── 0883-ProjectionAreaOf3DShapes.cs │ ├── 0884-UncommonWordsFromTwoSentences.cs │ ├── 0885-SpiralMatrixIII.cs │ ├── 0886-PossibleBipartition.cs │ ├── 0888-FairCandySwap.cs │ ├── 0889-ConstructBinaryTreeFromPreorderAndPostorderTraversal.cs │ ├── 0890-FindAndReplacePattern.cs │ ├── 0892-SurfaceAreaOf3DShapes.cs │ ├── 0893-GroupsOfSpecialEquivalentStrings.cs │ ├── 0894-AllPossibleFullBinaryTrees.cs │ ├── 0895-MaximumFrequencyStack.cs │ ├── 0896-MonotonicArray.cs │ └── 0897-IncreasingOrderSearchTree.cs ├── 0901-0950 │ ├── 0901-OnlineStockSpan.cs │ ├── 0904-FruitIntoBaskets.cs │ ├── 0905-SortArrayByParity.cs │ ├── 0908-SmallestRangeI.cs │ ├── 0912-SortAnArray.cs │ ├── 0913-CatAndMouse.cs │ ├── 0914-XOfAKindInADeckOfCards.cs │ ├── 0917-ReverseOnlyLetters.cs │ ├── 0918-MaximumSumCircularSubarray.cs │ ├── 0921-MinimumAddToMakeParenthesesValid.cs │ ├── 0922-SortArrayByParityII.cs │ ├── 0925-LongPressedName.cs │ ├── 0929-UniqueEmailAddresses.cs │ ├── 0931-MinimumFallingPathSum.cs │ ├── 0933-NumberOfRecentCalls.cs │ ├── 0937-ReorderDataInLogFiles.cs │ ├── 0938-RangeSumOfBST.cs │ ├── 0939-MinimumAreaRectangle.cs │ ├── 0941-ValidMountainArray.cs │ ├── 0942-DIStringMatch.cs │ ├── 0944-DeleteColumnsToMakeSorted.cs │ ├── 0946-ValidateStackSequences.cs │ ├── 0947-MostStonesRemovedWithSameRoworColumn.cs │ ├── 0949-LargestTimeForGivenDigits.cs │ └── 0950-RevealCardsInIncreasingOrder.cs ├── 0951-1000 │ ├── 0951-FlipEquivalentBinaryTrees.cs │ ├── 0952-LargestComponentSizeByCommonFactor.cs │ ├── 0953-VerifyingAnAlienDictionary.cs │ ├── 0957-PrisonCellsAfterNDays.cs │ ├── 0959-RegionsCutBySlashes.cs │ ├── 0961-NRepeatedElementInSize2NArray.cs │ ├── 0965-UnivaluedBinaryTree.cs │ ├── 0967-NumbersWithSameConsecutiveDifferences.cs │ ├── 0969-PancakeSorting.cs │ ├── 0970-PowerfulIntegers.cs │ ├── 0973-KClosestPointsToOrigin.cs │ ├── 0975-OddEvenJump.cs │ ├── 0976-LargestPerimeterTriangle.cs │ ├── 0977-SquaresOfASortedArray.cs │ ├── 0979-DistributeCoinsInBinaryTree.cs │ ├── 0980-UniquePathsIII.cs │ ├── 0981-TimeBasedKeyValueStore.cs │ ├── 0983-MinimumCostForTickets.cs │ ├── 0985-SumOfEvenNumbersAfterQueries.cs │ ├── 0986-IntervalListIntersections.cs │ ├── 0987-VerticalOrderTraversalOfABinaryTree.cs │ ├── 0989-AddToArrayFormOfInteger.cs │ ├── 0993-CousinsInBinaryTree.cs │ ├── 0994-RottingOranges.cs │ ├── 0997-FindTheTownJudge.cs │ ├── 0998-MaximumBinaryTreeII.cs │ └── 0999-AvailableCapturesForRook.cs ├── 1001-1050 │ ├── 1002-FindCommonCharacters.cs │ ├── 1005-MaximizeSumOfArrayAfterKNegations.cs │ ├── 1007-MinimumDominoRotationsForEqualRow.cs │ ├── 1008-ConstructBinarySearchTreeFromPreorderTraversal.cs │ ├── 1009-ComplementOfBase10Integer.cs │ ├── 1010-PairsOfSongsWithTotalDurationsDivisibleBy60.cs │ ├── 1011-CapacityToShipPackagesWithinDDays.cs │ ├── 1013-PartitionArrayIntoThreePartsWithEqualSum.cs │ ├── 1018-BinaryPrefixDivisibleBy5.cs │ ├── 1021-RemoveOutermostParentheses.cs │ ├── 1022-SumOfRootToLeafBinaryNumbers.cs │ ├── 1024-VideoStitching.cs │ ├── 1025-DivisorGame.cs │ ├── 1026-MaximumDifferenceBetweenNodeAndAncestor.cs │ ├── 1029-TwoCityScheduling.cs │ ├── 1030-MatrixCellsInDistanceOrder.cs │ ├── 1032-StreamOfCharacters.cs │ ├── 1033-MovingStonesUntilConsecutive.cs │ ├── 1035-UncrossedLines.cs │ ├── 1037-ValidBoomerang.cs │ ├── 1038-BinarySearchTreeToGreaterSumTree.cs │ ├── 1041-RobotBoundedInCircle.cs │ ├── 1042-FlowerPlantingWithNoAdjacent.cs │ ├── 1043-PartitionArrayForMaximumSum.cs │ ├── 1044-LongestDuplicateSubstring.cs │ ├── 1046-LastStoneWeight.cs │ ├── 1047-RemoveAllAdjacentDuplicatesInString.cs │ ├── 1048-LongestStringChain.cs │ └── HashMap.cs ├── 1051-1100 │ ├── 1051-HeightChecker.cs │ ├── 1055-ShortestWaytoFormString.cs │ ├── 1056-ConfusingNumber.cs │ ├── 1057-CampusBikes.cs │ ├── 1061-LexicographicallySmallestEquivalentString.cs │ ├── 1062-LongestRepeatingSubstring.cs │ ├── 1064-FixedPoint.cs │ ├── 1065-IndexPairsOfAString.cs │ ├── 1066-CampusBikesII.cs │ ├── 1071-GreatestCommonDivisorOfStrings.cs │ ├── 1072-FlipColumnsForMaximumNumberOfEqualRows.cs │ ├── 1078-OccurrencesAfterBigram.cs │ ├── 1079-LetterTilePossibilities.cs │ ├── 1081-SmallestSubsequenceOfDistinctCharacters.cs │ ├── 1085-SumOfDigitsInTheMinimumNumber.cs │ ├── 1086-HighFive.cs │ ├── 1087-BraceExpansion.cs │ ├── 1089-DuplicateZeros.cs │ ├── 1094-CarPooling.cs │ ├── 1096-BraceExpansionII.cs │ ├── 1099-TwoSumLessThanK.cs │ └── 1100-FindKLengthSubstringsWithNoRepeatedCharacters.cs ├── 1101-1150 │ ├── 1101-TheEarliestMomentWhenEveryoneBecomeFriends.cs │ ├── 1102-PathWithMaximumMinimumValue.cs │ ├── 1103-DistributeCandiesToPeople.cs │ ├── 1104-PathInZigzagLabelledBinaryTree.cs │ ├── 1108-DefangingAnIPAddress.cs │ ├── 1110-DeleteNodesAndReturnForest.cs │ ├── 1111-MaximumNestingDepthOfTwoValidParenthesesStrings.cs │ ├── 1114-PrintInOrder.cs │ ├── 1118-NumberOfDaysInAMonth.cs │ ├── 1119-RemoveVowelsFromAString.cs │ ├── 1120-MaximumAverageSubtree.cs │ ├── 1122-RelativeSortArray.cs │ ├── 1123-LowestCommonAncestorOfDeepestLeaves.cs │ ├── 1128-NumberOfEquivalentDominoPairs.cs │ ├── 1130-MinimumCostTreeFromLeafValues.cs │ ├── 1133-LargestUniqueNumber.cs │ ├── 1134-ArmstrongNumber.cs │ ├── 1137-NThTribonacciNumber.cs │ ├── 1140-StoneGameII.cs │ ├── 1143-LongestCommonSubsequence.cs │ └── 1150-CheckIfANumberIsMajorityElementInASortedArray.cs ├── 1151-1200 │ ├── 1152-AnalyzeUserWebsiteVisitPattern.cs │ ├── 1154-DayOfTheYear.cs │ ├── 1160-FindWordsThatCanBeFormedByCharacters.cs │ ├── 1161-MaximumLevelSumOfABinaryTree.cs │ ├── 1165-SingleRowKeyboard.cs │ ├── 1167-MinimumCostToConnectSticks.cs │ ├── 1170-CompareStringsByFrequencyOfTheSmallestCharacter.cs │ ├── 1175-PrimeArrangements.cs │ ├── 1176-DietPlanPerformance.cs │ ├── 1180-CountSubstringsWithOnlyOneDistinctLetter.cs │ ├── 1184-DistanceBetweenBusStops.cs │ ├── 1185-DayOfTheWeek.cs │ ├── 1189-MaximumNumberOfBalloons.cs │ ├── 1190-ReverseSubstringsBetweenEachPairOfParentheses.cs │ ├── 1192-CriticalConnectionsInANetwork.cs │ ├── 1196-HowManyApplesCanYouPutIntoTheBasket.cs │ ├── 1197-MinimumKnightMoves.cs │ ├── 1198-FindSmallestCommonElementInAllRows.cs │ └── 1200-MinimumAbsoluteDifference.cs ├── 1201-1250 │ ├── 1207-UniqueNumberOfOccurrences.cs │ ├── 1213-IntersectionOfThreeSortedArrays.cs │ ├── 1214-TwoSumBsts.cs │ ├── 1217-PlayWithChips.cs │ ├── 1219-PathWithMaximumGold.cs │ ├── 1221-SplitAStringInBalancedStrings.cs │ ├── 1222-QueensThatCanAttackTheKing.cs │ ├── 1227-AirplaneSeatAssignmentProbability.cs │ ├── 1228-MissingNumberInArithmeticProgression.cs │ ├── 1229-MeetingScheduler.cs │ ├── 1232-CheckIfItIsAStraightLine.cs │ ├── 1235-MaximumProfitInJobScheduling.cs │ ├── 1236-WebCrawler.cs │ ├── 1237-FindPositiveIntegerSolutionForAGivenEquation.cs │ ├── 1238-CircularPermutationInBinaryRepresentation.cs │ ├── 1242-WebCrawlerMultithreaded.cs │ ├── 1243-ArrayTransformation.cs │ ├── 1245-TreeDiameter.cs │ ├── 1247-MinimumSwapsToMakeStringsEqual.cs │ └── 1249-MinimumRemoveToMakeValidParentheses.cs ├── 1251-1300 │ ├── 1252-CellsWithOddValuesInAMatrix.cs │ ├── 1254-NumberOfClosedIslands.cs │ ├── 1256-EncodeNumber.cs │ ├── 1258-SynonymousSentences.cs │ ├── 1260-Shift2DGrid.cs │ ├── 1261-FindElementsInAContaminatedBinaryTree.cs │ ├── 1265-PrintImmutableLinkedListInReverse.cs │ ├── 1266-MinimumTimeVisitingAllPoints.cs │ ├── 1268-SearchSuggestionsSystem.cs │ ├── 1271-Hexspeak.cs │ ├── 1273-DeleteTreeNodes.cs │ ├── 1275-FindWinnerOnATicTacToeGame.cs │ ├── 1277-CountSquareSubmatricesWithAllOnes.cs │ ├── 1279-TrafficLightControlledIntersection.cs │ ├── 1281-SubtractTheProductAndSumOfDigitsOfAnInteger.cs │ ├── 1282-GroupThePeopleGivenTheGroupSizeTheyBelongTo.cs │ ├── 1286-IteratorForCombination.cs │ ├── 1287-ElementAppearingMoreThan25InSortedArray.cs │ ├── 1288-RemoveCoveredIntervals.cs │ ├── 1290-ConvertBinaryNumberInALinkedListToInteger.cs │ ├── 1291-SequentialDigits.cs │ ├── 1295-FindNumbersWithEvenNumberOfDigits.cs │ ├── 1296-DivideArrayInSetsOfKConsecutiveNumbers.cs │ └── 1299-ReplaceElementsWithGreatestElementOnRightSide.cs ├── 1301-1350 │ ├── 1302-DeepestLeavesSum.cs │ ├── 1304-FindNUniqueIntegersSumUpToZero.cs │ ├── 1305-AllElementsInTwoBinarySearchTrees.cs │ ├── 1306-JumpGameIII.cs │ ├── 1309-DecryptStringFromAlphabetToIntegerMapping.cs │ ├── 1310-XORQueriesOfASubarray.cs │ ├── 1313-DecompressRunLengthEncodedList.cs │ ├── 1314-MatrixBlockSum.cs │ ├── 1315-SumOfNodesWithEvenValuedGrandparent.cs │ ├── 1317-ConvertIntegerToTheSumOfTwoNoZeroIntegers.cs │ ├── 1318-MinimumFlipsToMakeAORBEqualToC.cs │ ├── 1323-Maximum69Numberr.cs │ ├── 1325-DeleteLeavesWithAGivenValue.cs │ ├── 1326-MinimumNumberOfTapsToOpenToWaterAGarden.cs │ ├── 1329-SortTheMatrixDiagonally.cs │ ├── 1331-RankTransformOfAnArray.cs │ ├── 1332-RemovePalindromicSubsequences.cs │ ├── 1337-TheKWeakestRowsInAMatrix.cs │ ├── 1338-ReduceArraySizeToTheHalf.cs │ ├── 1342-NumberOfStepsToReduceANumberToZero.cs │ ├── 1343-NumberOfSubArraysOfSizeKAndAverageGreaterThanOrEqualToThreshold.cs │ ├── 1344-AngleBetweenHandsOfAClock.cs │ ├── 1346-CheckIfNAndItsDoubleExist.cs │ └── 1347-MinimumNumberOfStepsToMakeTwoStringsAnagram.cs ├── 1351-1400 │ ├── 1351-CountNegativeNumbersInASortedMatrix.cs │ ├── 1353-MaximumNumberOfEventsThatCanBeAttended.cs │ ├── 1356-SortIntegersByTheNumberOf1Bits.cs │ ├── 1357-ApplyDiscountEveryNOrders.cs │ ├── 1360-NumberOfDaysBetweenTwoDates.cs │ ├── 1365-HowManyNumbersAreSmallerThanTheCurrentNumber.cs │ ├── 1370-IncreasingDecreasingString.cs │ ├── 1374-GenerateAStringWithCharactersThatHaveOddCounts.cs │ ├── 1375-BulbSwitcherIII.cs │ ├── 1379-FindACorrespondingNodeOfABinaryTreeInACloneOfThatTree.cs │ ├── 1380-LuckyNumbersInAMatrix.cs │ ├── 1381-DesignAStackWithIncrementOperation.cs │ ├── 1382-BalanceABinarySearchTree.cs │ ├── 1385-FindTheDistanceValueBetweenTwoArrays.cs │ ├── 1387-SortIntegersByThePowerValue.cs │ ├── 1389-CreateTargetArrayInTheGivenOrder.cs │ ├── 1394-FindLuckyIntegerInAnArray.cs │ ├── 1395-CountNumberOfTeams.cs │ ├── 1396-DesignUndergroundSystem.cs │ ├── 1399-CountLargestGroup.cs │ └── 1400-ConstructKPalindromeStrings.cs ├── 1401-1450 │ ├── 1403-MinimumSubsequenceInNonIncreasingOrder.cs │ ├── 1408-StringMatchingInAnArray.cs │ ├── 1409-QueriesOnAPermutationWithKey.cs │ ├── 1413-MinimumValueToGetPositiveStepByStepSum.cs │ ├── 1414-FindTheMinimumNumberOfFibonacciNumbersWhoseSumIsK.cs │ ├── 1415-TheKThLexicographicalStringOfAllHappyStringsOfLengthN.cs │ ├── 1417-ReformatTheString.cs │ ├── 1418-DisplayTableOfFoodOrdersInARestaurant.cs │ ├── 1422-MaximumScoreAfterSplittingAString.cs │ ├── 1426-CountingElements.cs │ ├── 1427-PerformStringShifts.cs │ ├── 1428-LeftmostColumnWithAtLeastAOne.cs │ ├── 1429-FirstUniqueNumber.cs │ ├── 1430-CheckIfAStringIsAValidSequenceFromRootToLeavesPathInABinaryTree.cs │ ├── 1431-KidsWithTheGreatestNumberOfCandies.cs │ ├── 1433-CheckIfAStringCanBreakAnotherString.cs │ ├── 1436-DestinationCity.cs │ ├── 1437-CheckIfAll1SAreAtLeastLengthKPlacesAway.cs │ ├── 1441-BuildAnArrayWithStackOperations.cs │ ├── 1442-CountTripletsThatCanFormTwoArraysOfEqualXOR.cs │ ├── 1446-ConsecutiveCharacters.cs │ ├── 1447-SimplifiedFractions.cs │ ├── 1448-CountGoodNodesInBinaryTree.cs │ └── 1450-NumberOfStudentsDoingHomeworkAtAGivenTime.cs ├── 1451-1500 │ ├── 1455-CheckIfAWordOccursAsAPrefixOfAnyWordInASentence.cs │ ├── 1457-PseudoPalindromicPathsInABinaryTree.cs │ ├── 1460-MakeTwoArraysEqualByReversingSubArrays.cs │ ├── 1464-MaximumProductOfTwoElementsInAnArray.cs │ ├── 1466-ReorderRoutesToMakeAllPathsLeadToTheCityZero.cs │ ├── 1469-FindAllTheLonelyNodes.cs │ ├── 1470-ShuffleTheArray.cs │ ├── 1472-DesignBrowserHistory.cs │ ├── 1474-DeleteNNodesAfterMNodesOfALinkedList.cs │ ├── 1475-FinalPricesWithASpecialDiscountInAShop.cs │ ├── 1476-SubrectangleQueries.cs │ ├── 1480-RunningSumOf1DArray.cs │ ├── 1485-CloneBinaryTreeWithRandomPointer.cs │ ├── 1486-XOROperationInAnArray.cs │ ├── 1490-CloneNAryTree.cs │ ├── 1491-AverageSalaryExcludingTheMinimumAndMaximumSalary.cs │ ├── 1492-TheKthFactorOfN.cs │ └── 1496-PathCrossing.cs ├── 1501-1550 │ ├── 1502-CanMakeArithmeticProgressionFromSequence.cs │ ├── 1504-CountSubmatricesWithAllOnes.cs │ ├── 1506-FindRootOfNAryTree.cs │ ├── 1507-ReformatDate.cs │ ├── 1508-RangeSumOfSortedSubarraySums.cs │ ├── 1512-NumberOfGoodPairs.cs │ └── 1518-WaterBottles.cs ├── Interval.cs ├── LeetCode.csproj ├── ListNode.cs ├── Properties │ └── AssemblyInfo.cs ├── TreeLinkNode.cs └── TreeNode.cs └── README.md /.gitattributes: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/.gitattributes -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/.gitignore -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/001-TwoSume-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/001-TwoSume-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/002-AddTwoNumbers-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/002-AddTwoNumbers-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/007-ReverseInteger-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/007-ReverseInteger-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/008-StringToInteger-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/008-StringToInteger-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/012-IntegerToRoman-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/012-IntegerToRoman-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/013-RomanToInteger-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/013-RomanToInteger-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/015-3Sum-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/015-3Sum-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/016-3SumClosest-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/016-3SumClosest-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/018-FourSum-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/018-FourSum-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/027-RemoveElement-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/027-RemoveElement-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/028-ImplementStrStr-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/028-ImplementStrStr-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/031-NextPermutation-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/031-NextPermutation-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/034-SearchForARange-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/034-SearchForARange-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/036-ValidSudoku-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/036-ValidSudoku-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/037-SudokuSolver-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/037-SudokuSolver-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/038-CountAndSay-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/038-CountAndSay-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/039-CombinationSum-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/039-CombinationSum-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/040-CombinationSum2-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/040-CombinationSum2-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/043-MultiplyStrings-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/043-MultiplyStrings-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/045-JumpGame2-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/045-JumpGame2-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/046-Permutations-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/046-Permutations-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/047-Permutations2-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/047-Permutations2-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/048-RotateImage-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/048-RotateImage-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/049-GroupAnagrams-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/049-GroupAnagrams-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0001-0050/050-Pow-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0001-0050/050-Pow-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/051-NQueens-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/051-NQueens-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/052-NQueens2-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/052-NQueens2-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/053-MaximumSubarray-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/053-MaximumSubarray-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/054-SpiralMatrix-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/054-SpiralMatrix-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/055-JumpGame-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/055-JumpGame-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/056-MergeIntervals-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/056-MergeIntervals-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/057-InsertInterval-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/057-InsertInterval-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/059-SpiralMatrix2-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/059-SpiralMatrix2-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/061-RotateList-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/061-RotateList-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/062-UniquePaths-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/062-UniquePaths-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/063-UniquePaths2-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/063-UniquePaths2-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/064-MinimumPathSum-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/064-MinimumPathSum-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/065-ValidNumber-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/065-ValidNumber-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/066-PlusOne-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/066-PlusOne-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/067-AddBinary-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/067-AddBinary-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/069-Sqrt(x)-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/069-Sqrt(x)-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/070-ClimbingStairs-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/070-ClimbingStairs-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/071-SimplifyPath-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/071-SimplifyPath-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/072-EditDistance-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/072-EditDistance-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/073-SetMatrixZeroes-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/073-SetMatrixZeroes-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/074-SearchA2DMatrix-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/074-SearchA2DMatrix-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/075-SortColors-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/075-SortColors-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/077-Combinations-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/077-Combinations-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/078-Subsets-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/078-Subsets-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/079-WordSearch-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/079-WordSearch-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/086-PartitionList-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/086-PartitionList-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/087-ScrambleString-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/087-ScrambleString-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/089-GrayCode-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/089-GrayCode-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/090-Subsets2-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/090-Subsets2-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/091-DecodeWays-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/091-DecodeWays-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0051-0100/100-SameTree-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0051-0100/100-SameTree-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0126-WordLadderII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0126-WordLadderII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0127-WordLadder-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0127-WordLadder-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0133-CloneGraph-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0133-CloneGraph-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0134-GasStation-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0134-GasStation-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0136-SingleNumber-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0136-SingleNumber-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0137-SingleNumberII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0137-SingleNumberII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0139-WordBreak-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0139-WordBreak-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0140-WordBreakII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0140-WordBreakII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0143-ReorderList-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0143-ReorderList-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0146-LRUCache-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0146-LRUCache-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/0148-SortList-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/0148-SortList-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/101-SymmetricTree-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/101-SymmetricTree-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/112-PathSum-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/112-PathSum-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/113-PathSum2-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/113-PathSum2-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/118-PascalsTriangle-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/118-PascalsTriangle-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0101-0150/120-Triangle-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0101-0150/120-Triangle-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0151-0200/0155-MinStack-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0151-0200/0155-MinStack-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0151-0200/0167-TwoSumII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0151-0200/0167-TwoSumII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0151-0200/0174-DungeonGame-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0151-0200/0174-DungeonGame-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0151-0200/0179-LargestNumber-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0151-0200/0179-LargestNumber-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0151-0200/0189-RotateArray-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0151-0200/0189-RotateArray-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0151-0200/0190-ReverseBits-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0151-0200/0190-ReverseBits-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0151-0200/0191-NumberOf1Bits-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0151-0200/0191-NumberOf1Bits-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0151-0200/0198-HouseRobber-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0151-0200/0198-HouseRobber-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0201-0250/0202-HappyNumber-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0201-0250/0202-HappyNumber-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0201-0250/0204-CountPrimes-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0201-0250/0204-CountPrimes-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0201-0250/0207-CourseSchedule-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0201-0250/0207-CourseSchedule-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0201-0250/0208-ImplementTrie-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0201-0250/0208-ImplementTrie-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0201-0250/0212-WordSearchII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0201-0250/0212-WordSearchII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0201-0250/0213-HouseRobberII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0201-0250/0213-HouseRobberII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0201-0250/0221-MaximalSquare-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0201-0250/0221-MaximalSquare-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0201-0250/0231-PowerOfTwo-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0201-0250/0231-PowerOfTwo-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0201-0250/0242-ValidAnagram-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0201-0250/0242-ValidAnagram-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0252-MeetingRooms-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0252-MeetingRooms-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0253-MeetingRoomsII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0253-MeetingRoomsII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0256-PaintHouse-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0256-PaintHouse-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0258-AddDigits-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0258-AddDigits-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0263-UglyNumber-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0263-UglyNumber-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0264-UglyNumberII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0264-UglyNumberII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0268-MissingNumber-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0268-MissingNumber-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0274-HIndex-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0274-HIndex-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0275-HIndexII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0275-HIndexII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0276-PaintFence-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0276-PaintFence-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0279-PerfectSquares-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0279-PerfectSquares-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0280-WiggleSort-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0280-WiggleSort-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0283-MoveZeroes-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0283-MoveZeroes-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0289-GameOfLife-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0289-GameOfLife-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0290-WordPattern-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0290-WordPattern-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0292-NimGame-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0292-NimGame-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0293-FlipGame-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0293-FlipGame-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0251-0300/0299-BullsAndCows-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0251-0300/0299-BullsAndCows-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0301-0350/0312-BurstBalloons-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0301-0350/0312-BurstBalloons-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0301-0350/0322-CoinChange-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0301-0350/0322-CoinChange-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0301-0350/0326-PowerOfThree-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0301-0350/0326-PowerOfThree-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0301-0350/0338-CountingBits-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0301-0350/0338-CountingBits-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0301-0350/0342-PowerOfFour-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0301-0350/0342-PowerOfFour-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0301-0350/0344-ReverseString-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0301-0350/0344-ReverseString-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0351-0400/0355-DesignTwitter-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0351-0400/0355-DesignTwitter-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0351-0400/0370-RangeAddition-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0351-0400/0370-RangeAddition-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0351-0400/0383-RansomNote-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0351-0400/0383-RansomNote-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0351-0400/0392-IsSubsequence-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0351-0400/0392-IsSubsequence-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0351-0400/0393-UTF8Validation-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0351-0400/0393-UTF8Validation-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0351-0400/0394-DecodeString-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0351-0400/0394-DecodeString-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0401-0450/0401-BinaryWatch-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0401-0450/0401-BinaryWatch-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0401-0450/0402-RemoveKDigits-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0401-0450/0402-RemoveKDigits-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0401-0450/0403-FrogJump-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0401-0450/0403-FrogJump-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0401-0450/0412-FizzBuzz-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0401-0450/0412-FizzBuzz-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0401-0450/0415-AddStrings-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0401-0450/0415-AddStrings-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0401-0450/0425-WordSquares-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0401-0450/0425-WordSquares-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0401-0450/0437-PathSumIII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0401-0450/0437-PathSumIII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0401-0450/0441-ArrangingCoins-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0401-0450/0441-ArrangingCoins-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0451-0500/0455-AssignCookies-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0451-0500/0455-AssignCookies-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0451-0500/0458-PoorPigs-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0451-0500/0458-PoorPigs-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0451-0500/0460-LFUCache-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0451-0500/0460-LFUCache-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0451-0500/0475-Heaters-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0451-0500/0475-Heaters-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0451-0500/0490-TheMaze-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0451-0500/0490-TheMaze-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0451-0500/0493-ReversePairs-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0451-0500/0493-ReversePairs-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0451-0500/0495-TeemoAttacking-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0451-0500/0495-TeemoAttacking-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0451-0500/0500-KeyboardRow-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0451-0500/0500-KeyboardRow-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0501-0550/0504-Base7-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0501-0550/0504-Base7-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0501-0550/0506-RelativeRanks-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0501-0550/0506-RelativeRanks-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0501-0550/0507-PerfectNumber-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0501-0550/0507-PerfectNumber-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0501-0550/0518-CoinChange2-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0501-0550/0518-CoinChange2-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0501-0550/0520-DetectCapital-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0501-0550/0520-DetectCapital-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0501-0550/0529-Minesweeper-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0501-0550/0529-Minesweeper-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0501-0550/0547-FriendCircles-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0501-0550/0547-FriendCircles-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0551-0600/0563-BinaryTreeTilt-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0551-0600/0563-BinaryTreeTilt-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0551-0600/0582-KillProcess-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0551-0600/0582-KillProcess-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0601-0650/0621-TaskScheduler-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0601-0650/0621-TaskScheduler-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0601-0650/0645-SetMismatch-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0601-0650/0645-SetMismatch-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0651-0700/0661-ImageSmoother-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0651-0700/0661-ImageSmoother-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0651-0700/0682-BaseballGame-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0651-0700/0682-BaseballGame-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0651-0700/0683-KEmptySlots-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0651-0700/0683-KEmptySlots-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0704-BinarySearch-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0704-BinarySearch-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0705-DesignHashset-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0705-DesignHashset-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0706-DesignHashmap-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0706-DesignHashmap-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0709-ToLowerCase-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0709-ToLowerCase-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0715-RangeModule-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0715-RangeModule-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0716-MaxStack-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0716-MaxStack-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0721-AccountsMerge-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0721-AccountsMerge-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0722-RemoveComments-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0722-RemoveComments-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0723-CandyCrush-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0723-CandyCrush-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0724-FindPivotIndex-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0724-FindPivotIndex-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0726-NumberOfAtoms-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0726-NumberOfAtoms-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0701-0750/0733-FloodFill-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0701-0750/0733-FloodFill-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0751-0800/0751-IPToCIDR-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0751-0800/0751-IPToCIDR-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0751-0800/0766-ToeplitzMatrix-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0751-0800/0766-ToeplitzMatrix-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0751-0800/0773-SlidingPuzzle-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0751-0800/0773-SlidingPuzzle-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0751-0800/0780-ReachingPoints-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0751-0800/0780-ReachingPoints-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0751-0800/0788-RotatedDigits-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0751-0800/0788-RotatedDigits-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0751-0800/0796-RotateString-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0751-0800/0796-RotateString-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0801-0850/0818-RaceCar-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0801-0850/0818-RaceCar-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0801-0850/0819-MostCommonWord-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0801-0850/0819-MostCommonWord-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0801-0850/0824-GoatLatin-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0801-0850/0824-GoatLatin-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0801-0850/0835-ImageOverlap-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0801-0850/0835-ImageOverlap-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0801-0850/0837-New21Game-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0801-0850/0837-New21Game-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0801-0850/0841-KeysAndRooms-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0801-0850/0841-KeysAndRooms-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0801-0850/0843-GuesstheWord-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0801-0850/0843-GuesstheWord-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0851-0900/0859-BuddyStrings-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0851-0900/0859-BuddyStrings-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0851-0900/0860-LemonadeChange-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0851-0900/0860-LemonadeChange-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0851-0900/0868-BinaryGap-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0851-0900/0868-BinaryGap-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0851-0900/0877-StoneGame-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0851-0900/0877-StoneGame-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0851-0900/0888-FairCandySwap-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0851-0900/0888-FairCandySwap-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0851-0900/0896-MonotonicArray-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0851-0900/0896-MonotonicArray-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0901-0950/0908-SmallestRangeI-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0901-0950/0908-SmallestRangeI-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0901-0950/0912-SortAnArray-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0901-0950/0912-SortAnArray-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0901-0950/0913-CatAndMouse-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0901-0950/0913-CatAndMouse-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0901-0950/0938-RangeSumOfBST-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0901-0950/0938-RangeSumOfBST-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0901-0950/0942-DIStringMatch-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0901-0950/0942-DIStringMatch-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0951-1000/0969-PancakeSorting-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0951-1000/0969-PancakeSorting-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0951-1000/0975-OddEvenJump-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0951-1000/0975-OddEvenJump-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0951-1000/0980-UniquePathsIII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0951-1000/0980-UniquePathsIII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/0951-1000/0994-RottingOranges-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/0951-1000/0994-RottingOranges-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1001-1050/1024-VideoStitching-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1001-1050/1024-VideoStitching-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1001-1050/1025-DivisorGame-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1001-1050/1025-DivisorGame-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1001-1050/1035-UncrossedLines-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1001-1050/1035-UncrossedLines-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1001-1050/1037-ValidBoomerang-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1001-1050/1037-ValidBoomerang-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1051-1100/1051-HeightChecker-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1051-1100/1051-HeightChecker-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1051-1100/1057-CampusBikes-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1051-1100/1057-CampusBikes-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1051-1100/1064-FixedPoint-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1051-1100/1064-FixedPoint-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1051-1100/1066-CampusBikesII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1051-1100/1066-CampusBikesII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1051-1100/1086-HighFive-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1051-1100/1086-HighFive-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1051-1100/1087-BraceExpansion-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1051-1100/1087-BraceExpansion-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1051-1100/1089-DuplicateZeros-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1051-1100/1089-DuplicateZeros-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1051-1100/1094-CarPooling-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1051-1100/1094-CarPooling-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1101-1150/1140-StoneGameII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1101-1150/1140-StoneGameII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1151-1200/1154-DayOfTheYear-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1151-1200/1154-DayOfTheYear-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1151-1200/1185-DayOfTheWeek-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1151-1200/1185-DayOfTheWeek-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1201-1250/1214-TwoSumBsts-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1201-1250/1214-TwoSumBsts-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1201-1250/1217-PlayWithChips-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1201-1250/1217-PlayWithChips-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1201-1250/1236-WebCrawler-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1201-1250/1236-WebCrawler-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1201-1250/1245-TreeDiameter-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1201-1250/1245-TreeDiameter-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1251-1300/1256-EncodeNumber-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1251-1300/1256-EncodeNumber-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1251-1300/1260-Shift2DGrid-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1251-1300/1260-Shift2DGrid-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1251-1300/1271-Hexspeak-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1251-1300/1271-Hexspeak-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1301-1350/1306-JumpGameIII-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1301-1350/1306-JumpGameIII-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1301-1350/1314-MatrixBlockSum-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1301-1350/1314-MatrixBlockSum-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1451-1500/1490-CloneNAryTree-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1451-1500/1490-CloneNAryTree-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1451-1500/1496-PathCrossing-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1451-1500/1496-PathCrossing-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1501-1550/1507-ReformatDate-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1501-1550/1507-ReformatDate-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/1501-1550/1518-WaterBottles-Test.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/1501-1550/1518-WaterBottles-Test.cs -------------------------------------------------------------------------------- /LeetCode.Test/AssertHelper.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/AssertHelper.cs -------------------------------------------------------------------------------- /LeetCode.Test/LeetCode.Test.csproj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/LeetCode.Test.csproj -------------------------------------------------------------------------------- /LeetCode.Test/Properties/AssemblyInfo.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/Properties/AssemblyInfo.cs -------------------------------------------------------------------------------- /LeetCode.Test/TestHelper.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.Test/TestHelper.cs -------------------------------------------------------------------------------- /LeetCode.sln: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode.sln -------------------------------------------------------------------------------- /LeetCode/0001-0050/001-TwoSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/001-TwoSum.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/002-AddTwoNumbers.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/002-AddTwoNumbers.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/004-MedianOfTwoSortedArrays.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/004-MedianOfTwoSortedArrays.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/006-ZigZagConversion.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/006-ZigZagConversion.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/007-ReverseInteger.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/007-ReverseInteger.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/008-StringToInteger(atoi).cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/008-StringToInteger(atoi).cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/009-PalindromeNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/009-PalindromeNumber.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/010-RegularExpressionMatching.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/010-RegularExpressionMatching.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/011-ContainerWithMostWater.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/011-ContainerWithMostWater.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/012-IntegerToRoman.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/012-IntegerToRoman.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/013-RomanToInteger.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/013-RomanToInteger.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/014-LongestCommonPrefix.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/014-LongestCommonPrefix.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/015-3Sum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/015-3Sum.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/016-3SumClosest.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/016-3SumClosest.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/018-4Sum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/018-4Sum.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/020-ValidParentheses.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/020-ValidParentheses.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/021-MergeTwoSortedLists.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/021-MergeTwoSortedLists.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/022-GenerateParentheses.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/022-GenerateParentheses.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/023-MergeKSortedLists.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/023-MergeKSortedLists.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/024-SwapNodesInPairs.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/024-SwapNodesInPairs.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/025-ReverseNodesInKGroup.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/025-ReverseNodesInKGroup.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/027-RemoveElement.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/027-RemoveElement.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/028-ImplementStrStr.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/028-ImplementStrStr.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/029-DivideTwoIntegers.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/029-DivideTwoIntegers.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/031-NextPermutation.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/031-NextPermutation.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/032-LongestValidParentheses.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/032-LongestValidParentheses.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/034-SearchForARange.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/034-SearchForARange.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/035-SearchInsertPosition.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/035-SearchInsertPosition.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/036-ValidSudoku.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/036-ValidSudoku.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/037-SudokuSolver.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/037-SudokuSolver.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/038-CountAndSay.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/038-CountAndSay.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/039-CombinationSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/039-CombinationSum.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/040-CombinationSum2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/040-CombinationSum2.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/041-FirstMissingPositive.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/041-FirstMissingPositive.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/042-TrappingRainWater.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/042-TrappingRainWater.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/043-MultiplyStrings.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/043-MultiplyStrings.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/044-WildcardMatching.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/044-WildcardMatching.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/045-JumpGame2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/045-JumpGame2.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/046-Permutations.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/046-Permutations.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/047-Permutations2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/047-Permutations2.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/048-RotateImage.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/048-RotateImage.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/049-GroupAnagrams.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/049-GroupAnagrams.cs -------------------------------------------------------------------------------- /LeetCode/0001-0050/050-Pow.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0001-0050/050-Pow.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/051-NQueens.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/051-NQueens.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/052-NQueens2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/052-NQueens2.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/053-MaximumSubarray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/053-MaximumSubarray.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/054-SpiralMatrix.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/054-SpiralMatrix.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/055-JumpGame.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/055-JumpGame.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/056-MergeIntervals.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/056-MergeIntervals.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/057-InsertInterval.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/057-InsertInterval.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/058-LengthOfLastWord.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/058-LengthOfLastWord.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/059-SpiralMatrix2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/059-SpiralMatrix2.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/060-PermutationSequence.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/060-PermutationSequence.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/061-RotateList.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/061-RotateList.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/062-UniquePaths.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/062-UniquePaths.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/063-UniquePaths2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/063-UniquePaths2.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/064-MinimumPathSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/064-MinimumPathSum.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/065-ValidNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/065-ValidNumber.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/066-PlusOne.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/066-PlusOne.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/067-AddBinary.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/067-AddBinary.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/068-TextJustification.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/068-TextJustification.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/069-Sqrt(x).cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/069-Sqrt(x).cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/070-ClimbingStairs.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/070-ClimbingStairs.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/071-SimplifyPath.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/071-SimplifyPath.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/072-EditDistance.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/072-EditDistance.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/073-SetMatrixZeroes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/073-SetMatrixZeroes.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/074-SearchA2DMatrix.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/074-SearchA2DMatrix.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/075-SortColors.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/075-SortColors.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/076-MinimumWindowSubstring.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/076-MinimumWindowSubstring.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/077-Combinations.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/077-Combinations.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/078-Subsets.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/078-Subsets.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/079-WordSearch.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/079-WordSearch.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/085-MaximalRectangle.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/085-MaximalRectangle.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/086-PartitionList.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/086-PartitionList.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/087-ScrambleString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/087-ScrambleString.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/088-MergeSortedArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/088-MergeSortedArray.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/089-GrayCode.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/089-GrayCode.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/090-Subsets2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/090-Subsets2.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/091-DecodeWays.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/091-DecodeWays.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/092-ReverseLinkedList2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/092-ReverseLinkedList2.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/093-RestoreIPAddresses.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/093-RestoreIPAddresses.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/095-UniqueBinarySearchTree2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/095-UniqueBinarySearchTree2.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/096-UniqueBinarySearchTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/096-UniqueBinarySearchTree.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/097-InterleavingString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/097-InterleavingString.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/098-ValidateBinarySearchTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/098-ValidateBinarySearchTree.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/099-RecoverBinarySearchTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/099-RecoverBinarySearchTree.cs -------------------------------------------------------------------------------- /LeetCode/0051-0100/100-SameTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0051-0100/100-SameTree.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0124-BinaryTreeMaximumPathSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0124-BinaryTreeMaximumPathSum.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0125-ValidPalindrome.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0125-ValidPalindrome.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0126-WordLadderII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0126-WordLadderII.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0127-WordLadder.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0127-WordLadder.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0129-SumRootToLeafNumbers.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0129-SumRootToLeafNumbers.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0130-SurroundedRegions.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0130-SurroundedRegions.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0131-PalindromePartitioning.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0131-PalindromePartitioning.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0133-CloneGraph.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0133-CloneGraph.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0134-GasStation.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0134-GasStation.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0136-SingleNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0136-SingleNumber.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0137-SingleNumberII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0137-SingleNumberII.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0139-WordBreak.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0139-WordBreak.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0140-WordBreakII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0140-WordBreakII.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0141-LinkedListCycle.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0141-LinkedListCycle.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0143-ReorderList.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0143-ReorderList.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0146-LRUCache.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0146-LRUCache.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/0148-SortList.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/0148-SortList.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/101-SymmetricTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/101-SymmetricTree.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/104-MaximumDepthOfBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/104-MaximumDepthOfBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/110-BalancedBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/110-BalancedBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/111-MinimumDepthOfBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/111-MinimumDepthOfBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/112-PathSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/112-PathSum.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/113-PathSum2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/113-PathSum2.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/115-DistinctSubsequences.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/115-DistinctSubsequences.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/118-PascalsTriangle.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/118-PascalsTriangle.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/119-PascalsTriangle2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/119-PascalsTriangle2.cs -------------------------------------------------------------------------------- /LeetCode/0101-0150/120-Triangle.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0101-0150/120-Triangle.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0151-ReverseWordsInAString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0151-ReverseWordsInAString.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0152-MaximumProductSubarray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0152-MaximumProductSubarray.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0155-MinStack.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0155-MinStack.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0162-FindPeakElement.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0162-FindPeakElement.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0165-CompareVersionNumbers.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0165-CompareVersionNumbers.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0167-TwoSumII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0167-TwoSumII.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0168-ExcelSheetColumnTitle.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0168-ExcelSheetColumnTitle.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0169-MajorityElement.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0169-MajorityElement.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0171-ExcelSheetColumnNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0171-ExcelSheetColumnNumber.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0172-FactorialTrailingZeroes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0172-FactorialTrailingZeroes.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0173-BinarySearchTreeIterator.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0173-BinarySearchTreeIterator.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0174-DungeonGame.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0174-DungeonGame.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0179-LargestNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0179-LargestNumber.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0189-RotateArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0189-RotateArray.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0190-ReverseBits.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0190-ReverseBits.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0191-NumberOf1Bits.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0191-NumberOf1Bits.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0198-HouseRobber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0198-HouseRobber.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0199-BinaryTreeRightSideView.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0199-BinaryTreeRightSideView.cs -------------------------------------------------------------------------------- /LeetCode/0151-0200/0200-NumberOfIslands.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0151-0200/0200-NumberOfIslands.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0201-BitwiseANDOfNumbersRange.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0201-BitwiseANDOfNumbersRange.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0202-HappyNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0202-HappyNumber.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0203-RemoveLinkedListElements.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0203-RemoveLinkedListElements.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0204-CountPrimes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0204-CountPrimes.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0205-IsomorphicStrings.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0205-IsomorphicStrings.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0206-ReverseLinkedList.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0206-ReverseLinkedList.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0207-CourseSchedule.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0207-CourseSchedule.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0208-ImplementTrie.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0208-ImplementTrie.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0209-MinimumSizeSubarraySum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0209-MinimumSizeSubarraySum.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0210-CourseScheduleII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0210-CourseScheduleII.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0212-WordSearchII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0212-WordSearchII.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0213-HouseRobberII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0213-HouseRobberII.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0216-CombinationSumIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0216-CombinationSumIII.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0217-ContainsDuplicate.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0217-ContainsDuplicate.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0218-TheSkylineProblem.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0218-TheSkylineProblem.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0219-ContainsDuplicateII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0219-ContainsDuplicateII.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0220-ContainsDuplicateIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0220-ContainsDuplicateIII.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0221-MaximalSquare.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0221-MaximalSquare.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0222-CountCompleteTreeNodes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0222-CountCompleteTreeNodes.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0224-BasicCalculator.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0224-BasicCalculator.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0226-InvertBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0226-InvertBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0227-BasicCalculatorII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0227-BasicCalculatorII.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0229-MajorityElementII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0229-MajorityElementII.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0230-KthSmallestElementInABST.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0230-KthSmallestElementInABST.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0231-PowerOfTwo.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0231-PowerOfTwo.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0234-PalindromeLinkedList.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0234-PalindromeLinkedList.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0237-DeleteNodeInALinkedList.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0237-DeleteNodeInALinkedList.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0238-ProductOfArrayExceptSelf.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0238-ProductOfArrayExceptSelf.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0239-SlidingWindowMaximum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0239-SlidingWindowMaximum.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0240-SearchA2DMatrixII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0240-SearchA2DMatrixII.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0242-ValidAnagram.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0242-ValidAnagram.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0243-ShortestWordDistance.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0243-ShortestWordDistance.cs -------------------------------------------------------------------------------- /LeetCode/0201-0250/0246-StrobogrammaticNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0201-0250/0246-StrobogrammaticNumber.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0252-MeetingRooms.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0252-MeetingRooms.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0253-MeetingRoomsII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0253-MeetingRoomsII.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0256-PaintHouse.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0256-PaintHouse.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0257-BinaryTreePaths.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0257-BinaryTreePaths.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0258-AddDigits.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0258-AddDigits.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0260-SingleNumberIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0260-SingleNumberIII.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0263-UglyNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0263-UglyNumber.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0264-UglyNumberII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0264-UglyNumberII.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0266-PalindromePermutation.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0266-PalindromePermutation.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0268-MissingNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0268-MissingNumber.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0269-AlienDictionary.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0269-AlienDictionary.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0271-EncodeAndDecodeStrings.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0271-EncodeAndDecodeStrings.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0273-IntegerToEnglishWords.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0273-IntegerToEnglishWords.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0274-HIndex.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0274-HIndex.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0275-HIndexII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0275-HIndexII.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0276-PaintFence.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0276-PaintFence.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0278-FirstBadVersion.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0278-FirstBadVersion.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0279-PerfectSquares.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0279-PerfectSquares.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0280-WiggleSort.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0280-WiggleSort.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0283-MoveZeroes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0283-MoveZeroes.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0285-InorderSuccessorInBST.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0285-InorderSuccessorInBST.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0287-FindTheDuplicateNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0287-FindTheDuplicateNumber.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0289-GameOfLife.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0289-GameOfLife.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0290-WordPattern.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0290-WordPattern.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0292-NimGame.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0292-NimGame.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0293-FlipGame.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0293-FlipGame.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0295-FindMedianFromDataStream.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0295-FindMedianFromDataStream.cs -------------------------------------------------------------------------------- /LeetCode/0251-0300/0299-BullsAndCows.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0251-0300/0299-BullsAndCows.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0301-RemoveInvalidParentheses.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0301-RemoveInvalidParentheses.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0303-RangeSumQueryImmutable.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0303-RangeSumQueryImmutable.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0305-NumberOfIslandsII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0305-NumberOfIslandsII.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0312-BurstBalloons.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0312-BurstBalloons.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0316-RemoveDuplicateLetters.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0316-RemoveDuplicateLetters.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0322-CoinChange.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0322-CoinChange.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0326-PowerOfThree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0326-PowerOfThree.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0327-CountOfRangeSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0327-CountOfRangeSum.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0328-OddEvenLinkedList.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0328-OddEvenLinkedList.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0332-ReconstructItinerary.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0332-ReconstructItinerary.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0336-PalindromePairs.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0336-PalindromePairs.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0338-CountingBits.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0338-CountingBits.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0339-NestedListWeightSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0339-NestedListWeightSum.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0342-PowerOfFour.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0342-PowerOfFour.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0344-ReverseString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0344-ReverseString.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0345-ReverseVowelsOfAString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0345-ReverseVowelsOfAString.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0347-TopKFrequentElements.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0347-TopKFrequentElements.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0348-DesignTicTacToe.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0348-DesignTicTacToe.cs -------------------------------------------------------------------------------- /LeetCode/0301-0350/0349-IntersectionOfTwoArrays.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0301-0350/0349-IntersectionOfTwoArrays.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0355-DesignTwitter.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0355-DesignTwitter.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0359-LoggerRateLimiter.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0359-LoggerRateLimiter.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0362-DesignHitCounter.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0362-DesignHitCounter.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0364-NestedListWeightSumII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0364-NestedListWeightSumII.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0366-FindLeavesOfBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0366-FindLeavesOfBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0367-ValidPerfectSquare.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0367-ValidPerfectSquare.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0368-LargestDivisibleSubset.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0368-LargestDivisibleSubset.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0370-RangeAddition.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0370-RangeAddition.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0371-SumOfTwoIntegers.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0371-SumOfTwoIntegers.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0374-GuessNumberHigherOrLower.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0374-GuessNumberHigherOrLower.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0380-InsertDeleteGetRandom.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0380-InsertDeleteGetRandom.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0383-RansomNote.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0383-RansomNote.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0389-FindTheDifference.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0389-FindTheDifference.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0392-IsSubsequence.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0392-IsSubsequence.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0393-UTF8Validation.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0393-UTF8Validation.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0394-DecodeString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0394-DecodeString.cs -------------------------------------------------------------------------------- /LeetCode/0351-0400/0399-EvaluateDivision.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0351-0400/0399-EvaluateDivision.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0401-BinaryWatch.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0401-BinaryWatch.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0402-RemoveKDigits.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0402-RemoveKDigits.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0403-FrogJump.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0403-FrogJump.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0404-SumOfLeftLeaves.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0404-SumOfLeftLeaves.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0408-ValidWordAbbreviation.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0408-ValidWordAbbreviation.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0409-LongestPalindrome.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0409-LongestPalindrome.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0410-SplitArrayLargestSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0410-SplitArrayLargestSum.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0412-FizzBuzz.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0412-FizzBuzz.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0414-ThirdMaximumNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0414-ThirdMaximumNumber.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0415-AddStrings.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0415-AddStrings.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0416-PartitionEqualSubsetSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0416-PartitionEqualSubsetSum.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0419-BattleshipsInABoard.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0419-BattleshipsInABoard.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0420-StrongPasswordChecker.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0420-StrongPasswordChecker.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0422-ValidWordSquare.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0422-ValidWordSquare.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0425-WordSquares.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0425-WordSquares.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0427-ConstructQuadTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0427-ConstructQuadTree.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0432-AllOOneDataStructure.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0432-AllOOneDataStructure.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0435-NonOverlappingIntervals.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0435-NonOverlappingIntervals.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0436-FindRightInterval.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0436-FindRightInterval.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0437-PathSumIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0437-PathSumIII.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0438-FindAllAnagramsInAString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0438-FindAllAnagramsInAString.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0441-ArrangingCoins.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0441-ArrangingCoins.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0443-StringCompression.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0443-StringCompression.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0445-AddTwoNumbersII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0445-AddTwoNumbersII.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0447-NumberOfBoomerangs.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0447-NumberOfBoomerangs.cs -------------------------------------------------------------------------------- /LeetCode/0401-0450/0450-DeleteNodeInABST.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0401-0450/0450-DeleteNodeInABST.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0455-AssignCookies.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0455-AssignCookies.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0458-PoorPigs.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0458-PoorPigs.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0459-RepeatedSubstringPattern.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0459-RepeatedSubstringPattern.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0460-LFUCache.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0460-LFUCache.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0461-HammingDistance.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0461-HammingDistance.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0463-IslandPerimeter.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0463-IslandPerimeter.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0465-OptimalAccountBalancing.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0465-OptimalAccountBalancing.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0468-ValidateIPAddress.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0468-ValidateIPAddress.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0472-ConcatenatedWords.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0472-ConcatenatedWords.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0475-Heaters.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0475-Heaters.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0476-NumberComplement.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0476-NumberComplement.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0480-SlidingWindowMedian.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0480-SlidingWindowMedian.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0482-LicenseKeyFormatting.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0482-LicenseKeyFormatting.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0484-FindPermutation.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0484-FindPermutation.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0485-MaxConsecutiveOnes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0485-MaxConsecutiveOnes.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0489-RobotRoomCleaner.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0489-RobotRoomCleaner.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0490-TheMaze.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0490-TheMaze.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0492-ConstructTheRectangle.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0492-ConstructTheRectangle.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0493-ReversePairs.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0493-ReversePairs.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0495-TeemoAttacking.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0495-TeemoAttacking.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0496-NextGreaterElementI.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0496-NextGreaterElementI.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0498-DiagonalTraverse.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0498-DiagonalTraverse.cs -------------------------------------------------------------------------------- /LeetCode/0451-0500/0500-KeyboardRow.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0451-0500/0500-KeyboardRow.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0503-NextGreaterElementII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0503-NextGreaterElementII.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0504-Base7.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0504-Base7.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0506-RelativeRanks.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0506-RelativeRanks.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0507-PerfectNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0507-PerfectNumber.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0509-FibonacciNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0509-FibonacciNumber.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0510-InorderSuccessorInBSTII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0510-InorderSuccessorInBSTII.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0513-FindBottomLeftTreeValue.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0513-FindBottomLeftTreeValue.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0518-CoinChange2.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0518-CoinChange2.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0520-DetectCapital.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0520-DetectCapital.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0523-ContinuousSubarraySum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0523-ContinuousSubarraySum.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0525-ContiguousArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0525-ContiguousArray.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0528-RandomPickWithWeight.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0528-RandomPickWithWeight.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0529-Minesweeper.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0529-Minesweeper.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0532-KDiffPairsInAnArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0532-KDiffPairsInAnArray.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0535-EncodeAndDecodeTinyURL.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0535-EncodeAndDecodeTinyURL.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0538-ConvertBSTToGreaterTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0538-ConvertBSTToGreaterTree.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0541-ReverseStringII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0541-ReverseStringII.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0543-DiameterOfBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0543-DiameterOfBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0544-OutputContestMatches.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0544-OutputContestMatches.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0545-BoundaryOfBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0545-BoundaryOfBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0501-0550/0547-FriendCircles.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0501-0550/0547-FriendCircles.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0551-StudentAttendanceRecordI.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0551-StudentAttendanceRecordI.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0557-ReverseWordsInAStringIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0557-ReverseWordsInAStringIII.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0559-MaximumDepthOfNAryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0559-MaximumDepthOfNAryTree.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0560-SubarraySumEqualsK.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0560-SubarraySumEqualsK.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0561-ArrayPartitionI.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0561-ArrayPartitionI.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0563-BinaryTreeTilt.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0563-BinaryTreeTilt.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0566-ReshapeTheMatrix.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0566-ReshapeTheMatrix.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0567-PermutationInString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0567-PermutationInString.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0572-SubtreeOfAnotherTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0572-SubtreeOfAnotherTree.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0575-DistributeCandies.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0575-DistributeCandies.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0582-KillProcess.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0582-KillProcess.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0588-DesignInMemoryFileSystem.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0588-DesignInMemoryFileSystem.cs -------------------------------------------------------------------------------- /LeetCode/0551-0600/0598-RangeAdditionII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0551-0600/0598-RangeAdditionII.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0605-CanPlaceFlowers.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0605-CanPlaceFlowers.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0616-AddBoldTagInString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0616-AddBoldTagInString.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0617-MergeTwoBinaryTrees.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0617-MergeTwoBinaryTrees.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0621-TaskScheduler.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0621-TaskScheduler.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0624-MaximumDistanceInArrays.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0624-MaximumDistanceInArrays.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0633-SumOfSquareNumbers.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0633-SumOfSquareNumbers.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0636-ExclusiveTimeOfFunctions.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0636-ExclusiveTimeOfFunctions.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0643-MaximumAverageSubarrayI.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0643-MaximumAverageSubarrayI.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0645-SetMismatch.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0645-SetMismatch.cs -------------------------------------------------------------------------------- /LeetCode/0601-0650/0647-PalindromicSubstrings.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0601-0650/0647-PalindromicSubstrings.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0653-TwoSumIVInputIsABST.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0653-TwoSumIVInputIsABST.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0654-MaximumBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0654-MaximumBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0657-RobotReturnToOrigin.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0657-RobotReturnToOrigin.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0661-ImageSmoother.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0661-ImageSmoother.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0665-NonDecreasingArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0665-NonDecreasingArray.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0669-TrimABinarySearchTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0669-TrimABinarySearchTree.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0680-ValidPalindromeII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0680-ValidPalindromeII.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0681-NextClosestTime.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0681-NextClosestTime.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0682-BaseballGame.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0682-BaseballGame.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0683-KEmptySlots.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0683-KEmptySlots.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0686-RepeatedStringMatch.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0686-RepeatedStringMatch.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0687-LongestUnivaluePath.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0687-LongestUnivaluePath.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0690-EmployeeImportance.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0690-EmployeeImportance.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0692-TopKFrequentWords.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0692-TopKFrequentWords.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0695-MaxAreaOfIsland.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0695-MaxAreaOfIsland.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0696-CountBinarySubstrings.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0696-CountBinarySubstrings.cs -------------------------------------------------------------------------------- /LeetCode/0651-0700/0697-DegreeOfAnArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0651-0700/0697-DegreeOfAnArray.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0704-BinarySearch.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0704-BinarySearch.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0705-DesignHashset.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0705-DesignHashset.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0706-DesignHashmap.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0706-DesignHashmap.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0709-ToLowerCase.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0709-ToLowerCase.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0715-RangeModule.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0715-RangeModule.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0716-MaxStack.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0716-MaxStack.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0717-1BitAnd2BitCharacters.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0717-1BitAnd2BitCharacters.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0721-AccountsMerge.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0721-AccountsMerge.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0722-RemoveComments.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0722-RemoveComments.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0723-CandyCrush.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0723-CandyCrush.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0724-FindPivotIndex.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0724-FindPivotIndex.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0726-NumberOfAtoms.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0726-NumberOfAtoms.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0728-SelfDividingNumbers.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0728-SelfDividingNumbers.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0733-FloodFill.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0733-FloodFill.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0734-SentenceSimilarity.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0734-SentenceSimilarity.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0735-AsteroidCollision.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0735-AsteroidCollision.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0739-DailyTemperatures.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0739-DailyTemperatures.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0743-NetworkDelayTime.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0743-NetworkDelayTime.cs -------------------------------------------------------------------------------- /LeetCode/0701-0750/0746-MinCostClimbingStairs.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0701-0750/0746-MinCostClimbingStairs.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0751-IPToCIDR.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0751-IPToCIDR.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0753-CrackingtheSafe.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0753-CrackingtheSafe.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0758-BoldWordsInString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0758-BoldWordsInString.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0759-EmployeeFreeTime.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0759-EmployeeFreeTime.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0760-FindAnagramMappings.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0760-FindAnagramMappings.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0763-PartitionLabels.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0763-PartitionLabels.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0765-CouplesHoldingHands.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0765-CouplesHoldingHands.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0766-ToeplitzMatrix.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0766-ToeplitzMatrix.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0767-ReorganizeString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0767-ReorganizeString.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0771-JewelsAndStones.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0771-JewelsAndStones.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0772-BasicCalculatorIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0772-BasicCalculatorIII.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0773-SlidingPuzzle.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0773-SlidingPuzzle.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0780-ReachingPoints.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0780-ReachingPoints.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0784-LetterCasePermutation.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0784-LetterCasePermutation.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0788-RotatedDigits.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0788-RotatedDigits.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0791-CustomSortString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0791-CustomSortString.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0794-ValidTicTacToeState.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0794-ValidTicTacToeState.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0796-RotateString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0796-RotateString.cs -------------------------------------------------------------------------------- /LeetCode/0751-0800/0800-SimilarRGBColor.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0751-0800/0800-SimilarRGBColor.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0804-UniqueMorseCodeWords.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0804-UniqueMorseCodeWords.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0809-ExpressiveWords.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0809-ExpressiveWords.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0811-SubdomainVisitCount.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0811-SubdomainVisitCount.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0812-LargestTriangleArea.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0812-LargestTriangleArea.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0814-BinaryTreePruning.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0814-BinaryTreePruning.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0818-RaceCar.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0818-RaceCar.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0819-MostCommonWord.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0819-MostCommonWord.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0824-GoatLatin.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0824-GoatLatin.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0829-ConsecutiveNumbersSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0829-ConsecutiveNumbersSum.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0832-FlippingAnImage.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0832-FlippingAnImage.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0835-ImageOverlap.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0835-ImageOverlap.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0836-RectangleOverlap.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0836-RectangleOverlap.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0837-New21Game.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0837-New21Game.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0840-MagicSquaresInGrid.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0840-MagicSquaresInGrid.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0841-KeysAndRooms.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0841-KeysAndRooms.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0843-GuesstheWord.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0843-GuesstheWord.cs -------------------------------------------------------------------------------- /LeetCode/0801-0850/0846-HandOfStraights.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0801-0850/0846-HandOfStraights.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0856-ScoreOfParentheses.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0856-ScoreOfParentheses.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0859-BuddyStrings.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0859-BuddyStrings.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0860-LemonadeChange.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0860-LemonadeChange.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0867-TransposeMatrix.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0867-TransposeMatrix.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0868-BinaryGap.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0868-BinaryGap.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0872-LeafSimilarTrees.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0872-LeafSimilarTrees.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0876-MiddleOfTheLinkedList.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0876-MiddleOfTheLinkedList.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0877-StoneGame.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0877-StoneGame.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0885-SpiralMatrixIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0885-SpiralMatrixIII.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0886-PossibleBipartition.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0886-PossibleBipartition.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0888-FairCandySwap.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0888-FairCandySwap.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0890-FindAndReplacePattern.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0890-FindAndReplacePattern.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0892-SurfaceAreaOf3DShapes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0892-SurfaceAreaOf3DShapes.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0895-MaximumFrequencyStack.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0895-MaximumFrequencyStack.cs -------------------------------------------------------------------------------- /LeetCode/0851-0900/0896-MonotonicArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0851-0900/0896-MonotonicArray.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0901-OnlineStockSpan.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0901-OnlineStockSpan.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0904-FruitIntoBaskets.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0904-FruitIntoBaskets.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0905-SortArrayByParity.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0905-SortArrayByParity.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0908-SmallestRangeI.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0908-SmallestRangeI.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0912-SortAnArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0912-SortAnArray.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0913-CatAndMouse.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0913-CatAndMouse.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0917-ReverseOnlyLetters.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0917-ReverseOnlyLetters.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0922-SortArrayByParityII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0922-SortArrayByParityII.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0925-LongPressedName.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0925-LongPressedName.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0929-UniqueEmailAddresses.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0929-UniqueEmailAddresses.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0931-MinimumFallingPathSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0931-MinimumFallingPathSum.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0933-NumberOfRecentCalls.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0933-NumberOfRecentCalls.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0937-ReorderDataInLogFiles.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0937-ReorderDataInLogFiles.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0938-RangeSumOfBST.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0938-RangeSumOfBST.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0939-MinimumAreaRectangle.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0939-MinimumAreaRectangle.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0941-ValidMountainArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0941-ValidMountainArray.cs -------------------------------------------------------------------------------- /LeetCode/0901-0950/0942-DIStringMatch.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0901-0950/0942-DIStringMatch.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0957-PrisonCellsAfterNDays.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0957-PrisonCellsAfterNDays.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0959-RegionsCutBySlashes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0959-RegionsCutBySlashes.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0965-UnivaluedBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0965-UnivaluedBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0969-PancakeSorting.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0969-PancakeSorting.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0970-PowerfulIntegers.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0970-PowerfulIntegers.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0975-OddEvenJump.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0975-OddEvenJump.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0977-SquaresOfASortedArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0977-SquaresOfASortedArray.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0980-UniquePathsIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0980-UniquePathsIII.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0983-MinimumCostForTickets.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0983-MinimumCostForTickets.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0993-CousinsInBinaryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0993-CousinsInBinaryTree.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0994-RottingOranges.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0994-RottingOranges.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0997-FindTheTownJudge.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0997-FindTheTownJudge.cs -------------------------------------------------------------------------------- /LeetCode/0951-1000/0998-MaximumBinaryTreeII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/0951-1000/0998-MaximumBinaryTreeII.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1002-FindCommonCharacters.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1002-FindCommonCharacters.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1024-VideoStitching.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1024-VideoStitching.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1025-DivisorGame.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1025-DivisorGame.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1029-TwoCityScheduling.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1029-TwoCityScheduling.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1032-StreamOfCharacters.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1032-StreamOfCharacters.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1035-UncrossedLines.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1035-UncrossedLines.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1037-ValidBoomerang.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1037-ValidBoomerang.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1041-RobotBoundedInCircle.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1041-RobotBoundedInCircle.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1046-LastStoneWeight.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1046-LastStoneWeight.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/1048-LongestStringChain.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/1048-LongestStringChain.cs -------------------------------------------------------------------------------- /LeetCode/1001-1050/HashMap.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1001-1050/HashMap.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1051-HeightChecker.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1051-HeightChecker.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1056-ConfusingNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1056-ConfusingNumber.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1057-CampusBikes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1057-CampusBikes.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1064-FixedPoint.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1064-FixedPoint.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1065-IndexPairsOfAString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1065-IndexPairsOfAString.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1066-CampusBikesII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1066-CampusBikesII.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1086-HighFive.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1086-HighFive.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1087-BraceExpansion.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1087-BraceExpansion.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1089-DuplicateZeros.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1089-DuplicateZeros.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1094-CarPooling.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1094-CarPooling.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1096-BraceExpansionII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1096-BraceExpansionII.cs -------------------------------------------------------------------------------- /LeetCode/1051-1100/1099-TwoSumLessThanK.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1051-1100/1099-TwoSumLessThanK.cs -------------------------------------------------------------------------------- /LeetCode/1101-1150/1108-DefangingAnIPAddress.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1101-1150/1108-DefangingAnIPAddress.cs -------------------------------------------------------------------------------- /LeetCode/1101-1150/1114-PrintInOrder.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1101-1150/1114-PrintInOrder.cs -------------------------------------------------------------------------------- /LeetCode/1101-1150/1118-NumberOfDaysInAMonth.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1101-1150/1118-NumberOfDaysInAMonth.cs -------------------------------------------------------------------------------- /LeetCode/1101-1150/1120-MaximumAverageSubtree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1101-1150/1120-MaximumAverageSubtree.cs -------------------------------------------------------------------------------- /LeetCode/1101-1150/1122-RelativeSortArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1101-1150/1122-RelativeSortArray.cs -------------------------------------------------------------------------------- /LeetCode/1101-1150/1133-LargestUniqueNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1101-1150/1133-LargestUniqueNumber.cs -------------------------------------------------------------------------------- /LeetCode/1101-1150/1134-ArmstrongNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1101-1150/1134-ArmstrongNumber.cs -------------------------------------------------------------------------------- /LeetCode/1101-1150/1137-NThTribonacciNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1101-1150/1137-NThTribonacciNumber.cs -------------------------------------------------------------------------------- /LeetCode/1101-1150/1140-StoneGameII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1101-1150/1140-StoneGameII.cs -------------------------------------------------------------------------------- /LeetCode/1151-1200/1154-DayOfTheYear.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1151-1200/1154-DayOfTheYear.cs -------------------------------------------------------------------------------- /LeetCode/1151-1200/1165-SingleRowKeyboard.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1151-1200/1165-SingleRowKeyboard.cs -------------------------------------------------------------------------------- /LeetCode/1151-1200/1175-PrimeArrangements.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1151-1200/1175-PrimeArrangements.cs -------------------------------------------------------------------------------- /LeetCode/1151-1200/1176-DietPlanPerformance.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1151-1200/1176-DietPlanPerformance.cs -------------------------------------------------------------------------------- /LeetCode/1151-1200/1185-DayOfTheWeek.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1151-1200/1185-DayOfTheWeek.cs -------------------------------------------------------------------------------- /LeetCode/1151-1200/1197-MinimumKnightMoves.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1151-1200/1197-MinimumKnightMoves.cs -------------------------------------------------------------------------------- /LeetCode/1201-1250/1214-TwoSumBsts.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1201-1250/1214-TwoSumBsts.cs -------------------------------------------------------------------------------- /LeetCode/1201-1250/1217-PlayWithChips.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1201-1250/1217-PlayWithChips.cs -------------------------------------------------------------------------------- /LeetCode/1201-1250/1219-PathWithMaximumGold.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1201-1250/1219-PathWithMaximumGold.cs -------------------------------------------------------------------------------- /LeetCode/1201-1250/1229-MeetingScheduler.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1201-1250/1229-MeetingScheduler.cs -------------------------------------------------------------------------------- /LeetCode/1201-1250/1236-WebCrawler.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1201-1250/1236-WebCrawler.cs -------------------------------------------------------------------------------- /LeetCode/1201-1250/1243-ArrayTransformation.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1201-1250/1243-ArrayTransformation.cs -------------------------------------------------------------------------------- /LeetCode/1201-1250/1245-TreeDiameter.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1201-1250/1245-TreeDiameter.cs -------------------------------------------------------------------------------- /LeetCode/1251-1300/1254-NumberOfClosedIslands.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1251-1300/1254-NumberOfClosedIslands.cs -------------------------------------------------------------------------------- /LeetCode/1251-1300/1256-EncodeNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1251-1300/1256-EncodeNumber.cs -------------------------------------------------------------------------------- /LeetCode/1251-1300/1258-SynonymousSentences.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1251-1300/1258-SynonymousSentences.cs -------------------------------------------------------------------------------- /LeetCode/1251-1300/1260-Shift2DGrid.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1251-1300/1260-Shift2DGrid.cs -------------------------------------------------------------------------------- /LeetCode/1251-1300/1271-Hexspeak.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1251-1300/1271-Hexspeak.cs -------------------------------------------------------------------------------- /LeetCode/1251-1300/1273-DeleteTreeNodes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1251-1300/1273-DeleteTreeNodes.cs -------------------------------------------------------------------------------- /LeetCode/1251-1300/1291-SequentialDigits.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1251-1300/1291-SequentialDigits.cs -------------------------------------------------------------------------------- /LeetCode/1301-1350/1302-DeepestLeavesSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1301-1350/1302-DeepestLeavesSum.cs -------------------------------------------------------------------------------- /LeetCode/1301-1350/1306-JumpGameIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1301-1350/1306-JumpGameIII.cs -------------------------------------------------------------------------------- /LeetCode/1301-1350/1310-XORQueriesOfASubarray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1301-1350/1310-XORQueriesOfASubarray.cs -------------------------------------------------------------------------------- /LeetCode/1301-1350/1314-MatrixBlockSum.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1301-1350/1314-MatrixBlockSum.cs -------------------------------------------------------------------------------- /LeetCode/1301-1350/1323-Maximum69Numberr.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1301-1350/1323-Maximum69Numberr.cs -------------------------------------------------------------------------------- /LeetCode/1351-1400/1375-BulbSwitcherIII.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1351-1400/1375-BulbSwitcherIII.cs -------------------------------------------------------------------------------- /LeetCode/1351-1400/1380-LuckyNumbersInAMatrix.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1351-1400/1380-LuckyNumbersInAMatrix.cs -------------------------------------------------------------------------------- /LeetCode/1351-1400/1395-CountNumberOfTeams.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1351-1400/1395-CountNumberOfTeams.cs -------------------------------------------------------------------------------- /LeetCode/1351-1400/1399-CountLargestGroup.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1351-1400/1399-CountLargestGroup.cs -------------------------------------------------------------------------------- /LeetCode/1401-1450/1417-ReformatTheString.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1401-1450/1417-ReformatTheString.cs -------------------------------------------------------------------------------- /LeetCode/1401-1450/1426-CountingElements.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1401-1450/1426-CountingElements.cs -------------------------------------------------------------------------------- /LeetCode/1401-1450/1427-PerformStringShifts.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1401-1450/1427-PerformStringShifts.cs -------------------------------------------------------------------------------- /LeetCode/1401-1450/1429-FirstUniqueNumber.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1401-1450/1429-FirstUniqueNumber.cs -------------------------------------------------------------------------------- /LeetCode/1401-1450/1436-DestinationCity.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1401-1450/1436-DestinationCity.cs -------------------------------------------------------------------------------- /LeetCode/1401-1450/1446-ConsecutiveCharacters.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1401-1450/1446-ConsecutiveCharacters.cs -------------------------------------------------------------------------------- /LeetCode/1401-1450/1447-SimplifiedFractions.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1401-1450/1447-SimplifiedFractions.cs -------------------------------------------------------------------------------- /LeetCode/1451-1500/1469-FindAllTheLonelyNodes.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1451-1500/1469-FindAllTheLonelyNodes.cs -------------------------------------------------------------------------------- /LeetCode/1451-1500/1470-ShuffleTheArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1451-1500/1470-ShuffleTheArray.cs -------------------------------------------------------------------------------- /LeetCode/1451-1500/1472-DesignBrowserHistory.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1451-1500/1472-DesignBrowserHistory.cs -------------------------------------------------------------------------------- /LeetCode/1451-1500/1476-SubrectangleQueries.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1451-1500/1476-SubrectangleQueries.cs -------------------------------------------------------------------------------- /LeetCode/1451-1500/1480-RunningSumOf1DArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1451-1500/1480-RunningSumOf1DArray.cs -------------------------------------------------------------------------------- /LeetCode/1451-1500/1486-XOROperationInAnArray.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1451-1500/1486-XOROperationInAnArray.cs -------------------------------------------------------------------------------- /LeetCode/1451-1500/1490-CloneNAryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1451-1500/1490-CloneNAryTree.cs -------------------------------------------------------------------------------- /LeetCode/1451-1500/1492-TheKthFactorOfN.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1451-1500/1492-TheKthFactorOfN.cs -------------------------------------------------------------------------------- /LeetCode/1451-1500/1496-PathCrossing.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1451-1500/1496-PathCrossing.cs -------------------------------------------------------------------------------- /LeetCode/1501-1550/1506-FindRootOfNAryTree.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1501-1550/1506-FindRootOfNAryTree.cs -------------------------------------------------------------------------------- /LeetCode/1501-1550/1507-ReformatDate.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1501-1550/1507-ReformatDate.cs -------------------------------------------------------------------------------- /LeetCode/1501-1550/1512-NumberOfGoodPairs.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1501-1550/1512-NumberOfGoodPairs.cs -------------------------------------------------------------------------------- /LeetCode/1501-1550/1518-WaterBottles.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/1501-1550/1518-WaterBottles.cs -------------------------------------------------------------------------------- /LeetCode/Interval.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/Interval.cs -------------------------------------------------------------------------------- /LeetCode/LeetCode.csproj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/LeetCode.csproj -------------------------------------------------------------------------------- /LeetCode/ListNode.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/ListNode.cs -------------------------------------------------------------------------------- /LeetCode/Properties/AssemblyInfo.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/Properties/AssemblyInfo.cs -------------------------------------------------------------------------------- /LeetCode/TreeLinkNode.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/TreeLinkNode.cs -------------------------------------------------------------------------------- /LeetCode/TreeNode.cs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/LeetCode/TreeNode.cs -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/A-Hemeda/LeetCode-Challenges-CSharp/HEAD/README.md --------------------------------------------------------------------------------