├── .github
└── workflows
│ └── swift.yml
├── .gitignore
├── .ruby-version
├── .swiftlint.yml
├── Algorithms
├── Algorithms.xcodeproj
│ ├── project.pbxproj
│ ├── project.xcworkspace
│ │ ├── contents.xcworkspacedata
│ │ └── xcshareddata
│ │ │ └── IDEWorkspaceChecks.plist
│ └── xcshareddata
│ │ └── xcschemes
│ │ └── Algorithms.xcscheme
├── Algorithms
│ ├── Algorithms
│ │ ├── Array
│ │ │ ├── Permutations.swift
│ │ │ └── Subarray.swift
│ │ ├── Graph
│ │ │ ├── BFS.swift
│ │ │ ├── DFS.swift
│ │ │ ├── Dijkstra.swift
│ │ │ ├── Kruskal.swift
│ │ │ ├── Prim.swift
│ │ │ └── TopologicalSort.swift
│ │ ├── Searching
│ │ │ └── BinarySearch.swift
│ │ ├── Sorting
│ │ │ ├── BubbleSort.swift
│ │ │ ├── CountingSort.swift
│ │ │ ├── HeapSort.swift
│ │ │ ├── InsertionSort.swift
│ │ │ ├── MergeSort.swift
│ │ │ ├── QuickSort.swift
│ │ │ ├── RadixSort.swift
│ │ │ └── SelectionSort.swift
│ │ └── String
│ │ │ ├── Subsequence.swift
│ │ │ └── Substring.swift
│ ├── DataStructures
│ │ ├── BinarySearchTree.swift
│ │ ├── Heap.swift
│ │ ├── LinkedList.swift
│ │ ├── PriorityQueue.swift
│ │ └── UnionFind.swift
│ └── Helpers
│ │ ├── BinaryTreeNode.swift
│ │ └── ListNode.swift
└── AlgorithmsTests
│ ├── Algorithms
│ ├── BFSTests.swift
│ ├── BinarySearchTests.swift
│ ├── BubbleSortTests.swift
│ ├── CountingSortTests.swift
│ ├── DFSTests.swift
│ ├── DijkstraTests.swift
│ ├── HeapSortTests.swift
│ ├── InsertionSortTests.swift
│ ├── KruskalTests.swift
│ ├── LinkedListTests.swift
│ ├── MergeSortTests.swift
│ ├── PermutationsTests.swift
│ ├── PrimTests.swift
│ ├── QuickSortTests.swift
│ ├── RadixSortTests.swift
│ ├── SelectionSortTests.swift
│ ├── SubarrayTests.swift
│ ├── SubsequenceTests.swift
│ ├── SubstringTests.swift
│ └── TopologicalSortTests.swift
│ └── DataStructures
│ ├── BinarySearchTreeTests.swift
│ ├── HeapTests.swift
│ └── PriorityQueueTests.swift
├── CodingChallenges.xcodeproj
├── project.pbxproj
├── project.xcworkspace
│ ├── contents.xcworkspacedata
│ └── xcshareddata
│ │ └── IDEWorkspaceChecks.plist
└── xcshareddata
│ ├── xcbaselines
│ └── 4353DA511CDB868200A07167.xcbaseline
│ │ ├── 21C99C31-EBD9-4F03-B063-BCC26E413925.plist
│ │ └── Info.plist
│ └── xcschemes
│ └── CodingChallenges.xcscheme
├── CodingChallenges.xcworkspace
├── contents.xcworkspacedata
└── xcshareddata
│ ├── IDETemplateMacros.plist
│ └── IDEWorkspaceChecks.plist
├── CodingChallenges
├── AppDelegate
│ └── AppDelegate.swift
├── Resources
│ ├── Images
│ │ └── Assets.xcassets
│ │ │ ├── AppIcon.appiconset
│ │ │ └── Contents.json
│ │ │ └── Contents.json
│ └── StoryBoards
│ │ └── Base.lproj
│ │ └── LaunchScreen.storyboard
├── SupportingFiles
│ └── Info.plist
└── ViewControllers
│ └── Questions
│ └── QuestionsViewController.swift
├── CodingChallengesTests
└── Info.plist
├── CrackingTheCodingInterview
├── CrackingTheCodingInterview.xcodeproj
│ ├── project.pbxproj
│ ├── project.xcworkspace
│ │ ├── contents.xcworkspacedata
│ │ └── xcshareddata
│ │ │ └── IDEWorkspaceChecks.plist
│ └── xcshareddata
│ │ └── xcschemes
│ │ └── CrackingTheCodingInterview.xcscheme
├── CrackingTheCodingInterview
│ └── Challenges
│ │ ├── Chapter 1
│ │ ├── OffByOne
│ │ │ └── OffByOne.swift
│ │ └── PalindromePermutation
│ │ │ └── PalindromePermutation.swift
│ │ ├── Chapter 2
│ │ ├── CircularLinkedList
│ │ │ └── CircularLinkedList.swift
│ │ └── IntersectingNode
│ │ │ ├── LinkedListIntersectingNode.swift
│ │ │ ├── LinkedListNode.swift
│ │ │ └── SingleLinkedList.swift
│ │ ├── Chapter 3
│ │ ├── MinStack
│ │ │ └── MinStack.swift
│ │ ├── QueueViaStacks
│ │ │ └── QueueViaStacks.swift
│ │ └── StackOfPlates
│ │ │ ├── StackOfPlates.swift
│ │ │ ├── StackOfPlatesNode.swift
│ │ │ └── StackOfPlatesStack.swift
│ │ └── Chapter 4
│ │ ├── BalancedBST
│ │ └── BalancedBST.swift
│ │ ├── BinarySearchTreeDepth
│ │ ├── BinarySearchTreeDepth.swift
│ │ ├── BinarySearchTreeDepthNode.swift
│ │ └── LinkedList
│ │ │ ├── BinarySearchTreeDepthLinkedList.swift
│ │ │ └── BinarySearchTreeDepthLinkedListNode.swift
│ │ ├── BuildOrder
│ │ ├── ProjectBuildOrder.swift
│ │ └── ProjectBuildOrderNode.swift
│ │ ├── Helpers
│ │ └── TreeNodeCtCI.swift
│ │ ├── MinimalTree
│ │ ├── MinimalBinarySearchTree.swift
│ │ └── MinimalBinarySearchTreeNode.swift
│ │ ├── RoutePlanner
│ │ ├── RoutePlanner.swift
│ │ ├── RoutePlannerNode.swift
│ │ └── RoutePlannerQueue.swift
│ │ ├── SuccessorBST
│ │ └── SuccessorBST.swift
│ │ └── ValidateBST
│ │ └── ValidateBST.swift
└── CrackingTheCodingInterviewTests
│ └── Tests
│ ├── Chapter 1
│ ├── OffByOneTests.swift
│ └── PalindromePermutationTests.swift
│ ├── Chapter 2
│ ├── CircularLinkedListTests.swift
│ └── LinkedListIntersectingNodeTests.swift
│ ├── Chapter 3
│ ├── MinStackTests.swift
│ ├── QueueViaStacksTests.swift
│ └── StackOfPlatesTests.swift
│ └── Chapter 4
│ ├── BalancedBSTTests.swift
│ ├── BinarySearchTreeDepthTests.swift
│ ├── MinimalBinarySearchTreeTests.swift
│ ├── ProjectBuildOrderTests.swift
│ ├── RoutePlannerTests.swift
│ ├── SuccessorBSTTests.swift
│ └── ValidateBSTTests.swift
├── Gemfile
├── Gemfile.lock
├── HackerRank
├── HackerRank.xcodeproj
│ ├── project.pbxproj
│ ├── project.xcworkspace
│ │ ├── contents.xcworkspacedata
│ │ └── xcshareddata
│ │ │ └── IDEWorkspaceChecks.plist
│ └── xcshareddata
│ │ └── xcschemes
│ │ └── HackerRank.xcscheme
├── HackerRank
│ └── Challenges
│ │ ├── ACMICPCTeam.swift
│ │ ├── AngryProfessor.swift
│ │ ├── AppleAndOrange.swift
│ │ ├── BFSShortReach.swift
│ │ ├── Beast.swift
│ │ ├── BiggerIsGreater.swift
│ │ ├── BirthdayBar.swift
│ │ ├── BirthdayCakeCandles.swift
│ │ ├── BreakingTheRecords.swift
│ │ ├── CaesarCipher.swift
│ │ ├── CavityMap.swift
│ │ ├── ChocolateFeast.swift
│ │ ├── CompareTheTriplets.swift
│ │ ├── CutTheSticks.swift
│ │ ├── DikshasBirthday.swift
│ │ ├── DivisibleSumPairs.swift
│ │ ├── Encryption.swift
│ │ ├── EvenTree.swift
│ │ ├── FindDigits.swift
│ │ ├── GradingStudents.swift
│ │ ├── GridSearch.swift
│ │ ├── IceCreamParlor.swift
│ │ ├── InsertionSort1.swift
│ │ ├── InsertionSort2.swift
│ │ ├── Kangaroo.swift
│ │ ├── Kaprekar.swift
│ │ ├── LarrysArray.swift
│ │ ├── LibraryFine.swift
│ │ ├── LisasWorkbook.swift
│ │ ├── MagicSquare.swift
│ │ ├── ManasaAndStones.swift
│ │ ├── MaximizeSum.swift
│ │ ├── MaximumSubarray.swift
│ │ ├── MigratoryBirds.swift
│ │ ├── MinMaxSum.swift
│ │ ├── MissingNumbers.swift
│ │ ├── NewYearChaos.swift
│ │ ├── OrganizingContainersOfBalls.swift
│ │ ├── Percentages.swift
│ │ ├── PrimsMST.swift
│ │ ├── Quicksort1Partition.swift
│ │ ├── QuicksortInPlace.swift
│ │ ├── RunningTime.swift
│ │ ├── SaveThePrisoner.swift
│ │ ├── ServiceLane.swift
│ │ ├── SherlockAndArray.swift
│ │ ├── SherlockSquares.swift
│ │ ├── SortingIntro.swift
│ │ ├── Staircase.swift
│ │ ├── Summing.swift
│ │ ├── TimeConverter.swift
│ │ ├── TimeInWords.swift
│ │ └── UtopianTree.swift
└── HackerRankTests
│ └── Tests
│ ├── ACMICPCTeamTests.swift
│ ├── AngryProfessorTests.swift
│ ├── AppleAndOrange.swift
│ ├── BFSShortReachTests.swift
│ ├── BeastTests.swift
│ ├── BiggerIsGreaterTests.swift
│ ├── BirthdayBarTests.swift
│ ├── BirthdayCakeCandlesTests.swift
│ ├── BreakingTheRecordsTests.swift
│ ├── CaesarCipherTests.swift
│ ├── CavityMapTests.swift
│ ├── ChocolateFeastTests.swift
│ ├── CompareTheTripletsTests.swift
│ ├── CutTheSticksTests.swift
│ ├── DikshasBirthdayTests.swift
│ ├── DivisibleSumPairsTests.swift
│ ├── EncryptionTests.swift
│ ├── EvenTreeTests.swift
│ ├── FindDigitsTests.swift
│ ├── GradingStudentsTests.swift
│ ├── GridSearchTests.swift
│ ├── IceCreamParlorTests.swift
│ ├── InsertionSort1Tests.swift
│ ├── InsertionSort2Tests.swift
│ ├── KangarooTests.swift
│ ├── KaprekarTests.swift
│ ├── LarrysArrayTests.swift
│ ├── LibraryFineTests.swift
│ ├── LisasWorkbookTests.swift
│ ├── MagicSqaureTests.swift
│ ├── ManasaAndStonesTests.swift
│ ├── MaximizeSumTests.swift
│ ├── MaximumSubarrayTests.swift
│ ├── MigratoryBirdsTests.swift
│ ├── MinMaxSumTests.swift
│ ├── MissingNumbersTests.swift
│ ├── NewYearChaosTests.swift
│ ├── OrganizingContainersOfBallsTests.swift
│ ├── PercentagesTests.swift
│ ├── PrimsMSTTests.swift
│ ├── QuickSortTests.swift
│ ├── QuicksortInPlaceTests.swift
│ ├── RunningTimeTests.swift
│ ├── SaveThePrisonerTests.swift
│ ├── ServiceLaneTests.swift
│ ├── SherlockAndArrayTests.swift
│ ├── SherlockSquaresTests.swift
│ ├── SortingIntroTests.swift
│ ├── StaircaseTests.swift
│ ├── SummingTests.swift
│ ├── TimeConverterTests.swift
│ ├── TimeInWordsTests.swift
│ └── UtopianTreeTests.swift
├── LICENSE
├── LeetCode
├── LeetCode.xcodeproj
│ ├── project.pbxproj
│ ├── project.xcworkspace
│ │ ├── contents.xcworkspacedata
│ │ └── xcshareddata
│ │ │ └── IDEWorkspaceChecks.plist
│ └── xcshareddata
│ │ └── xcschemes
│ │ └── LeetCode.xcscheme
├── LeetCode
│ ├── Challenges
│ │ ├── AccountsMerge.swift
│ │ ├── AddBinary.swift
│ │ ├── AddDigits.swift
│ │ ├── AddOneRowToTree.swift
│ │ ├── AddStrings.swift
│ │ ├── AddTwoNumbers.swift
│ │ ├── AdditiveNumber.swift
│ │ ├── AllElementsInTwoBinarySearchTrees.swift
│ │ ├── AllNodesDistanceKInBinaryTree.swift
│ │ ├── AllPathsFromSourceLeadToDestination.swift
│ │ ├── AllPathsFromSourceToTarget.swift
│ │ ├── AmountOfTimeForBinaryTreeToBeInfected.swift
│ │ ├── AnalyzeUserWebsiteVisitPattern.swift
│ │ ├── ApplyOperationsToAnArray.swift
│ │ ├── ArrangingCoins.swift
│ │ ├── ArrayWithElementsNotEqualToAverageOfNeighbors.swift
│ │ ├── AsFarFromLandAsPossible.swift
│ │ ├── AssignCookies.swift
│ │ ├── AsteroidCollision.swift
│ │ ├── AverageOfLevelsInBinaryTree.swift
│ │ ├── BSTIterator.swift
│ │ ├── BackspaceStringCompare.swift
│ │ ├── BalanceABinarySearchTree.swift
│ │ ├── BalancedBinaryTree.swift
│ │ ├── BaseballGame.swift
│ │ ├── BasicCalculatorII.swift
│ │ ├── BattleshipsInABoard.swift
│ │ ├── BeautifulTowersI.swift
│ │ ├── BestTimeToBuyAndSellStock.swift
│ │ ├── BestTimeToBuyAndSellStockII.swift
│ │ ├── BinarySearch.swift
│ │ ├── BinarySearchTreeToGreaterSumTree.swift
│ │ ├── BinaryTreeColoringGame.swift
│ │ ├── BinaryTreeInorderTraversal.swift
│ │ ├── BinaryTreeLevelOrderTraversal.swift
│ │ ├── BinaryTreeLevelOrderTraversalII.swift
│ │ ├── BinaryTreeLongestConsecutiveSequence.swift
│ │ ├── BinaryTreeLongestConsecutiveSequenceII.swift
│ │ ├── BinaryTreePaths.swift
│ │ ├── BinaryTreePostorderTraversal.swift
│ │ ├── BinaryTreePreorderTraversal.swift
│ │ ├── BinaryTreePruning.swift
│ │ ├── BinaryTreeRightSideView.swift
│ │ ├── BinaryTreeTilt.swift
│ │ ├── BinaryTreeVerticalOrderTraversal.swift
│ │ ├── BinaryTreeZigzagLevelOrderTraversal.swift
│ │ ├── BoatsToSavePeople.swift
│ │ ├── BoundaryOfBinaryTree.swift
│ │ ├── BrickWall.swift
│ │ ├── BuddyStrings.swift
│ │ ├── BuildingsWithOceanView.swift
│ │ ├── BullsAndCows.swift
│ │ ├── CanPlaceFlowers.swift
│ │ ├── CapacityToShipPackagesWithinDDays.swift
│ │ ├── CarFleet.swift
│ │ ├── CarPooling.swift
│ │ ├── CheapestFlightsWithinKStops.swift
│ │ ├── CheckCompletenessOfABinaryTree.swift
│ │ ├── CheckIfANumberIsMajorityElementInASortedArray.swift
│ │ ├── CheckIfAStringContainsAllBinaryCodesOfSizeK.swift
│ │ ├── CheckIfAWordOccursAsAPrefixOfAnyWordInASentence.swift
│ │ ├── CheckIfMoveIsLegal.swift
│ │ ├── CheckIfNAndItsDoubleExist.swift
│ │ ├── CheckIfStringIsAPrefixOfArray.swift
│ │ ├── CheckIfWordIsValidAfterSubstitutions.swift
│ │ ├── CircularArrayLoop.swift
│ │ ├── ClimbingStairs.swift
│ │ ├── CloneBinaryTreeWithRandomPointer.swift
│ │ ├── CloneGraph.swift
│ │ ├── ClosestBinarySearchTreeValue.swift
│ │ ├── ClosestLeafInABinaryTree.swift
│ │ ├── ClosestNodesQueriesInABinarySearchTree.swift
│ │ ├── ClumsyFactorial.swift
│ │ ├── CoinChange .swift
│ │ ├── CombinationSum.swift
│ │ ├── CombinationSumII.swift
│ │ ├── CombinationSumIII.swift
│ │ ├── Combinations.swift
│ │ ├── CompareVersionNumbers.swift
│ │ ├── ConcatenationOfArray.swift
│ │ ├── ConsecutiveCharacters.swift
│ │ ├── ConstructBinarySearchTreeFromPreorderTraversal.swift
│ │ ├── ConstructBinaryTreeFromString.swift
│ │ ├── ConstructBinaryTreeInorderPostorderTraversal.swift
│ │ ├── ConstructBinaryTreePreorderInorderTraversal.swift
│ │ ├── ConstructSmallestNumberFromDIString.swift
│ │ ├── ConstructStringFromBinaryTree.swift
│ │ ├── ContainerWithMostWater.swift
│ │ ├── ContainsDuplicate.swift
│ │ ├── ContainsDuplicateII.swift
│ │ ├── ContiguousArray.swift
│ │ ├── ContinuousSubarraySum.swift
│ │ ├── ConvertBSTToGreaterTree.swift
│ │ ├── ConvertBinaryNumberInALinkedListToInteger.swift
│ │ ├── ConvertBinarySearchTreeToSortedDoublyLinkedList.swift
│ │ ├── ConvertSortedArrayToBinarySearchTree.swift
│ │ ├── ConvertSortedListToBinarySearchTree.swift
│ │ ├── CopyListWithRandomPointer.swift
│ │ ├── CountBinarySubstrings.swift
│ │ ├── CountCompleteTreeNodes.swift
│ │ ├── CountGoodNodesInBinaryTree.swift
│ │ ├── CountNegativeNumbersInASortedMatrix.swift
│ │ ├── CountNodesEqualToAverageOfSubtree.swift
│ │ ├── CountNodesEqualToSumOfDescendants.swift
│ │ ├── CountNodesWithTheHighestScore.swift
│ │ ├── CountNumberOfHomogenousSubstrings.swift
│ │ ├── CountPairsWhoseSumIsLessThanTarget.swift
│ │ ├── CountSortedVowelStrings.swift
│ │ ├── CountSubIslands.swift
│ │ ├── CountTheNumberOfIncremovableSubarraysI.swift
│ │ ├── CountUnivalueSubtrees.swift
│ │ ├── CountUnreachablePairsOfNodesInAnUndirectedGraph.swift
│ │ ├── CourseSchedule.swift
│ │ ├── CourseScheduleII.swift
│ │ ├── CousinsInBinaryTree.swift
│ │ ├── CousinsInBinaryTreeII.swift
│ │ ├── CrawlerLogFolder.swift
│ │ ├── CreateBinaryTreeFromDescriptions.swift
│ │ ├── CustomSortString.swift
│ │ ├── CuttingRibbons.swift
│ │ ├── DIStringMatch.swift
│ │ ├── DailyTemperatures.swift
│ │ ├── DecodeString.swift
│ │ ├── DecodeWays.swift
│ │ ├── DeepestLeavesSum.swift
│ │ ├── DeleteLeavesWithAGivenValue.swift
│ │ ├── DeleteNNodesAfterMNodesOfALinkedList.swift
│ │ ├── DeleteNodeInABST.swift
│ │ ├── DeleteNodeInALinkedList.swift
│ │ ├── DeleteNodesAndReturnForest.swift
│ │ ├── DeleteTheMiddleNodeOfALinkedList.swift
│ │ ├── DestroyingAsteroids.swift
│ │ ├── DetermineIfACellIsReachableAtAGivenTime.swift
│ │ ├── DetermineWhetherMatrixCanBeObtainedByRotation.swift
│ │ ├── DetonateTheMaximumBombs.swift
│ │ ├── DiagonalTraverse.swift
│ │ ├── DiameterOfBinaryTree.swift
│ │ ├── DiameterOfNAryTree.swift
│ │ ├── DistributeCoinsInBinaryTree.swift
│ │ ├── DivideArrayInSetsOfKConsecutiveNumbers.swift
│ │ ├── DivideTwoIntegers.swift
│ │ ├── DotProductOfTwoSparseVectors.swift
│ │ ├── DuplicateZeros.swift
│ │ ├── EarliestMomentWhenEveryoneBecomeFriends.swift
│ │ ├── EliminateMaximumNumberOfMonsters.swift
│ │ ├── EqualTreePartition.swift
│ │ ├── EvaluateBooleanBinaryTree.swift
│ │ ├── EvaluateReversePolishNotation.swift
│ │ ├── EvenOddTree.swift
│ │ ├── ExcelSheetColumnNumber.swift
│ │ ├── ExclusiveTimeOfFunctions.swift
│ │ ├── FairCandySwap.swift
│ │ ├── FaultySensor.swift
│ │ ├── FibonacciNumber.swift
│ │ ├── FinalPricesWithSpecialDiscount.swift
│ │ ├── FindAllAnagramsInAString.swift
│ │ ├── FindAllGroupsOfFarmland.swift
│ │ ├── FindAllKDistantIndicesInAnArray.swift
│ │ ├── FindAllNumbersDisappearedInAnArray.swift
│ │ ├── FindAllTheLonelyNodes.swift
│ │ ├── FindBottomLeftTreeValue.swift
│ │ ├── FindClosestNodeToGivenTwoNodes.swift
│ │ ├── FindDistanceInABinaryTree.swift
│ │ ├── FindDuplicateNumber.swift
│ │ ├── FindDuplicateSubtrees.swift
│ │ ├── FindEventualSafeStates.swift
│ │ ├── FindFirstAndLastPositionOfElementInSortedArray.swift
│ │ ├── FindFirstPalindromicStringInTheArray.swift
│ │ ├── FindIfPathExistsInGraph.swift
│ │ ├── FindIndicesWithIndexAndValueDifferenceI.swift
│ │ ├── FindKClosestElements.swift
│ │ ├── FindLargestValueInEachTreeRow.swift
│ │ ├── FindLeavesOfBinaryTree.swift
│ │ ├── FindMinimumRotatedSortedArray.swift
│ │ ├── FindMinimumRotatedSortedArrayII.swift
│ │ ├── FindModeInBinarySearchTree.swift
│ │ ├── FindNearestRightNodeInBinaryTree.swift
│ │ ├── FindPeakElement.swift
│ │ ├── FindPivotIndex.swift
│ │ ├── FindSmallestCommonElementInAllRows.swift
│ │ ├── FindSmallestLetterGreaterThanTarget.swift
│ │ ├── FindTargetIndicesAfterSortingArray.swift
│ │ ├── FindTheArrayConcatenationValue.swift
│ │ ├── FindTheDifferenceOfTwoArrays.swift
│ │ ├── FindTheDistanceValueBetweenTwoArrays.swift
│ │ ├── FindTheIndexOfTheFirstOccurrenceInAString.swift
│ │ ├── FindTheLexicographicallySmallestValidSequence.swift
│ │ ├── FindTheMinimumAndMaximumNumberOfNodesBetweenCriticalPoints.swift
│ │ ├── FindTheTownJudge.swift
│ │ ├── FirstBadVersion.swift
│ │ ├── FixedPoint.swift
│ │ ├── FlattenBinaryTreeToLinkedList.swift
│ │ ├── FlipBinaryTreeToMatchPreorderTraversal.swift
│ │ ├── FlipEquivalentBinaryTrees.swift
│ │ ├── FlippingAnImage.swift
│ │ ├── FloodFill.swift
│ │ ├── FrequencyOfTheMostFrequentElement.swift
│ │ ├── FruitIntoBaskets.swift
│ │ ├── GameOfLife.swift
│ │ ├── GasStation.swift
│ │ ├── GenerateParentheses.swift
│ │ ├── GoatLatin.swift
│ │ ├── GraphValidTree.swift
│ │ ├── GridGame.swift
│ │ ├── GroupAnagrams.swift
│ │ ├── GroupShiftedStrings.swift
│ │ ├── GuessNumberHigherOrLower.swift
│ │ ├── HandOfStraights.swift
│ │ ├── HappyNumber.swift
│ │ ├── Heaters.swift
│ │ ├── HouseRobber.swift
│ │ ├── HouseRobberII.swift
│ │ ├── HouseRobberIII.swift
│ │ ├── ImplementStackUsingQueues.swift
│ │ ├── ImplementStrStr.swift
│ │ ├── IncreasingOrderSearchTree.swift
│ │ ├── IncreasingTripletSubsequence.swift
│ │ ├── InsertInterval.swift
│ │ ├── InsertIntoABinarySearchTree.swift
│ │ ├── InsertIntoASortedCircularLinkedList.swift
│ │ ├── InsertionSortList.swift
│ │ ├── InsufficientNodesInRootToLeafPaths.swift
│ │ ├── IntegerToRoman.swift
│ │ ├── InterleavingString.swift
│ │ ├── IntersectionOfThreeSortedArrays.swift
│ │ ├── IntersectionOfTwoArrays.swift
│ │ ├── IntersectionOfTwoArraysII.swift
│ │ ├── IntersectionOfTwoLinkedLists.swift
│ │ ├── IntervalListIntersections.swift
│ │ ├── InvertBinaryTree.swift
│ │ ├── IsGraphBipartite.swift
│ │ ├── IsSubsequence.swift
│ │ ├── IslandPerimeter.swift
│ │ ├── IsomorphicStrings.swift
│ │ ├── JumpGame.swift
│ │ ├── JumpGameII.swift
│ │ ├── KClosestPointsToOrigin.swift
│ │ ├── KDiffPairsInAnArray.swift
│ │ ├── KeysAndRooms.swift
│ │ ├── KokoEatingBananas.swift
│ │ ├── KthLargestElementInArray.swift
│ │ ├── KthMissingPositiveNumber.swift
│ │ ├── KthSmallestElementInBinarySearchTree.swift
│ │ ├── KthSmallestPrimeFraction.swift
│ │ ├── KthSymbolInGrammar.swift
│ │ ├── LargestBSTSubtree.swift
│ │ ├── LargestNumber.swift
│ │ ├── LargestPositiveIntegerThatExistsWithItsNegative.swift
│ │ ├── LeafSimilarTrees.swift
│ │ ├── LeftmostColumnWithAtLeastAOne.swift
│ │ ├── LengthOfLastWord.swift
│ │ ├── LetterCombinationsOfAPhoneNumber.swift
│ │ ├── LexicographicallySmallestPalindrome.swift
│ │ ├── LinkedListCycle.swift
│ │ ├── LinkedListCycleII.swift
│ │ ├── LinkedListFrequency.swift
│ │ ├── LinkedListInBinaryTree.swift
│ │ ├── LongPressedName.swift
│ │ ├── LongestAbsoluteFilePath.swift
│ │ ├── LongestArithmeticSubsequenceOfGivenDifference.swift
│ │ ├── LongestCommonPrefix.swift
│ │ ├── LongestConsecutiveSequence.swift
│ │ ├── LongestIncreasingSubsequence.swift
│ │ ├── LongestPalindromicSubstring.swift
│ │ ├── LongestRepeatingCharacterReplacement.swift
│ │ ├── LongestSubsequenceWithLimitedSum.swift
│ │ ├── LongestSubstringWithAtMostTwoDistinctCharacters.swift
│ │ ├── LongestSubstringWithoutRepeatingCharacters.swift
│ │ ├── LongestUncommonSubsequenceII.swift
│ │ ├── LongestUnivaluePath.swift
│ │ ├── LongestWordInDictionaryThroughDeleting.swift
│ │ ├── LongestZigZagPathInABinaryTree.swift
│ │ ├── LowestCommonAncestorBinarySearchTree.swift
│ │ ├── LowestCommonAncestorBinaryTree.swift
│ │ ├── LowestCommonAncestorBinaryTreeII.swift
│ │ ├── LowestCommonAncestorBinaryTreeIII.swift
│ │ ├── LowestCommonAncestorOfDeepestLeaves.swift
│ │ ├── MajorityElement.swift
│ │ ├── MajorityElementII.swift
│ │ ├── MakeCostsOfPathsEqualInABinaryTree.swift
│ │ ├── MakeTheStringGreat.swift
│ │ ├── Matrix01.swift
│ │ ├── MaxAreaOfIsland.swift
│ │ ├── MaxConsecutiveOnesIII.swift
│ │ ├── MaxNumberOfKSumPairs.swift
│ │ ├── MaximalRangeThatEachElementIsMaximumInIt.swift
│ │ ├── MaximizeTheConfusionOfAnExam.swift
│ │ ├── MaximumAverageSubtree.swift
│ │ ├── MaximumBinaryTree.swift
│ │ ├── MaximumBinaryTreeII.swift
│ │ ├── MaximumCoinsHeroesCanCollect.swift
│ │ ├── MaximumCountOfPositiveIntegerAndNegativeInteger.swift
│ │ ├── MaximumDepthBinaryTree.swift
│ │ ├── MaximumDifferenceBetweenNodeAndAncestor.swift
│ │ ├── MaximumEnemyFortsThatCanBeCaptured.swift
│ │ ├── MaximumLengthOfPairChain.swift
│ │ ├── MaximumLevelSumOfABinaryTree.swift
│ │ ├── MaximumNestingDepthOfTheParentheses.swift
│ │ ├── MaximumNumberOfBalloons.swift
│ │ ├── MaximumNumberOfFishInAGrid.swift
│ │ ├── MaximumNumberOfRemovableCharacters.swift
│ │ ├── MaximumNumberOfVowelsInASubstringOfGivenLength.swift
│ │ ├── MaximumProductOfTheLengthOfTwoPalindromicSubsequences.swift
│ │ ├── MaximumProductSubarray.swift
│ │ ├── MaximumSubarray.swift
│ │ ├── MaximumSwap.swift
│ │ ├── MaximumTwinSumOfALinkedList.swift
│ │ ├── MaximumWidthOfBinaryTree.swift
│ │ ├── MeetingRooms.swift
│ │ ├── MeetingRoomsII.swift
│ │ ├── MergeInBetweenLinkedLists.swift
│ │ ├── MergeIntervals.swift
│ │ ├── MergeKSortedLists.swift
│ │ ├── MergeSortedArray.swift
│ │ ├── MergeStringsAlternately.swift
│ │ ├── MergeTripletsToFormTargetTriplet.swift
│ │ ├── MergeTwo2DArraysBySummingValues.swift
│ │ ├── MergeTwoBinaryTrees.swift
│ │ ├── MergeTwoSortedLists.swift
│ │ ├── MiddleOfLinkedList.swift
│ │ ├── MinCostToConnectAllPoints.swift
│ │ ├── Minesweeper.swift
│ │ ├── MiniParser.swift
│ │ ├── MinimumAbsoluteDifferenceInBST.swift
│ │ ├── MinimumAddToMakeParenthesesValid.swift
│ │ ├── MinimumAverageOfSmallestAndLargestElements.swift
│ │ ├── MinimumCommonValue.swift
│ │ ├── MinimumDepthOfBinaryTree.swift
│ │ ├── MinimumDifferenceBetweenHighestAndLowestOfKScore.swift
│ │ ├── MinimumDistanceBetweenBSTNodes.swift
│ │ ├── MinimumFuelCostToReportToTheCapital.swift
│ │ ├── MinimumHeightTrees.swift
│ │ ├── MinimumNumberOfFlipsToMakeTheBinaryStringAlternating.swift
│ │ ├── MinimumNumberOfSwapsToMakeTheStringBalanced.swift
│ │ ├── MinimumNumberOfVerticesToReachAllNodes.swift
│ │ ├── MinimumOperationsToReduceXToZero.swift
│ │ ├── MinimumPairRemovalToSortArrayI.swift
│ │ ├── MinimumPenaltyForAShop.swift
│ │ ├── MinimumRemoveToMakeValidParentheses.swift
│ │ ├── MinimumScoreOfAPathBetweenTwoCities.swift
│ │ ├── MinimumSizeSubarraySum.swift
│ │ ├── MinimumStringLengthAfterRemovingSubstrings.swift
│ │ ├── MinimumValueToGetPositive.swift
│ │ ├── MissingElementInSortedArray.swift
│ │ ├── MissingNumber.swift
│ │ ├── MissingRanges.swift
│ │ ├── MostFrequentSubtreeSum.swift
│ │ ├── MoveZeroes.swift
│ │ ├── MovingAverage.swift
│ │ ├── MultiplyStrings.swift
│ │ ├── NRepeatedElementInSize2NArray.swift
│ │ ├── NaryTreeLevelOrderTraversal.swift
│ │ ├── NaryTreePostorderTraversal.swift
│ │ ├── NaryTreePreorderTraversal.swift
│ │ ├── NestedListWeightSum.swift
│ │ ├── NestedListWeightSumII.swift
│ │ ├── NetworkDelayTime.swift
│ │ ├── NextGreaterElementI.swift
│ │ ├── NextGreaterElementII.swift
│ │ ├── NextGreaterElementIII.swift
│ │ ├── NextGreaterNodeInLinkedList.swift
│ │ ├── NextPermutation.swift
│ │ ├── NonDecreasingArray.swift
│ │ ├── NonOverlappingIntervals.swift
│ │ ├── NumberOfArithmeticTriplets.swift
│ │ ├── NumberOfClosedIslands.swift
│ │ ├── NumberOfConnectedComponentsInAnUndirectedGraph.swift
│ │ ├── NumberOfDaysBetweenTwoDates.swift
│ │ ├── NumberOfDistinctAverages.swift
│ │ ├── NumberOfDistinctIslands.swift
│ │ ├── NumberOfEnclaves.swift
│ │ ├── NumberOfEquivalentDominoPairs.swift
│ │ ├── NumberOfGoodLeafNodesPairs.swift
│ │ ├── NumberOfIslands.swift
│ │ ├── NumberOfNodesWithValueOne.swift
│ │ ├── NumberOfPairsOfInterchangeableRectangles.swift
│ │ ├── NumberOfProvinces.swift
│ │ ├── NumberOfStudentsUnableToEatLunch.swift
│ │ ├── NumberOfSubarraysOfSizeKAndAverageGreaterThanOrEqualToThreshold.swift
│ │ ├── NumberOfSubarraysWithBoundedMaximum.swift
│ │ ├── NumberOfSubsequencesThatSatisfyTheGivenSumCondition.swift
│ │ ├── NumberOfZeroFilledSubarrays.swift
│ │ ├── OddEvenLinkedList.swift
│ │ ├── OneEditDistance.swift
│ │ ├── OneThreeTwoPattern.swift
│ │ ├── OpenTheLock.swift
│ │ ├── OptimalPartitionOfString.swift
│ │ ├── PacificAtlanticWaterFlow.swift
│ │ ├── PairsOfSongsWithTotalDurationsDivisibleBy60.swift
│ │ ├── PalindromeLinkedList.swift
│ │ ├── PalindromeNumber.swift
│ │ ├── PalindromePartitioning.swift
│ │ ├── PalindromicSubstrings.swift
│ │ ├── PartitionLabels.swift
│ │ ├── PartitionList.swift
│ │ ├── PascalsTriangle.swift
│ │ ├── PascalsTriangleII.swift
│ │ ├── PathSum.swift
│ │ ├── PathSumII.swift
│ │ ├── PathSumIII.swift
│ │ ├── PathSumIV.swift
│ │ ├── PeakIndexMountainArray.swift
│ │ ├── PerfectSquares.swift
│ │ ├── PermutationInString.swift
│ │ ├── Permutations.swift
│ │ ├── PermutationsII.swift
│ │ ├── PlusOne.swift
│ │ ├── PopulatingNextRightPointers.swift
│ │ ├── PopulatingNextRightPointersII.swift
│ │ ├── Pow.swift
│ │ ├── PowerOfThree.swift
│ │ ├── PrintImmutableLinkedListInReverse.swift
│ │ ├── ProductOfArrayExceptSelf.swift
│ │ ├── ProductOfTwoRunLengthEncodedArrays.swift
│ │ ├── PseudoPalindromicPathsInABinaryTree.swift
│ │ ├── PushDominoes.swift
│ │ ├── RandomPickWithWeight.swift
│ │ ├── RandomizedSet.swift
│ │ ├── RangeSumOfBST.swift
│ │ ├── RansomNote.swift
│ │ ├── ReconstructItinerary.swift
│ │ ├── RecoverBinarySearchTree.swift
│ │ ├── RedundantConnection.swift
│ │ ├── RemoveAllAdjacentDuplicatesInString.swift
│ │ ├── RemoveAllAdjacentDuplicatesInStringII.swift
│ │ ├── RemoveCoveredIntervals.swift
│ │ ├── RemoveDuplicateLetters.swift
│ │ ├── RemoveDuplicatesFromAnUnsortedLinkedList.swift
│ │ ├── RemoveDuplicatesFromSortedArray.swift
│ │ ├── RemoveDuplicatesFromSortedArrayII.swift
│ │ ├── RemoveDuplicatesFromSortedList.swift
│ │ ├── RemoveDuplicatesFromSortedListII.swift
│ │ ├── RemoveElement.swift
│ │ ├── RemoveKDigits.swift
│ │ ├── RemoveLinkedListElements.swift
│ │ ├── RemoveNodesFromLinkedList.swift
│ │ ├── RemoveNthNodeFromEndOfList.swift
│ │ ├── RemoveOutermostParentheses.swift
│ │ ├── RemovePalindromicSubsequences.swift
│ │ ├── RemoveZeroSumConsecutiveNodesFromLinkedList.swift
│ │ ├── RemovingStarsFromAString.swift
│ │ ├── ReorderList.swift
│ │ ├── ReorderRoutesToMakeAllPathsLeadToTheCityZero.swift
│ │ ├── RepeatedDNASequences.swift
│ │ ├── ReplaceElementsWithGreatestElementOnRightSide.swift
│ │ ├── RestoreIPAddresses.swift
│ │ ├── RestoreTheArrayFromAdjacentPairs.swift
│ │ ├── ReverseInteger.swift
│ │ ├── ReverseLinkedList.swift
│ │ ├── ReverseLinkedListII.swift
│ │ ├── ReverseNodesInEvenLengthGroups.swift
│ │ ├── ReverseOddLevelsOfBinaryTree.swift
│ │ ├── ReverseOnlyLetters.swift
│ │ ├── ReversePrefixOfWord.swift
│ │ ├── ReverseString.swift
│ │ ├── ReverseStringII.swift
│ │ ├── ReverseVowelsOfAString.swift
│ │ ├── ReverseWordsInAString.swift
│ │ ├── ReverseWordsInAStringII.swift
│ │ ├── ReverseWordsInAStringIII.swift
│ │ ├── RobotRoomCleaner.swift
│ │ ├── RomanToInteger.swift
│ │ ├── RootEqualsSumOfChildren.swift
│ │ ├── RotateArray.swift
│ │ ├── RotateImage.swift
│ │ ├── RotateList.swift
│ │ ├── RottingOranges.swift
│ │ ├── RunningSumOf1DArray.swift
│ │ ├── SameTree.swift
│ │ ├── ScoreOfParentheses.swift
│ │ ├── Search2DMatrix.swift
│ │ ├── Search2DMatrixII.swift
│ │ ├── SearchInABinarySearchTree.swift
│ │ ├── SearchInRotatedSortedArray.swift
│ │ ├── SearchInRotatedSortedArrayII.swift
│ │ ├── SearchInsertPosition.swift
│ │ ├── SearchSortedArrayOfUnknownSize.swift
│ │ ├── SearchSuggestionsSystem.swift
│ │ ├── SecondMinimumNodeInBinaryTree.swift
│ │ ├── SerializeDeserializeBinaryTree.swift
│ │ ├── SetMatrixZeroes.swift
│ │ ├── ShortestBridge.swift
│ │ ├── ShortestDistanceToACharacter.swift
│ │ ├── ShortestPathBinaryMatrix.swift
│ │ ├── ShortestPathWithAlternatingColors.swift
│ │ ├── ShortestUnsortedContinuousSubarray.swift
│ │ ├── ShortestWordDistanceII.swift
│ │ ├── SignOfTheProductOfAnArray.swift
│ │ ├── SimplifyPath.swift
│ │ ├── SingleElementInASortedArray.swift
│ │ ├── SingleNumber .swift
│ │ ├── SmallestStringStartingFromLeaf.swift
│ │ ├── SmallestStringWithSwaps.swift
│ │ ├── SmallestSubtreeWithAllTheDeepestNodes.swift
│ │ ├── SnakesAndLadders.swift
│ │ ├── SortAnArray.swift
│ │ ├── SortArrayByParity.swift
│ │ ├── SortArrayByParityII.swift
│ │ ├── SortCharactersByFrequency.swift
│ │ ├── SortColors.swift
│ │ ├── SortLinkedListAlreadySortedUsingAbsoluteValues.swift
│ │ ├── SortList.swift
│ │ ├── SortTheMatrixDiagonally.swift
│ │ ├── SortTransformedArray.swift
│ │ ├── SpecialArrayWithXElementsGreaterThanOrEqualX.swift
│ │ ├── SpiralMatrix.swift
│ │ ├── SpiralMatrixII.swift
│ │ ├── SplitBST.swift
│ │ ├── SplitLinkedListInParts.swift
│ │ ├── Sqrt.swift
│ │ ├── SquaresOfSortedArray.swift
│ │ ├── StepByStepDirectionsFromABinaryTreeNodeToAnother.swift
│ │ ├── StringCompression.swift
│ │ ├── StringToInteger.swift
│ │ ├── StrobogrammaticNumber.swift
│ │ ├── SubarraySumEqualsK.swift
│ │ ├── SubdomainVisitCount.swift
│ │ ├── Subsets.swift
│ │ ├── SubsetsII.swift
│ │ ├── SubtreeOfAnotherTree.swift
│ │ ├── SuccessfulPairsOfSpellsAndPotions.swift
│ │ ├── SumOfAllOddLengthSubarrays.swift
│ │ ├── SumOfLeftLeaves.swift
│ │ ├── SumOfNodesWithEvenValuedGrandparent.swift
│ │ ├── SumOfRootToLeafBinaryNumbers.swift
│ │ ├── SumOfSquareNumbers.swift
│ │ ├── SumRootToLeafNumbers.swift
│ │ ├── SurroundedRegions.swift
│ │ ├── SwapAdjacentInLRString.swift
│ │ ├── SwapNodesInPairs.swift
│ │ ├── SwappingNodesInALinkedList.swift
│ │ ├── SymmetricTree.swift
│ │ ├── TargetSum.swift
│ │ ├── TernaryExpressionParser.swift
│ │ ├── TheKWeakestRowsInAMatrix.swift
│ │ ├── ThreeSum.swift
│ │ ├── ThreeSumClosest.swift
│ │ ├── ToeplitzMatrix.swift
│ │ ├── TopKFrequentElements.swift
│ │ ├── TrimABinarySearchTree.swift
│ │ ├── TwoSum.swift
│ │ ├── TwoSumBSTs.swift
│ │ ├── TwoSumII.swift
│ │ ├── TwoSumIVInputIsABST.swift
│ │ ├── TwoSumLessThanK.swift
│ │ ├── UglyNumber.swift
│ │ ├── UndergroundSystem.swift
│ │ ├── UniqueBinarySearchTrees.swift
│ │ ├── UniqueEmailAddresses.swift
│ │ ├── UniqueLength3PalindromicSubsequences.swift
│ │ ├── UniquePaths.swift
│ │ ├── UniquePathsII.swift
│ │ ├── UnivaluedBinaryTree.swift
│ │ ├── ValidAnagram.swift
│ │ ├── ValidNumber.swift
│ │ ├── ValidPalindrome.swift
│ │ ├── ValidPalindromeII.swift
│ │ ├── ValidParentheses.swift
│ │ ├── ValidParenthesisString.swift
│ │ ├── ValidPerfectSquare.swift
│ │ ├── ValidSudoku.swift
│ │ ├── ValidTriangleNumber.swift
│ │ ├── ValidWordAbbreviation.swift
│ │ ├── ValidateBinarySearchTree.swift
│ │ ├── ValidateBinaryTreeNodes.swift
│ │ ├── ValidateStackSequences.swift
│ │ ├── VerifyingAnAlienDictionary.swift
│ │ ├── VerticalOrderTraversalOfABinaryTree.swift
│ │ ├── WallsAndGates.swift
│ │ ├── WinnerOfTheLinkedListGame.swift
│ │ ├── WordBreak.swift
│ │ ├── WordPattern.swift
│ │ ├── WordSearch.swift
│ │ └── ZigzagConversion.swift
│ └── Helpers
│ │ ├── BinaryMatrix.swift
│ │ ├── GraphVertice.swift
│ │ ├── GraphWeightedEdge.swift
│ │ ├── Heap.swift
│ │ ├── ImmutableListNode.swift
│ │ ├── ListNode.swift
│ │ ├── ListNodeRandom.swift
│ │ ├── NaryTreeNode.swift
│ │ ├── NestedInteger.swift
│ │ ├── TreeNode.swift
│ │ ├── TreeNodeNext.swift
│ │ ├── TreeNodeParent.swift
│ │ └── TreeNodeRandom.swift
└── LeetCodeTests
│ └── Tests
│ ├── AccountsMergeTests.swift
│ ├── AddBinaryTests.swift
│ ├── AddDigitsTests.swift
│ ├── AddOneRowToTreeTests.swift
│ ├── AddStringsTests.swift
│ ├── AddTwoNumbersTests.swift
│ ├── AdditiveNumberTests.swift
│ ├── AllElementsInTwoBinarySearchTreesTests.swift
│ ├── AllNodesDistanceKInBinaryTreeTests.swift
│ ├── AllPathsFromSourceLeadToDestinationTests.swift
│ ├── AllPathsFromSourceToTargetTests.swift
│ ├── AmountOfTimeForBinaryTreeToBeInfectedTests.swift
│ ├── AnalyzeUserWebsiteVisitPatternTests.swift
│ ├── ApplyOperationsToAnArrayTests.swift
│ ├── ArrangingCoinsTests.swift
│ ├── ArrayWithElementsNotEqualToAverageOfNeighborsTests.swift
│ ├── AsFarFromLandAsPossibleTests.swift
│ ├── AssignCookiesTests.swift
│ ├── AsteroidCollisionTests.swift
│ ├── AverageOfLevelsInBinaryTreeTests.swift
│ ├── BSTIteratorTests.swift
│ ├── BackspaceStringCompareTests.swift
│ ├── BalanceABinarySearchTreeTests.swift
│ ├── BalancedBinaryTreeTests.swift
│ ├── BaseballGameTests.swift
│ ├── BasicCalculatorIITests.swift
│ ├── BattleshipsInABoardTests.swift
│ ├── BeautifulTowersITests.swift
│ ├── BestTimeToBuyAndSellStockIITests.swift
│ ├── BestTimeToBuyAndSellStockTests.swift
│ ├── BinarySearchTests.swift
│ ├── BinarySearchTreeToGreaterSumTreeTests.swift
│ ├── BinaryTreeColoringGameTests.swift
│ ├── BinaryTreeInorderTraversalTests.swift
│ ├── BinaryTreeLevelOrderTraversalIITests.swift
│ ├── BinaryTreeLevelOrderTraversalTests.swift
│ ├── BinaryTreeLongestConsecutiveSequenceIITests.swift
│ ├── BinaryTreeLongestConsecutiveSequenceTests.swift
│ ├── BinaryTreePathsTests.swift
│ ├── BinaryTreePostorderTraversalTests.swift
│ ├── BinaryTreePreorderTraversalTests.swift
│ ├── BinaryTreePruningTests.swift
│ ├── BinaryTreeRightSideViewTests.swift
│ ├── BinaryTreeTiltTests.swift
│ ├── BinaryTreeVerticalOrderTraversalTests.swift
│ ├── BinaryTreeZigzagLevelOrderTraversalTests.swift
│ ├── BoatsToSavePeopleTests.swift
│ ├── BoundaryOfBinaryTreeTests.swift
│ ├── BrickWallTests.swift
│ ├── BuddyStringsTests.swift
│ ├── BuildingsWithOceanViewTests.swift
│ ├── BullsAndCowsTest.swift
│ ├── CanPlaceFlowersTests.swift
│ ├── CapacityToShipPackagesWithinDDaysTests.swift
│ ├── CarFleetTests.swift
│ ├── CarPoolingTests.swift
│ ├── CheapestFlightsWithinKStopsTests.swift
│ ├── CheckCompletenessOfABinaryTreeTests.swift
│ ├── CheckIfANumberIsMajorityElementInASortedArrayTests.swift
│ ├── CheckIfAStringContainsAllBinaryCodesOfSizeKTests.swift
│ ├── CheckIfAWordOccursAsAPrefixOfAnyWordInASentenceTests.swift
│ ├── CheckIfMoveIsLegalTests.swift
│ ├── CheckIfNAndItsDoubleExistTests.swift
│ ├── CheckIfStringIsAPrefixOfArrayTests.swift
│ ├── CheckIfWordIsValidAfterSubstitutionsTests.swift
│ ├── CircularArrayLoopTests.swift
│ ├── ClimbingStairsTests.swift
│ ├── CloneBinaryTreeWithRandomPointerTests.swift
│ ├── CloneGraphTests.swift
│ ├── ClosestBinarySearchTreeValueTests.swift
│ ├── ClosestLeafInABinaryTreeTests.swift
│ ├── ClosestNodesQueriesInABinarySearchTreeTests.swift
│ ├── ClumsyFactorialTests.swift
│ ├── CoinChangeTests.swift
│ ├── CombinationSumIIITests.swift
│ ├── CombinationSumIITests.swift
│ ├── CombinationSumTests.swift
│ ├── CombinationsTests.swift
│ ├── CompareVersionNumbersTests.swift
│ ├── ConcatenationOfArrayTests.swift
│ ├── ConsecutiveCharactersTests.swift
│ ├── ConstructBinarySearchTreeFromPreorderTraversalTests.swift
│ ├── ConstructBinaryTreeFromStringTests.swift
│ ├── ConstructBinaryTreeInorderPostorderTraversalTests.swift
│ ├── ConstructBinaryTreePreorderInorderTraversalTests.swift
│ ├── ConstructSmallestNumberFromDIStringTest.swift
│ ├── ConstructStringFromBinaryTreeTests.swift
│ ├── ContainerWithMostWaterTests.swift
│ ├── ContainsDuplicateIITests.swift
│ ├── ContainsDuplicateTests.swift
│ ├── ContiguousArrayTests.swift
│ ├── ContinuousSubarraySumTests.swift
│ ├── ConvertBSTToGreaterTreeTests.swift
│ ├── ConvertBinaryNumberInALinkedListToIntegerTests.swift
│ ├── ConvertBinarySearchTreeToSortedDoublyLinkedListTests.swift
│ ├── ConvertSortedArrayToBinarySearchTreeTests.swift
│ ├── ConvertSortedListToBinarySearchTreeTests.swift
│ ├── CopyListWithRandomPointerTests.swift
│ ├── CountBinarySubstringsTests.swift
│ ├── CountCompleteTreeNodesTests.swift
│ ├── CountGoodNodesInBinaryTreeTests.swift
│ ├── CountNegativeNumbersInASortedMatrixTests.swift
│ ├── CountNodesEqualToAverageOfSubtreeTests.swift
│ ├── CountNodesEqualToSumOfDescendantsTests.swift
│ ├── CountNodesWithTheHighestScoreTests.swift
│ ├── CountNumberOfHomogenousSubstringsTests.swift
│ ├── CountPairsWhoseSumIsLessThanTargetTests.swift
│ ├── CountSortedVowelStringsTests.swift
│ ├── CountSubIslandsTests.swift
│ ├── CountTheNumberOfIncremovableSubarraysITests.swift
│ ├── CountUnivalueSubtreesTests.swift
│ ├── CountUnreachablePairsOfNodesInAnUndirectedGraphTests.swift
│ ├── CourseScheduleIITests.swift
│ ├── CourseScheduleTests.swift
│ ├── CousinsInBinaryTreeIITests.swift
│ ├── CousinsInBinaryTreeTests.swift
│ ├── CrawlerLogFolderTests.swift
│ ├── CreateBinaryTreeFromDescriptionsTests.swift
│ ├── CustomSortStringTests.swift
│ ├── CuttingRibbonsTests.swift
│ ├── DIStringMatchTests.swift
│ ├── DailyTemperaturesTests.swift
│ ├── DecodeStringTests.swift
│ ├── DeepestLeavesSumTests.swift
│ ├── DeleteLeavesWithAGivenValueTests.swift
│ ├── DeleteNNodesAfterMNodesOfALinkedListTests.swift
│ ├── DeleteNodeInABSTTests.swift
│ ├── DeleteNodeInALinkedListTests.swift
│ ├── DeleteNodesAndReturnForestTests.swift
│ ├── DeleteTheMiddleNodeOfALinkedListTests.swift
│ ├── DestroyingAsteroidsTests.swift
│ ├── DetermineIfACellIsReachableAtAGivenTimeTests.swift
│ ├── DetermineWhetherMatrixCanBeObtainedByRotationTests.swift
│ ├── DetonateTheMaximumBombsTests.swift
│ ├── DiagonalTraverseTests.swift
│ ├── DiameterOfBinaryTreeTests.swift
│ ├── DiameterOfNAryTreeTests.swift
│ ├── DistributeCoinsInBinaryTreeTests.swift
│ ├── DivideArrayInSetsOfKConsecutiveNumbersTests.swift
│ ├── DivideTwoIntegersTests.swift
│ ├── DotProductOfTwoSparseVectorsTests.swift
│ ├── DuplicateZerosTests.swift
│ ├── EarliestMomentWhenEveryoneBecomeFriendsTests.swift
│ ├── EliminateMaximumNumberOfMonstersTests.swift
│ ├── EqualTreePartitionTests.swift
│ ├── EvaluateBooleanBinaryTreeTests.swift
│ ├── EvaluateReversePolishNotationTests.swift
│ ├── EvenOddTreeTests.swift
│ ├── ExcelSheetColumnNumberTests.swift
│ ├── ExclusiveTimeOfFunctionsTests.swift
│ ├── FairCandySwapTests.swift
│ ├── FaultySensorTests.swift
│ ├── FibonacciNumberTests.swift
│ ├── FinalPricesWithSpecialDiscountTests.swift
│ ├── FindAllAnagramsInAStringTests.swift
│ ├── FindAllGroupsOfFarmlandTests.swift
│ ├── FindAllKDistantIndicesInAnArrayTests.swift
│ ├── FindAllNumbersDisappearedInAnArrayTests.swift
│ ├── FindAllTheLonelyNodesTests.swift
│ ├── FindBottomLeftTreeValueTests.swift
│ ├── FindClosestNodeToGivenTwoNodesTests.swift
│ ├── FindDistanceInABinaryTreeTests.swift
│ ├── FindDuplicateNumberTests.swift
│ ├── FindDuplicateSubtreesTests.swift
│ ├── FindEventualSafeStatesTests.swift
│ ├── FindFirstAndLastPositionOfElementInSortedArrayTests.swift
│ ├── FindFirstPalindromicStringInTheArrayTests.swift
│ ├── FindIfPathExistsInGraphTests.swift
│ ├── FindIndicesWithIndexAndValueDifferenceITests.swift
│ ├── FindKClosestElementsTests.swift
│ ├── FindLargestValueInEachTreeRowTests.swift
│ ├── FindLeavesOfBinaryTreeTests.swift
│ ├── FindMinimumRotatedSortedArrayIITests.swift
│ ├── FindMinimumRotatedSortedArrayTests.swift
│ ├── FindModeInBinarySearchTreeTests.swift
│ ├── FindNearestRightNodeInBinaryTreeTests.swift
│ ├── FindPeakElementTests.swift
│ ├── FindPivotIndexTests.swift
│ ├── FindSmallestCommonElementInAllRowsTests.swift
│ ├── FindSmallestLetterGreaterThanTargetTests.swift
│ ├── FindTargetIndicesAfterSortingArrayTests.swift
│ ├── FindTheArrayConcatenationValueTests.swift
│ ├── FindTheDifferenceOfTwoArraysTests.swift
│ ├── FindTheDistanceValueBetweenTwoArraysTests.swift
│ ├── FindTheIndexOfTheFirstOccurrenceInAStringTests.swift
│ ├── FindTheLexicographicallySmallestValidSequenceTests.swift
│ ├── FindTheMinimumAndMaximumNumberOfNodesBetweenCriticalPointsTests.swift
│ ├── FindTheTownJudgeTests.swift
│ ├── FirstBadVersionTests.swift
│ ├── FixedPointTests.swift
│ ├── FlattenBinaryTreeToLinkedListTests.swift
│ ├── FlipBinaryTreeToMatchPreorderTraversalTests.swift
│ ├── FlipEquivalentBinaryTreesTests.swift
│ ├── FlippingAnImageTests.swift
│ ├── FloodFillTests.swift
│ ├── FrequencyOfTheMostFrequentElementTests.swift
│ ├── FruitIntoBasketsTests.swift
│ ├── GameOfLifeTests.swift
│ ├── GasStationTests.swift
│ ├── GenerateParenthesesTests.swift
│ ├── GoatLatinTests.swift
│ ├── GraphValidTreeTests.swift
│ ├── GridGameTests.swift
│ ├── GroupAnagramsTests.swift
│ ├── GroupShiftedStringsTests.swift
│ ├── GuessNumberHigherOrLowerTests.swift
│ ├── HandOfStraightsTests.swift
│ ├── HappyNumberTests.swift
│ ├── HeatersTests.swift
│ ├── HouseRobberIIITests.swift
│ ├── HouseRobberIITests.swift
│ ├── HouseRobberTests.swift
│ ├── ImplementStackUsingQueuesTests.swift
│ ├── ImplementStrStrTests.swift
│ ├── IncreasingOrderSearchTreeTests.swift
│ ├── IncreasingTripletSubsequenceTests.swift
│ ├── InsertIntervalTests.swift
│ ├── InsertIntoABinarySearchTreeTests.swift
│ ├── InsertIntoASortedCircularLinkedListTests.swift
│ ├── InsertionSortListTests.swift
│ ├── InsufficientNodesInRootToLeafPathsTests.swift
│ ├── IntegerToRomanTests.swift
│ ├── InterleavingStringTests.swift
│ ├── IntersectionOfThreeSortedArraysTests.swift
│ ├── IntersectionOfTwoArraysIITests.swift
│ ├── IntersectionOfTwoArraysTests.swift
│ ├── IntersectionOfTwoLinkedListsTests.swift
│ ├── IntervalListIntersectionsTest.swift
│ ├── InvertBinaryTreeTests.swift
│ ├── IsGraphBipartiteTests.swift
│ ├── IsSubsequenceTests.swift
│ ├── IslandPerimeterTests.swift
│ ├── IsomorphicStringsTests.swift
│ ├── JumpGameIITests.swift
│ ├── JumpGameTests.swift
│ ├── KClosestPointsToOriginTests.swift
│ ├── KDiffPairsInAnArrayTests.swift
│ ├── KeysAndRoomsTests.swift
│ ├── KokoEatingBananasTests.swift
│ ├── KthLargestElementInArrayTests.swift
│ ├── KthMissingPositiveNumberTests.swift
│ ├── KthSmallestElementInBinarySearchTreeTests.swift
│ ├── KthSmallestPrimeFractionTests.swift
│ ├── KthSymbolInGrammarTests.swift
│ ├── LargestBSTSubtreeTests.swift
│ ├── LargestNumberTests.swift
│ ├── LargestPositiveIntegerThatExistsWithItsNegativeTests.swift
│ ├── LeafSimilarTreesTests.swift
│ ├── LeftmostColumnWithAtLeastAOneTests.swift
│ ├── LengthOfLastWordTests.swift
│ ├── LetterCombinationsOfAPhoneNumberTests.swift
│ ├── LexicographicallySmallestPalindromeTests.swift
│ ├── LinkedListCycleIITests.swift
│ ├── LinkedListCycleTests.swift
│ ├── LinkedListFrequencyTests.swift
│ ├── LinkedListInBinaryTreeTests.swift
│ ├── LongPressedNameTests.swift
│ ├── LongestAbsoluteFilePathTests.swift
│ ├── LongestArithmeticSubsequenceOfGivenDifferenceTests.swift
│ ├── LongestCommonPrefixTests.swift
│ ├── LongestConsecutiveSequenceTests.swift
│ ├── LongestIncreasingSubsequenceTests.swift
│ ├── LongestPalindromicSubstringTests.swift
│ ├── LongestRepeatingCharacterReplacementTests.swift
│ ├── LongestSubsequenceWithLimitedSumTests.swift
│ ├── LongestSubstringWithAtMostTwoDistinctCharactersTests.swift
│ ├── LongestSubstringWithoutRepeatingCharactersTests.swift
│ ├── LongestUncommonSubsequenceIITests.swift
│ ├── LongestUnivaluePathTests.swift
│ ├── LongestWordInDictionaryThroughDeletingTests.swift
│ ├── LongestZigZagPathInABinaryTreeTests.swift
│ ├── LowestCommonAncestorBinarySearchTreeTests.swift
│ ├── LowestCommonAncestorBinaryTreeIIITests.swift
│ ├── LowestCommonAncestorBinaryTreeIITests.swift
│ ├── LowestCommonAncestorBinaryTreeTests.swift
│ ├── LowestCommonAncestorOfDeepestLeavesTests.swift
│ ├── MajorityElementIITests.swift
│ ├── MajorityElementTests.swift
│ ├── MakeCostsOfPathsEqualInABinaryTreeTests.swift
│ ├── MakeTheStringGreatTests.swift
│ ├── Matrix01Tests.swift
│ ├── MaxAreaOfIslandTests.swift
│ ├── MaxConsecutiveOnesIIITests.swift
│ ├── MaxNumberOfKSumPairsTests.swift
│ ├── MaximalRangeThatEachElementIsMaximumInItTests.swift
│ ├── MaximizeTheConfusionOfAnExamTests.swift
│ ├── MaximumAverageSubtreeTests.swift
│ ├── MaximumBinaryTreeIITests.swift
│ ├── MaximumBinaryTreeTests.swift
│ ├── MaximumCoinsHeroesCanCollectTests.swift
│ ├── MaximumCountOfPositiveIntegerAndNegativeIntegerTests.swift
│ ├── MaximumDepthBinaryTreeTests.swift
│ ├── MaximumDifferenceBetweenNodeAndAncestorTests.swift
│ ├── MaximumEnemyFortsThatCanBeCapturedTests.swift
│ ├── MaximumLengthOfPairChainTests.swift
│ ├── MaximumLevelSumOfABinaryTreeTests.swift
│ ├── MaximumNestingDepthOfTheParenthesesTests.swift
│ ├── MaximumNumberOfBalloonsTests.swift
│ ├── MaximumNumberOfFishInAGridTests.swift
│ ├── MaximumNumberOfRemovableCharactersTests.swift
│ ├── MaximumNumberOfVowelsInASubstringOfGivenLengthTests.swift
│ ├── MaximumProductOfTheLengthOfTwoPalindromicSubsequencesTests.swift
│ ├── MaximumProductSubarrayTests.swift
│ ├── MaximumSubarrayTests.swift
│ ├── MaximumSwapTests.swift
│ ├── MaximumTwinSumOfALinkedListTests.swift
│ ├── MaximumWidthOfBinaryTreeTests.swift
│ ├── MeetingRoomsIITests.swift
│ ├── MeetingRoomsTests.swift
│ ├── MergeInBetweenLinkedListsTests.swift
│ ├── MergeIntervalsTests.swift
│ ├── MergeKSortedListsTests.swift
│ ├── MergeSortedArrayTests.swift
│ ├── MergeStringsAlternatelyTests.swift
│ ├── MergeTripletsToFormTargetTripletTests.swift
│ ├── MergeTwo2DArraysBySummingValuesTests.swift
│ ├── MergeTwoBinaryTreesTests.swift
│ ├── MergeTwoSortedListsTests.swift
│ ├── MiddleOfLinkedListTests.swift
│ ├── MinCostToConnectAllPointsTests.swift
│ ├── MinesweeperTests.swift
│ ├── MiniParserTests.swift
│ ├── MinimumAbsoluteDifferenceInBSTTests.swift
│ ├── MinimumAddToMakeParenthesesValidTests.swift
│ ├── MinimumAverageOfSmallestAndLargestElementsTests.swift
│ ├── MinimumCommonValueTests.swift
│ ├── MinimumDepthOfBinaryTreeTests.swift
│ ├── MinimumDifferenceBetweenHighestAndLowestOfKScoreTests.swift
│ ├── MinimumDistanceBetweenBSTNodesTests.swift
│ ├── MinimumFuelCostToReportToTheCapitalTests.swift
│ ├── MinimumHeightTreesTests.swift
│ ├── MinimumNumberOfFlipsToMakeTheBinaryStringAlternatingTests.swift
│ ├── MinimumNumberOfSwapsToMakeTheStringBalancedTests.swift
│ ├── MinimumNumberOfVerticesToReachAllNodesTests.swift
│ ├── MinimumOperationsToReduceXToZeroTests.swift
│ ├── MinimumPairRemovalToSortArrayITests.swift
│ ├── MinimumPenaltyForAShopTests.swift
│ ├── MinimumRemoveToMakeValidParenthesesTests.swift
│ ├── MinimumScoreOfAPathBetweenTwoCitiesTests.swift
│ ├── MinimumSizeSubarraySumTests.swift
│ ├── MinimumStringLengthAfterRemovingSubstringsTests.swift
│ ├── MinimumValueToGetPositiveTests.swift
│ ├── MissingElementInSortedArrayTests.swift
│ ├── MissingNumberTests.swift
│ ├── MissingRangesTests.swift
│ ├── MostFrequentSubtreeSumTests.swift
│ ├── MoveZerosTests.swift
│ ├── MovingAverageTests.swift
│ ├── MultiplyStringsTests.swift
│ ├── NRepeatedElementInSize2NArrayTests.swift
│ ├── NaryTreeLevelOrderTraversalTests.swift
│ ├── NaryTreePostorderTraversalTests.swift
│ ├── NaryTreePreorderTraversalTests.swift
│ ├── NestedListWeightSumIITests.swift
│ ├── NestedListWeightSumTests.swift
│ ├── NetworkDelayTimeTests.swift
│ ├── NextGreaterElementIIITests.swift
│ ├── NextGreaterElementIITests.swift
│ ├── NextGreaterElementITests.swift
│ ├── NextGreaterNodeInLinkedListTests.swift
│ ├── NextPermutationTests.swift
│ ├── NonDecreasingArrayTests.swift
│ ├── NonOverlappingIntervalsTests.swift
│ ├── NumberOfArithmeticTripletsTests.swift
│ ├── NumberOfClosedIslandsTests.swift
│ ├── NumberOfConnectedComponentsInAnUndirectedGraphTests.swift
│ ├── NumberOfDaysBetweenTwoDatesTests.swift
│ ├── NumberOfDistinctAveragesTests.swift
│ ├── NumberOfDistinctIslandsTests.swift
│ ├── NumberOfEnclavesTests.swift
│ ├── NumberOfEquivalentDominoPairsTests.swift
│ ├── NumberOfGoodLeafNodesPairsTests.swift
│ ├── NumberOfIslandsTests.swift
│ ├── NumberOfNodesWithValueOneTests.swift
│ ├── NumberOfPairsOfInterchangeableRectanglesTests.swift
│ ├── NumberOfProvincesTests.swift
│ ├── NumberOfStudentsUnableToEatLunchTests.swift
│ ├── NumberOfSubarraysOfSizeKAndAverageGreaterThanOrEqualToThresholdTests.swift
│ ├── NumberOfSubarraysWithBoundedMaximumTests.swift
│ ├── NumberOfSubsequencesThatSatisfyTheGivenSumConditionTests.swift
│ ├── NumberOfZeroFilledSubarraysTests.swift
│ ├── OddEvenLinkedListTests.swift
│ ├── OneEditDistanceTests.swift
│ ├── OneThreeTwoPatternTests.swift
│ ├── OpenTheLockTests.swift
│ ├── OptimalPartitionOfStringTests.swift
│ ├── PacificAtlanticWaterFlowTests.swift
│ ├── PairsOfSongsWithTotalDurationsDivisibleBy60Tests.swift
│ ├── PalindromeLinkedListTests.swift
│ ├── PalindromeNumberTests.swift
│ ├── PalindromePartitioningTests.swift
│ ├── PalindromicSubstringsTests.swift
│ ├── PartitionLabelsTests.swift
│ ├── PartitionListTests.swift
│ ├── PascalsTriangleIITests.swift
│ ├── PascalsTriangleTests.swift
│ ├── PathSumIIITests.swift
│ ├── PathSumIITests.swift
│ ├── PathSumIVTests.swift
│ ├── PathSumTests.swift
│ ├── PeakIndexMountainArrayTests.swift
│ ├── PerfectSquaresTests.swift
│ ├── PermutationInStringTests.swift
│ ├── PermutationsIITests.swift
│ ├── PermutationsTests.swift
│ ├── PlusOneTests.swift
│ ├── PopulatingNextRightPointersIITests.swift
│ ├── PopulatingNextRightPointersTests.swift
│ ├── PowTests.swift
│ ├── PowerOfThreeTests.swift
│ ├── ProductOfArrayExceptSelfTests.swift
│ ├── ProductOfTwoRunLengthEncodedArraysTests.swift
│ ├── PseudoPalindromicPathsInABinaryTreeTests.swift
│ ├── PushDominoesTests.swift
│ ├── RandomizedSetTests.swift
│ ├── RangeSumOfBSTTests.swift
│ ├── RansomNoteTests.swift
│ ├── ReconstructItineraryTests.swift
│ ├── RecoverBinarySearchTreeTests.swift
│ ├── RedundantConnectionTests.swift
│ ├── RemoveAllAdjacentDuplicatesInStringIITests.swift
│ ├── RemoveAllAdjacentDuplicatesInStringTests.swift
│ ├── RemoveCoveredIntervalsTests.swift
│ ├── RemoveDuplicateLettersTests.swift
│ ├── RemoveDuplicatesFromAnUnsortedLinkedListTests.swift
│ ├── RemoveDuplicatesFromSortedArrayIITests.swift
│ ├── RemoveDuplicatesFromSortedArrayTests.swift
│ ├── RemoveDuplicatesFromSortedListTests.swift
│ ├── RemoveElementTests.swift
│ ├── RemoveKDigitsTests.swift
│ ├── RemoveLinkedListElementsTests.swift
│ ├── RemoveNodesFromLinkedListTests.swift
│ ├── RemoveNthNodeFromEndOfListTests.swift
│ ├── RemoveOutermostParenthesesTests.swift
│ ├── RemovePalindromicSubsequencesTests.swift
│ ├── RemoveZeroSumConsecutiveNodesFromLinkedListTests.swift
│ ├── RemovingStarsFromAStringTests.swift
│ ├── ReorderListTests.swift
│ ├── ReorderRoutesToMakeAllPathsLeadToTheCityZeroTests.swift
│ ├── RepeatedDNASequencesTests.swift
│ ├── ReplaceElementsWithGreatestElementOnRightSideTests.swift
│ ├── RestoreIPAddressesTests.swift
│ ├── RestoreTheArrayFromAdjacentPairsTests.swift
│ ├── ReverseIntegerTests.swift
│ ├── ReverseLinkedListIITests.swift
│ ├── ReverseLinkedListTests.swift
│ ├── ReverseNodesInEvenLengthGroupsTests.swift
│ ├── ReverseOddLevelsOfBinaryTreeTests.swift
│ ├── ReverseOnlyLettersTests.swift
│ ├── ReversePrefixOfWordTests.swift
│ ├── ReverseStringIITests.swift
│ ├── ReverseStringTests.swift
│ ├── ReverseVowelsOfAStringTests.swift
│ ├── ReverseWordsInAStringIIITests.swift
│ ├── ReverseWordsInAStringIITests.swift
│ ├── ReverseWordsInAStringTests.swift
│ ├── RomanToIntegerTests.swift
│ ├── RootEqualsSumOfChildrenTests.swift
│ ├── RotateArrayTests.swift
│ ├── RotateImageTests.swift
│ ├── RotateListTests.swift
│ ├── RottingOrangesTests.swift
│ ├── RunningSumOf1DArrayTests.swift
│ ├── SameTreeTests.swift
│ ├── ScoreOfParenthesesTests.swift
│ ├── Search2DMatrixIITests.swift
│ ├── Search2DMatrixTests.swift
│ ├── SearchInABinarySearchTreeTests.swift
│ ├── SearchInRotatedSortedArrayIITests.swift
│ ├── SearchInRotatedSortedArrayTests.swift
│ ├── SearchInsertPositionTests.swift
│ ├── SearchSortedArrayOfUnknownSizeTests.swift
│ ├── SearchSuggestionsSystemTests.swift
│ ├── SecondMinimumNodeInBinaryTreeTests.swift
│ ├── SerializeDeserializeBinaryTreeTests.swift
│ ├── SetMatrixZeroesTests.swift
│ ├── ShortestBridgeTests.swift
│ ├── ShortestDistanceToACharacterTests.swift
│ ├── ShortestPathBinaryMatrixTests.swift
│ ├── ShortestPathWithAlternatingColorsTests.swift
│ ├── ShortestUnsortedContinuousSubarrayTests.swift
│ ├── ShortestWordDistanceIITests.swift
│ ├── SignOfTheProductOfAnArrayTests.swift
│ ├── SimplifyPathTests.swift
│ ├── SingleElementInASortedArrayTests.swift
│ ├── SingleNumberTests.swift
│ ├── SmallestStringStartingFromLeafTests.swift
│ ├── SmallestStringWithSwapsTests.swift
│ ├── SmallestSubtreeWithAllTheDeepestNodesTests.swift
│ ├── SnakesAndLaddersTests.swift
│ ├── SortAnArrayTests.swift
│ ├── SortArrayByParityIITests.swift
│ ├── SortArrayByParityTests.swift
│ ├── SortCharactersByFrequencyTests.swift
│ ├── SortColorsTests.swift
│ ├── SortLinkedListAlreadySortedUsingAbsoluteValuesTests.swift
│ ├── SortListTests.swift
│ ├── SortTheMatrixDiagonallyTests.swift
│ ├── SortTransformedArrayTests.swift
│ ├── SpecialArrayWithXElementsGreaterThanOrEqualXTests.swift
│ ├── SpiralMatrixIITests.swift
│ ├── SpiralMatrixTests.swift
│ ├── SplitBSTTests.swift
│ ├── SplitLinkedListInPartsTests.swift
│ ├── SqrtTests.swift
│ ├── SquaresOfSortedArrayTests.swift
│ ├── StepByStepDirectionsFromABinaryTreeNodeToAnotherTests.swift
│ ├── StringCompressionTests.swift
│ ├── StringToIntegerTests.swift
│ ├── StrobogrammaticNumberTests.swift
│ ├── SubarraySumEqualsKTests.swift
│ ├── SubdomainVisitCountTests.swift
│ ├── SubsetsIITests.swift
│ ├── SubsetsTests.swift
│ ├── SubtreeOfAnotherTreeTests.swift
│ ├── SuccessfulPairsOfSpellsAndPotionsTests.swift
│ ├── SumOfAllOddLengthSubarraysTests.swift
│ ├── SumOfLeftLeavesTests.swift
│ ├── SumOfNodesWithEvenValuedGrandparentTests.swift
│ ├── SumOfRootToLeafBinaryNumbersTests.swift
│ ├── SumOfSquareNumbersTests.swift
│ ├── SumRootToLeafNumbersTests.swift
│ ├── SurroundedRegionsTests.swift
│ ├── SwapAdjacentInLRStringTests.swift
│ ├── SwapNodesInPairsTests.swift
│ ├── SwappingNodesInALinkedListTests.swift
│ ├── SymmetricTreeTests.swift
│ ├── TargetSumTests.swift
│ ├── TernaryExpressionParserTests.swift
│ ├── TheKWeakestRowsInAMatrixTests.swift
│ ├── ThreeSumClosestTests.swift
│ ├── ThreeSumTests.swift
│ ├── ToeplitzMatrixTests.swift
│ ├── TopKFrequentElementsTests.swift
│ ├── TrimABinarySearchTreeTests.swift
│ ├── TwoSumBSTsTests.swift
│ ├── TwoSumIITests.swift
│ ├── TwoSumIVInputIsABSTTests.swift
│ ├── TwoSumLessThanKTests.swift
│ ├── TwoSumTests.swift
│ ├── UglyNumberTests.swift
│ ├── UndergroundSystemTests.swift
│ ├── UniqueBinarySearchTreesTests.swift
│ ├── UniqueEmailAddressesTests.swift
│ ├── UniqueLength3PalindromicSubsequencesTests.swift
│ ├── UniquePathsIITests.swift
│ ├── UniquePathsTests.swift
│ ├── UnivaluedBinaryTreeTests.swift
│ ├── ValidAnagramTests.swift
│ ├── ValidNumberTests.swift
│ ├── ValidPalindromeIITests.swift
│ ├── ValidPalindromeTests.swift
│ ├── ValidParenthesesTests.swift
│ ├── ValidParenthesisStringTests.swift
│ ├── ValidPerfectSquareTests.swift
│ ├── ValidSudokuTests.swift
│ ├── ValidTriangleNumberTests.swift
│ ├── ValidWordAbbreviationTests.swift
│ ├── ValidateBinarySearchTreeTests.swift
│ ├── ValidateBinaryTreeNodesTests.swift
│ ├── ValidateStackSequencesTests.swift
│ ├── VerifyingAnAlienDictionaryTests.swift
│ ├── VerticalOrderTraversalOfABinaryTreeTests.swift
│ ├── WallsAndGatesTests.swift
│ ├── WinnerOfTheLinkedListGameTests.swift
│ ├── WordBreakTests.swift
│ ├── WordPatternTests.swift
│ ├── WordSearchTests.swift
│ └── ZigzagConversionTests.swift
├── README.md
└── fastlane
├── Appfile
├── Fastfile
└── README.md
/.github/workflows/swift.yml:
--------------------------------------------------------------------------------
1 | name: Build
2 |
3 | on:
4 | push:
5 | branches: [ main ]
6 | pull_request:
7 | branches: [ main ]
8 |
9 | jobs:
10 | build:
11 |
12 | runs-on: macos-latest
13 |
14 | steps:
15 | - uses: actions/checkout@v4
16 | - name: List available Xcode versions
17 | run: ls /Applications | grep Xcode
18 | - name: Show current version of Xcode
19 | run: xcodebuild -version
20 | - name: Set up Xcode version
21 | run: sudo xcode-select -s /Applications/Xcode_16.1.0.app/Contents/Developer
22 | - name: Show current version of Xcode
23 | run: xcodebuild -version
24 | - name: Install Bundle
25 | run: bundle install
26 | - name: Run tests
27 | run: bundle exec fastlane run_all_tests --verbose
28 |
--------------------------------------------------------------------------------
/.ruby-version:
--------------------------------------------------------------------------------
1 | 3.1.0
2 |
--------------------------------------------------------------------------------
/.swiftlint.yml:
--------------------------------------------------------------------------------
1 | # By default, SwiftLint uses a set of sensible default rules you can adjust:
2 | disabled_rules: # rule identifiers turned on by default to exclude from running
3 | - trailing_whitespace
4 | - identifier_name
5 | - comment_spacing
6 | - function_body_length
7 | - type_name
8 | - file_length
9 | - for_where
10 | - function_parameter_count
11 | - large_tuple
12 | - cyclomatic_complexity
13 | - type_body_length
14 | - mark
15 |
16 | excluded:
17 | - CodingChallengesTests/
18 | - Algorithms/AlgorithmsTests/
19 | - CrackingTheCodingInterview/CrackingTheCodingInterviewTests/
20 | - HackerRank/HackerRankTests/
21 | - LeetCode/LeetCodeTests/
22 |
23 | line_length:
24 | warning: 140
25 | ignores_function_declarations: true
26 | ignores_comments: false
27 | ignores_interpolated_strings: true
28 | ignores_urls: true
29 |
30 |
--------------------------------------------------------------------------------
/Algorithms/Algorithms.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/Algorithms/Algorithms.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | IDEDidComputeMac32BitWarning
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/CodingChallenges.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/CodingChallenges.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | IDEDidComputeMac32BitWarning
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/CodingChallenges.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
7 |
9 |
10 |
12 |
13 |
15 |
16 |
18 |
19 |
20 |
--------------------------------------------------------------------------------
/CodingChallenges.xcworkspace/xcshareddata/IDETemplateMacros.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | FILEHEADER
6 | Created ___DATE___.
7 |
8 |
9 |
--------------------------------------------------------------------------------
/CodingChallenges.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | IDEDidComputeMac32BitWarning
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/CodingChallenges/Resources/Images/Assets.xcassets/AppIcon.appiconset/Contents.json:
--------------------------------------------------------------------------------
1 | {
2 | "images" : [
3 | {
4 | "idiom" : "iphone",
5 | "size" : "29x29",
6 | "scale" : "2x"
7 | },
8 | {
9 | "idiom" : "iphone",
10 | "size" : "29x29",
11 | "scale" : "3x"
12 | },
13 | {
14 | "idiom" : "iphone",
15 | "size" : "40x40",
16 | "scale" : "2x"
17 | },
18 | {
19 | "idiom" : "iphone",
20 | "size" : "40x40",
21 | "scale" : "3x"
22 | },
23 | {
24 | "idiom" : "iphone",
25 | "size" : "60x60",
26 | "scale" : "2x"
27 | },
28 | {
29 | "idiom" : "iphone",
30 | "size" : "60x60",
31 | "scale" : "3x"
32 | }
33 | ],
34 | "info" : {
35 | "version" : 1,
36 | "author" : "xcode"
37 | }
38 | }
--------------------------------------------------------------------------------
/CodingChallenges/Resources/Images/Assets.xcassets/Contents.json:
--------------------------------------------------------------------------------
1 | {
2 | "info" : {
3 | "version" : 1,
4 | "author" : "xcode"
5 | }
6 | }
--------------------------------------------------------------------------------
/CodingChallenges/ViewControllers/Questions/QuestionsViewController.swift:
--------------------------------------------------------------------------------
1 | //
2 | // QuestionsViewController.swift
3 | // CodingChallenges
4 | //
5 | // Created by William Boles on 05/05/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import UIKit
10 |
11 | final class QuestionsViewController: UIViewController {
12 |
13 | }
14 |
--------------------------------------------------------------------------------
/CodingChallengesTests/Info.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | CFBundleDevelopmentRegion
6 | en
7 | CFBundleExecutable
8 | $(EXECUTABLE_NAME)
9 | CFBundleIdentifier
10 | $(PRODUCT_BUNDLE_IDENTIFIER)
11 | CFBundleInfoDictionaryVersion
12 | 6.0
13 | CFBundleName
14 | $(PRODUCT_NAME)
15 | CFBundlePackageType
16 | BNDL
17 | CFBundleShortVersionString
18 | 1.0
19 | CFBundleSignature
20 | ????
21 | CFBundleVersion
22 | 1
23 |
24 |
25 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | IDEDidComputeMac32BitWarning
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview/Challenges/Chapter 2/IntersectingNode/LinkedListNode.swift:
--------------------------------------------------------------------------------
1 | //
2 | // LinkedListNode.swift
3 | // CrackingTheCodingInterview
4 | //
5 | // Created by William Boles on 30/05/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | final class LinkedListNode {
12 | var value: Int
13 | var next: LinkedListNode?
14 |
15 | // MARK: - Init
16 |
17 | init(value: Int) {
18 | self.value = value
19 | }
20 | }
21 |
22 | extension LinkedListNode: Equatable {
23 | static func == (lhs: LinkedListNode, rhs: LinkedListNode) -> Bool {
24 | ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
25 | }
26 | }
27 |
28 | extension LinkedListNode: Hashable {
29 | func hash(into hasher: inout Hasher) {
30 | hasher.combine(ObjectIdentifier(self))
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview/Challenges/Chapter 2/IntersectingNode/SingleLinkedList.swift:
--------------------------------------------------------------------------------
1 | //
2 | // SingleLinkedList.swift
3 | // CrackingTheCodingInterview
4 | //
5 | // Created by William Boles on 30/05/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | final class SingleLinkedList {
12 | var head: LinkedListNode?
13 |
14 | // MARK: - Add
15 |
16 | func addNode(node: LinkedListNode) {
17 | guard var head = head else {
18 | self.head = node
19 | return
20 | }
21 |
22 | while head.next != nil {
23 | head = head.next!
24 | }
25 | head.next = node
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview/Challenges/Chapter 3/StackOfPlates/StackOfPlatesNode.swift:
--------------------------------------------------------------------------------
1 | //
2 | // StackOfPlatesNode.swift
3 | // CrackingTheCodingInterview
4 | //
5 | // Created by William Boles on 01/06/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | final class StackOfPlatesNode {
12 | let value: Int
13 |
14 | // MARK: - Init
15 |
16 | init(value: Int) {
17 | self.value = value
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview/Challenges/Chapter 4/BinarySearchTreeDepth/BinarySearchTreeDepthNode.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BinarySearchTreeDepthNode.swift
3 | // CrackingTheCodingInterview
4 | //
5 | // Created by William Boles on 01/06/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | final class BinarySearchTreeDepthNode {
12 |
13 | // MARK: Properties
14 |
15 | var value: Int
16 | var depth: Int
17 |
18 | var left: BinarySearchTreeDepthNode?
19 | var right: BinarySearchTreeDepthNode?
20 |
21 | // MARK: Init
22 |
23 | init(value: Int, depth: Int) {
24 | self.value = value
25 | self.depth = depth
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview/Challenges/Chapter 4/BinarySearchTreeDepth/LinkedList/BinarySearchTreeDepthLinkedListNode.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BinarySearchTreeDepthLinkedListNode.swift
3 | // CrackingTheCodingInterview
4 | //
5 | // Created by William Boles on 01/06/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | final class BinarySearchTreeDepthLinkedListNode {
12 | var next: BinarySearchTreeDepthLinkedListNode?
13 | var binarySearchTreeNode: BinarySearchTreeDepthNode?
14 | }
15 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview/Challenges/Chapter 4/MinimalTree/MinimalBinarySearchTreeNode.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MinimalBinarySearchTreeNode.swift
3 | // CrackingTheCodingInterview
4 | //
5 | // Created by William Boles on 01/06/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | final class MinimalBinarySearchTreeNode {
12 |
13 | // MARK: Properties
14 |
15 | var value: Int
16 |
17 | var left: MinimalBinarySearchTreeNode?
18 | var right: MinimalBinarySearchTreeNode?
19 |
20 | // MARK: Init
21 |
22 | init(value: Int) {
23 | self.value = value
24 | }
25 |
26 | // MARK: Child
27 |
28 | func addChild(node: MinimalBinarySearchTreeNode) {
29 | if node.value <= self.value {
30 | left = node
31 | } else {
32 | right = node
33 | }
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview/Challenges/Chapter 4/RoutePlanner/RoutePlannerNode.swift:
--------------------------------------------------------------------------------
1 | //
2 | // RoutePlannerNode.swift
3 | // CrackingTheCodingInterview
4 | //
5 | // Created by William Boles on 01/06/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | final class RoutePlannerNode {
12 | var connectedNodes = [RoutePlannerNode]()
13 | var visited = false
14 | var previousVisitedNode: RoutePlannerNode?
15 |
16 | // MARK: - Connections
17 |
18 | func addConnection(node: RoutePlannerNode) {
19 | connectedNodes.append(node)
20 | }
21 | }
22 |
23 | extension RoutePlannerNode: Equatable {
24 | static func == (lhs: RoutePlannerNode, rhs: RoutePlannerNode) -> Bool {
25 | ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterview/Challenges/Chapter 4/RoutePlanner/RoutePlannerQueue.swift:
--------------------------------------------------------------------------------
1 | //
2 | // RoutePlannerQueue.swift
3 | // CrackingTheCodingInterview
4 | //
5 | // Created by William Boles on 01/06/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | final class RoutePlannerQueue {
12 | lazy var nodes = [RoutePlannerNode]()
13 |
14 | // MARK: - Meta
15 |
16 | func isEmpty() -> Bool {
17 | return nodes.isEmpty
18 | }
19 |
20 | // MARK: - Actions
21 |
22 | func enqueue(node: RoutePlannerNode) {
23 | nodes.append(node)
24 | }
25 |
26 | func dequeue() -> RoutePlannerNode {
27 | return nodes.removeFirst()
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterviewTests/Tests/Chapter 3/QueueViaStacksTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // QueueViaStacksTests.swift
3 | // CrackingTheCodingInterviewTests
4 | //
5 | // Created by William Boles on 01/06/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import CrackingTheCodingInterview
12 |
13 | final class QueueViaStacksTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let values = [3, 5, 6, 7, 8, 9, 2, 3, 5, 8]
19 |
20 | let queue = QueueViaStacks()
21 |
22 | for value in values {
23 | queue.enqueue(value: value)
24 | }
25 |
26 | XCTAssertEqual(3, queue.peek())
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/CrackingTheCodingInterview/CrackingTheCodingInterviewTests/Tests/Chapter 4/ProjectBuildOrderTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BuildOrderTests.swift
3 | // CrackingTheCodingInterviewTests
4 | //
5 | // Created by William Boles on 02/06/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import CrackingTheCodingInterview
12 |
13 | final class ProjectBuildOrderTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let projects = ["a", "b", "c", "d", "e", "f"]
19 | let dependencies = [["a", "d"], ["f", "b"], ["b", "d"], ["f", "a"], ["d", "c"]]
20 |
21 | let buildOrder = ProjectBuildOrder.buildOrder(projects: projects, dependencies: dependencies)
22 |
23 | for node in buildOrder! {
24 | print(node.value)
25 | }
26 |
27 | XCTAssertNotNil(buildOrder)
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source "https://rubygems.org"
2 |
3 | gem "fastlane", "2.227.2"
4 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank.xcodeproj/project.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | IDEDidComputeMac32BitWarning
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/AngryProfessor.swift:
--------------------------------------------------------------------------------
1 | //
2 | // AngryProfessor.swift
3 | // HackerRank
4 | //
5 | // Created by Boles on 07/05/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/angry-professor
12 | final class AngryProfessor {
13 |
14 | static func shouldCancelClass(_ studentArrivalTimes: [Int], _ cancellationThreshold: Int) -> Bool {
15 | var lateStudents = 0
16 |
17 | for arrivalTime in studentArrivalTimes {
18 | if arrivalTime > 0 {
19 | lateStudents += 1
20 | }
21 | }
22 |
23 | return lateStudents > cancellationThreshold
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/AppleAndOrange.swift:
--------------------------------------------------------------------------------
1 | //
2 | // AppleAndOrange.swift
3 | // HackerRank
4 | //
5 | // Created by William Boles on 27/10/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/apple-and-orange/problem
12 | final class AppleAndOrange {
13 | static func countAppleAndOrangesHittingHouse(houseStart: Int, houseEnd: Int, appleTree: Int, orangeTree: Int, apples: [Int], oranges: [Int]) -> (Int, Int) {
14 | let houseRange = (houseStart...houseEnd)
15 | let appleHits = apples.reduce(0) { houseRange.contains(appleTree + $1) ? $0 + 1 : $0 }
16 | let orangeHits = oranges.reduce(0) { houseRange.contains(orangeTree + $1) ? $0 + 1 : $0 }
17 |
18 | return (appleHits, orangeHits)
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/BirthdayBar.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BirthdayBar.swift
3 | // HackerRank
4 | //
5 | // Created by William Boles on 28/10/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/the-birthday-bar/problem
12 | struct BirthdayBar {
13 | static func birthday(s: [Int], d: Int, m: Int) -> Int {
14 | guard s.count >= m else {
15 | return 0
16 | }
17 |
18 | var possibilities = 0
19 | for index in 0...(s.count - m) {
20 | let segmentTotal = s[index..<(index + m)].reduce(0, +)
21 | if segmentTotal == d {
22 | possibilities += 1
23 | }
24 | }
25 |
26 | return possibilities
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/BirthdayCakeCandles.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BirthdayCakeCandles.swift
3 | // HackerRank
4 | //
5 | // Created by William Boles on 27/10/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/birthday-cake-candles/problem
12 | struct BirthdayCakeCandles {
13 |
14 | static func countOfTallestCandles(_ candles: [Int]) -> Int {
15 | guard !candles.isEmpty else {
16 | return 0
17 | }
18 |
19 | guard candles.count > 1 else {
20 | return candles[0]
21 | }
22 |
23 | let sortedCandles = candles.sorted(by: >)
24 | let filteredCandles = sortedCandles.filter { $0 == sortedCandles.first!}
25 |
26 | return filteredCandles.count
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/CompareTheTriplets.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CompareTheTriplets.swift
3 | // HackerRank
4 | //
5 | // Created by William Boles on 03/11/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/compare-the-triplets/problem
12 | struct CompareTheTriplets {
13 | static func score(a: [Int], b: [Int]) -> [Int] {
14 | guard a.count == b.count else {
15 | fatalError("Invalid data")
16 | }
17 |
18 | var aScore = 0
19 | var bScore = 0
20 |
21 | for index in 0.. bValue {
26 | aScore += 1
27 | } else if bValue > aValue {
28 | bScore += 1
29 | }
30 | }
31 |
32 | return [aScore, bScore]
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/DivisibleSumPairs.swift:
--------------------------------------------------------------------------------
1 | //
2 | // DivisibleSumPairs.swift
3 | // HackerRank
4 | //
5 | // Created by William Boles on 28/10/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/divisible-sum-pairs/problem
12 | struct DivisibleSumPairs {
13 | static func divisibleSumPairs(k: Int, ar: [Int]) -> Int {
14 | //Pair does not need to be beside each other
15 |
16 | var pairs = 0
17 | for (i, v1) in ar.enumerated() {
18 | for v2 in ar.suffix(from: (i + 1)) where ((v1 + v2) % k == 0) {
19 | pairs += 1
20 | }
21 | }
22 |
23 | return pairs
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/FindDigits.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FindDigits.swift
3 | // HackerRank
4 | //
5 | // Created by Boles on 08/05/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/find-digits
12 | final class FindDigits {
13 |
14 | static func findCountOfDivisibleValuesOfNumberInNumber(number: Int) -> Int {
15 |
16 | var divisibles = 0
17 |
18 | let stringNumber = String(number)
19 |
20 | for ch in stringNumber {
21 | if let digit = Int(String(ch)) {
22 |
23 | if digit > 0 {
24 |
25 | if number % digit == 0 {
26 |
27 | divisibles += 1
28 | }
29 |
30 | }
31 | }
32 | }
33 |
34 | return divisibles
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/IceCreamParlor.swift:
--------------------------------------------------------------------------------
1 | //
2 | // IceCreamParlor.swift
3 | // HackerRank
4 | //
5 | // Created by William Boles on 11/07/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/icecream-parlor
12 | final class IceCreamParlor {
13 |
14 | static func chosenIceCreams(money: Int, iceCreamChoices: [Int]) -> (firstIceCream: Int?, secondIceCream: Int?) {
15 | for i in 0..<(iceCreamChoices.count-1) {
16 | for j in (i+1).. Set {
15 |
16 | var multiplesOfA = (numberOfStones - 1)
17 | var multiplesOfB = 0
18 |
19 | var possibleValues = Set()
20 |
21 | while multiplesOfA >= 0 {
22 |
23 | let total = (multiplesOfA * gapValueA) + (multiplesOfB * gapValueB)
24 |
25 | possibleValues.insert(total)
26 |
27 | multiplesOfA -= 1
28 | multiplesOfB += 1
29 | }
30 |
31 | return possibleValues
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/MaximizeSum.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MaximizeSum.swift
3 | // HackerRank
4 | //
5 | // Created by William Boles on 11/07/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/maximize-sum
12 | final class MaximizeSum {
13 |
14 | // MARK: Maximum
15 |
16 | static func maximizeSum(values: [Int], modulo: Int) -> Int {
17 | var prefix = [Int]()
18 | var current = 0
19 | for value in values {
20 | current = (value % modulo + current) % modulo
21 | prefix.append(current)
22 | }
23 |
24 | var ret = prefix[0]
25 | for i in 1.. Int {
14 | var countedBirds = [arr[0]: 1]
15 | var mostFrequentBird = arr[0]
16 |
17 | for bird in arr.suffix(from: 1) {
18 | countedBirds[bird, default: 0] += 1
19 |
20 | if countedBirds[bird]! > countedBirds[mostFrequentBird]! {
21 | mostFrequentBird = bird
22 | } else if (countedBirds[bird]! == countedBirds[mostFrequentBird]!) && (bird < mostFrequentBird) {
23 | mostFrequentBird = bird
24 | }
25 | }
26 |
27 | return mostFrequentBird
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/ServiceLane.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ServiceLane.swift
3 | // HackerRank
4 | //
5 | // Created by Boles on 08/05/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/service-lane
12 | final class ServiceLane {
13 |
14 | static func largestVehicle(servicelane: [Int], entrance: Int, exit: Int) -> Int {
15 |
16 | var smallestWidth = 5
17 |
18 | for index in entrance...exit {
19 |
20 | let width = servicelane[index]
21 |
22 | if width < smallestWidth {
23 |
24 | smallestWidth = width
25 | }
26 | }
27 |
28 | return smallestWidth
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/SherlockAndArray.swift:
--------------------------------------------------------------------------------
1 | //
2 | // SherlockAndArray.swift
3 | // HackerRank
4 | //
5 | // Created by William Boles on 07/07/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/sherlock-and-array/problem
12 | final class SherlockAndArray {
13 |
14 | static func leftRightEqualityPossible(array: [Int]) -> Bool {
15 | if array.count < 3 {
16 | return false
17 | }
18 |
19 | var leftTotal = 0
20 | var total = 0
21 |
22 | for i in 0.. Int {
15 | return array.firstIndex(of: value)!
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/TimeConverter.swift:
--------------------------------------------------------------------------------
1 | //
2 | // TimeConverter.swift
3 | // HackerRank
4 | //
5 | // Created by Boles on 07/05/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/time-conversion
12 | final class TimeConverter {
13 |
14 | static func convertFrom12HourTo24HourUsingDateManipulation(time: String) -> String {
15 | let dateFormatter = DateFormatter()
16 | dateFormatter.dateFormat = "h:mm:ssa"
17 |
18 | let date12 = dateFormatter.date(from: time)
19 |
20 | dateFormatter.dateFormat = "HH:mm:ss"
21 | let date24 = dateFormatter.string(from: date12!)
22 |
23 | return date24
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/HackerRank/HackerRank/Challenges/UtopianTree.swift:
--------------------------------------------------------------------------------
1 | //
2 | // UtopianTree.swift
3 | // HackerRank
4 | //
5 | // Created by Boles on 08/05/2016.
6 | // Copyright © 2016 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://www.hackerrank.com/challenges/utopian-tree
12 | final class UtopianTree {
13 |
14 | static func heightOfTree(cycles: Int) -> Int {
15 |
16 | var heightOfTree = 1
17 |
18 | for cycle in 0..
2 |
4 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | IDEDidComputeMac32BitWarning
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Challenges/ConcatenationOfArray.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ConcatenationOfArray.swift
3 | // LeetCode
4 | //
5 | // Created by William Boles on 06/07/2023.
6 | //
7 |
8 | import Foundation
9 |
10 | //https://leetcode.com/problems/concatenation-of-array/
11 | struct ConcatenationOfArray {
12 |
13 | //Time: O(n) where n is the number of elements in `nums`
14 | //Space: O(n)
15 | //array
16 | //
17 | //Solution Description:
18 | //The elements in `num` should repeat at index `i + n` where `i` is the original index and `n` is the length of `nums`
19 | func getConcatenation(_ nums: [Int]) -> [Int] {
20 | return nums + nums
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Challenges/FindMinimumRotatedSortedArray.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FindMinimumRotatedSortedArray.swift
3 | // LeetCode
4 | //
5 | // Created by William Boles on 18/11/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
12 | struct FindMinimumRotatedSortedArray {
13 |
14 | //Time: O(log n)
15 | //Space: O(1)
16 | //divide and conquer
17 | //binary search find leftmost
18 | func findMin(_ nums: [Int]) -> Int {
19 | var left = 0
20 | var right = nums.count - 1
21 |
22 | while left < right {
23 | let mid = left + (right - left) / 2
24 |
25 | if nums[mid] > nums[right] {
26 | left = mid + 1
27 | } else {
28 | right = mid
29 | }
30 | }
31 |
32 | return nums[left]
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Challenges/MovingAverage.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MovingAverage.swift
3 | // LeetCode
4 | //
5 | // Created by William Boles on 28/02/2022.
6 | //
7 |
8 | import Foundation
9 |
10 | //https://leetcode.com/problems/moving-average-from-data-stream/
11 | //design
12 | //
13 | //Time: O(n) where n is the window size
14 | //Space: O(1)
15 | final class MovingAverage {
16 | private let size: Int
17 | private var values = [Int]()
18 | private var sum = 0
19 |
20 | init(_ size: Int) {
21 | self.size = size
22 | }
23 |
24 | func next(_ val: Int) -> Double {
25 | values.append(val)
26 |
27 | let sub = values.count > size ? values.removeFirst() : 0
28 | sum = sum - sub + val
29 | let divider = min(values.count, size)
30 |
31 | return (Double(sum) / Double(divider))
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Challenges/PowerOfThree.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PowerOfThree.swift
3 | // LeetCode
4 | //
5 | // Created by William Boles on 06/04/2023.
6 | //
7 |
8 | import Foundation
9 |
10 | //https://leetcode.com/problems/power-of-three
11 | struct PowerOfThree {
12 |
13 | //Time: O(log n)
14 | //Space: O(log n)
15 | //maths
16 | //recursive
17 | //modulo
18 | //
19 | //Solution Description:
20 | //W attempt to divide `n` by 3 recursively until we get 1. We check that our division is "clean" by ensuring none of the divisions
21 | //will result in a remainder.
22 | func isPowerOfThree(_ n: Int) -> Bool {
23 | guard n > 0 else {
24 | return false
25 | }
26 |
27 | guard n > 1 else {
28 | return true
29 | }
30 |
31 | guard n % 3 == 0 else {
32 | return false
33 | }
34 |
35 | return isPowerOfThree((n/3))
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Challenges/PrintImmutableLinkedListInReverse.swift:
--------------------------------------------------------------------------------
1 | // Created 10/05/2025.
2 |
3 | import Foundation
4 |
5 | //https://leetcode.com/problems/print-immutable-linked-list-in-reverse/
6 | struct PrintImmutableLinkedListInReverse {
7 |
8 | //Time: O(n) where n is the number of nodes in the list
9 | //Space: O(n)
10 | //linked list
11 | //graph theory
12 | //DFS
13 | //recursion
14 | //
15 | //Solution Description:
16 | //Treating the linked list as a graph can use DFS to reach the tail and then as the stack unwinds call `printValue` to
17 | //print the values tail->head.
18 | func printLinkedListInReverse(_ head: ImmutableListNode?) {
19 | dfs(head)
20 | }
21 |
22 | private func dfs(_ head: ImmutableListNode?) {
23 | guard let head else {
24 | return
25 | }
26 |
27 | dfs(head.getNext())
28 | head.printValue()
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Challenges/RootEqualsSumOfChildren.swift:
--------------------------------------------------------------------------------
1 | //
2 | // RootEqualsSumOfChildren.swift
3 | // LeetCode
4 | //
5 | // Created by William Boles on 09/11/2023.
6 | //
7 |
8 | import Foundation
9 |
10 | //https://leetcode.com/problems/root-equals-sum-of-children/
11 | struct RootEqualsSumOfChildren {
12 |
13 | //Time: O(1)
14 | //Space: O(1)
15 | //binary tree
16 | //
17 | //Solution Description:
18 | //We sum the `root` node's left and right child nodes and compare that value against the value of root.
19 | func checkTree(_ root: TreeNode?) -> Bool {
20 | guard let root = root, let left = root.left, let right = root.right else {
21 | return false
22 | }
23 |
24 | return root.val == (left.val + right.val)
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Challenges/SortTransformedArray.swift:
--------------------------------------------------------------------------------
1 | //
2 | // SortTransformedArray.swift
3 | // LeetCode
4 | //
5 | // Created by William Boles on 04/09/2024.
6 | //
7 |
8 | import Foundation
9 |
10 | //https://leetcode.com/problems/sort-transformed-array/
11 | struct SortTransformedArray {
12 |
13 | //Time: O(n log n) where n is the number of elements in `nums`
14 | //Space: O(n)
15 | //array
16 | //sorting
17 | //
18 | //Solution Description:
19 | //We apply the forumla to each element in `nums`, add the outcome to the `result` array and sort that array.
20 | func sortTransformedArray(_ nums: [Int], _ a: Int, _ b: Int, _ c: Int) -> [Int] {
21 | var result = [Int]()
22 |
23 | for num in nums {
24 | let outcome = (a * (num * num)) + (b * num) + c
25 | result.append(outcome)
26 | }
27 |
28 | return result.sorted()
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Challenges/ValidPalindrome.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ValidPalindrome.swift
3 | // LeetCode
4 | //
5 | // Created by William Boles on 15/11/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | //https://leetcode.com/problems/valid-palindrome/
12 | struct ValidPalindrome {
13 |
14 | //Time: O(n)
15 | //two pointers
16 | func isPalindrome(_ s: String) -> Bool {
17 | let str = s.lowercased().filter { $0.isLetter || $0.isNumber }
18 | let characters = Array(str)
19 |
20 | var left = 0
21 | var right = characters.count - 1
22 |
23 | while right >= left {
24 | if characters[left] != characters[right] {
25 | return false
26 | }
27 |
28 | left += 1
29 | right -= 1
30 | }
31 |
32 | return true
33 | }
34 | }
35 |
36 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Helpers/BinaryMatrix.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BinaryMatrix.swift
3 | // LeetCode
4 | //
5 | // Created by William Boles on 15/04/2022.
6 | //
7 |
8 | import Foundation
9 |
10 | final class BinaryMatrix {
11 | let matrix: [[Int]]
12 |
13 | init(_ matrix: [[Int]]) {
14 | self.matrix = matrix
15 | }
16 |
17 | func get(_ row: Int, _ col: Int) -> Int {
18 | return matrix[row][col]
19 | }
20 |
21 | func dimensions() -> [Int] {
22 | let rows = matrix.count
23 | let columns = matrix[0].count
24 |
25 | return [rows, columns]
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/LeetCode/LeetCode/Helpers/GraphWeightedEdge.swift:
--------------------------------------------------------------------------------
1 | //
2 | // WeightedEdge.swift
3 | // LeetCode
4 | //
5 | // Created by William Boles on 07/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import Foundation
10 |
11 | final class GraphWeightedEdge {
12 | let source: Int
13 | let destination: Int
14 | let weight: Int
15 |
16 | // MARK: - Init
17 |
18 | init(source: Int, destination: Int, weight: Int) {
19 | self.source = source
20 | self.destination = destination
21 | self.weight = weight
22 | }
23 | }
24 |
25 | extension GraphWeightedEdge: Equatable {
26 | static func == (lhs: GraphWeightedEdge, rhs: GraphWeightedEdge) -> Bool {
27 | ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
28 | }
29 | }
30 |
31 | extension GraphWeightedEdge: Hashable {
32 | func hash(into hasher: inout Hasher) {
33 | hasher.combine(ObjectIdentifier(self))
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/AddBinaryTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // AddBinaryTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 16/03/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class AddBinaryTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let a = "11"
18 | let b = "1"
19 |
20 | let result = AddBinary().addBinary(a, b)
21 |
22 | XCTAssertEqual(result, "100")
23 | }
24 |
25 | func test_B() {
26 | let a = "1010"
27 | let b = "1011"
28 |
29 | let result = AddBinary().addBinary(a, b)
30 |
31 | XCTAssertEqual(result, "10101")
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/AmountOfTimeForBinaryTreeToBeInfectedTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // AmountOfTimeForBinaryTreeToBeInfectedTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 07/12/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class AmountOfTimeForBinaryTreeToBeInfectedTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let start = 3
18 | let data = [1,5,3,nil,4,10,6,9,2]
19 | let root = TreeNode.deserialize(data)
20 |
21 | let result = AmountOfTimeForBinaryTreeToBeInfected().amountOfTime(root, start)
22 |
23 | XCTAssertEqual(result, 4)
24 | }
25 |
26 | func test_B() {
27 | let start = 1
28 | let data = [1]
29 | let root = TreeNode.deserialize(data)
30 |
31 | let result = AmountOfTimeForBinaryTreeToBeInfected().amountOfTime(root, start)
32 |
33 | XCTAssertEqual(result, 0)
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ArrangingCoinsTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ArrangingCoinsTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 31/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class ArrangingCoinsTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let n = 5
18 |
19 | let result = ArrangingCoins().arrangeCoins(n)
20 |
21 | XCTAssertEqual(result, 2)
22 | }
23 |
24 | func test_B() {
25 | let n = 8
26 |
27 | let result = ArrangingCoins().arrangeCoins(n)
28 |
29 | XCTAssertEqual(result, 3)
30 | }
31 |
32 | func test_C() {
33 | let n = 1
34 |
35 | let result = ArrangingCoins().arrangeCoins(n)
36 |
37 | XCTAssertEqual(result, 1)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ArrayWithElementsNotEqualToAverageOfNeighborsTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ArrayWithElementsNotEqualToAverageOfNeighborsTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 18/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class ArrayWithElementsNotEqualToAverageOfNeighborsTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [1, 2, 3, 4, 5]
18 |
19 | let result = ArrayWithElementsNotEqualToAverageOfNeighbors().rearrangeArray(nums)
20 |
21 | XCTAssertEqual(result, [1, 5, 2, 4, 3])
22 | }
23 |
24 | func test_B() {
25 | let nums = [6, 2, 0, 9, 7]
26 |
27 | let result = ArrayWithElementsNotEqualToAverageOfNeighbors().rearrangeArray(nums)
28 |
29 | XCTAssertEqual(result, [0, 9, 2, 7, 6])
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/AssignCookiesTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // AssignCookiesTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 01/09/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class AssignCookiesTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let g = [1,2,3]
18 | let s = [1,1]
19 |
20 | let result = AssignCookies().findContentChildren(g, s)
21 |
22 | XCTAssertEqual(result, 1)
23 | }
24 |
25 | func test_B() {
26 | let g = [1,2]
27 | let s = [1,2,3]
28 |
29 | let result = AssignCookies().findContentChildren(g, s)
30 |
31 | XCTAssertEqual(result, 2)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/BSTIteratorTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BSTIteratorTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 31/03/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class BSTIteratorTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [7, 3, 15, nil, nil, 9, 20]
18 | let root = TreeNode.deserialize(data)
19 | let iterator = BSTIterator(root)
20 |
21 | XCTAssertEqual(iterator.next(), 3)
22 | XCTAssertEqual(iterator.next(), 7)
23 | XCTAssertTrue(iterator.hasNext())
24 | XCTAssertEqual(iterator.next(), 9)
25 | XCTAssertTrue(iterator.hasNext())
26 | XCTAssertEqual(iterator.next(), 15)
27 | XCTAssertTrue(iterator.hasNext())
28 | XCTAssertEqual(iterator.next(), 20)
29 | XCTAssertFalse(iterator.hasNext())
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/BaseballGameTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BaseballGameTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 28/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class BaseballGameTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let ops = ["5", "2", "C", "D", "+"]
18 |
19 | let result = BaseballGame().calPoints(ops)
20 |
21 | XCTAssertEqual(result, 30)
22 | }
23 |
24 | func test_B() {
25 | let ops = ["5", "-2", "4", "C", "D", "9", "+", "+"]
26 |
27 | let result = BaseballGame().calPoints(ops)
28 |
29 | XCTAssertEqual(result, 27)
30 | }
31 |
32 | func test_C() {
33 | let ops = ["1", "C"]
34 |
35 | let result = BaseballGame().calPoints(ops)
36 |
37 | XCTAssertEqual(result, 0)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/BattleshipsInABoardTests.swift:
--------------------------------------------------------------------------------
1 | // Created 05/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct BattleshipsInABoardTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let board: [[Character]] = [["X",".",".","X"],
14 | [".",".",".","X"],
15 | [".",".",".","X"]]
16 |
17 | let result = BattleshipsInABoard().countBattleships(board)
18 |
19 | #expect(result == 2)
20 | }
21 |
22 | @Test
23 | func test_B() {
24 | let board: [[Character]] = [["."]]
25 |
26 | let result = BattleshipsInABoard().countBattleships(board)
27 |
28 | #expect(result == 0)
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/BeautifulTowersITests.swift:
--------------------------------------------------------------------------------
1 | // Created 13/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct AABeautifulTowersITests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let heights = [5,3,4,1,1]
14 |
15 | let result = BeautifulTowersI().maximumSumOfHeights(heights)
16 |
17 | #expect(result == 13)
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let heights = [6,5,3,9,2,7]
23 |
24 | let result = BeautifulTowersI().maximumSumOfHeights(heights)
25 |
26 | #expect(result == 22)
27 | }
28 |
29 | @Test
30 | func test_C() {
31 | let heights = [3,2,5,5,2,3]
32 |
33 | let result = BeautifulTowersI().maximumSumOfHeights(heights)
34 |
35 | #expect(result == 18)
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/BestTimeToBuyAndSellStockTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BestTimeToBuyAndSellStockTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 31/01/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class BestTimeToBuyAndSellStockTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let prices = [7, 1, 5, 3, 6, 4]
18 |
19 | let result = BestTimeToBuyAndSellStock().maxProfit(prices)
20 |
21 | XCTAssertEqual(result, 5)
22 | }
23 |
24 | func test_B() {
25 | let prices = [7, 6, 4, 3, 1]
26 |
27 | let result = BestTimeToBuyAndSellStock().maxProfit(prices)
28 |
29 | XCTAssertEqual(result, 0)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/BinaryTreeColoringGameTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BinaryTreeColoringGameTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 13/12/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class BinaryTreeColoringGameTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let n = 11
18 | let x = 3
19 | let data = [1,2,3,4,5,6,7,8,9,10,11]
20 | let root = TreeNode.deserialize(data)
21 |
22 | let result = BinaryTreeColoringGame().btreeGameWinningMove(root, n, x)
23 |
24 | XCTAssertTrue(result)
25 | }
26 |
27 | func test_B() {
28 | let n = 3
29 | let x = 1
30 | let data = [1,2,3]
31 | let root = TreeNode.deserialize(data)
32 |
33 | let result = BinaryTreeColoringGame().btreeGameWinningMove(root, n, x)
34 |
35 | XCTAssertFalse(result)
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/BinaryTreeLongestConsecutiveSequenceTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BinaryTreeLongestConsecutiveSequenceTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 09/12/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class BinaryTreeLongestConsecutiveSequenceTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [1,nil,3,2,4,nil,nil,nil,5]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = BinaryTreeLongestConsecutiveSequence().longestConsecutive(root)
21 |
22 | XCTAssertEqual(result, 3)
23 | }
24 |
25 | func test_B() {
26 | let data = [2,nil,3,2,nil,1]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = BinaryTreeLongestConsecutiveSequence().longestConsecutive(root)
30 |
31 | XCTAssertEqual(result, 2)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/BullsAndCowsTest.swift:
--------------------------------------------------------------------------------
1 | //
2 | // BullsAndCowsTest.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 01/04/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class BullsAndCowsTest: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let secret = "1807"
18 | let guess = "7810"
19 |
20 | let result = BullsAndCows().getHint(secret, guess)
21 |
22 | XCTAssertEqual(result, "1A3B")
23 | }
24 |
25 | func test_B() {
26 | let secret = "1123"
27 | let guess = "0111"
28 |
29 | let result = BullsAndCows().getHint(secret, guess)
30 |
31 | XCTAssertEqual(result, "1A1B")
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CheckIfNAndItsDoubleExistTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CheckIfNAndItsDoubleExistTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 23/02/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CheckIfNAndItsDoubleExistTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let arr = [10,2,5,3]
18 |
19 | let result = CheckIfNAndItsDoubleExist().checkIfExist(arr)
20 |
21 | XCTAssertTrue(result)
22 | }
23 |
24 | func test_B() {
25 | let arr = [3,1,7,11]
26 |
27 | let result = CheckIfNAndItsDoubleExist().checkIfExist(arr)
28 |
29 | XCTAssertFalse(result)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CircularArrayLoopTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CircularArrayLoopTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 04/09/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CircularArrayLoopTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [2,-1,1,2,2]
18 |
19 | let result = CircularArrayLoop().circularArrayLoop(nums)
20 |
21 | XCTAssertTrue(result)
22 | }
23 |
24 | func test_B() {
25 | let nums = [-1,-2,-3,-4,-5,6]
26 |
27 | let result = CircularArrayLoop().circularArrayLoop(nums)
28 |
29 | XCTAssertFalse(result)
30 | }
31 |
32 | func test_C() {
33 | let nums = [1,-1,5,1,4]
34 |
35 | let result = CircularArrayLoop().circularArrayLoop(nums)
36 |
37 | XCTAssertTrue(result)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ClimbingStairsTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ClimbingStairsTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 21/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class ClimbingStairsTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let n = 2
19 |
20 | let result = ClimbingStairs().climbStairs(n)
21 |
22 | XCTAssertEqual(result, 2)
23 | }
24 |
25 | func test_B() {
26 | let n = 3
27 |
28 | let result = ClimbingStairs().climbStairs(n)
29 |
30 | XCTAssertEqual(result, 3)
31 | }
32 |
33 | func test_C() {
34 | let n = 35
35 |
36 | let result = ClimbingStairs().climbStairs(n)
37 |
38 | XCTAssertEqual(result, 14930352)
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ClumsyFactorialTests.swift:
--------------------------------------------------------------------------------
1 | // Created 12/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct ClumsyFactorialTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let n = 4
14 |
15 | let result = ClumsyFactorial().clumsy(n)
16 |
17 | #expect(result == 7)
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let n = 10
23 |
24 | let result = ClumsyFactorial().clumsy(n)
25 |
26 | #expect(result == 12)
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ConcatenationOfArrayTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ConcatenationOfArrayTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 06/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class ConcatenationOfArrayTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [1, 2, 1]
18 |
19 | let result = ConcatenationOfArray().getConcatenation(nums)
20 |
21 | XCTAssertEqual(result, [1, 2, 1, 1, 2, 1])
22 | }
23 |
24 | func test_B() {
25 | let nums = [1, 3, 2, 1]
26 |
27 | let result = ConcatenationOfArray().getConcatenation(nums)
28 |
29 | XCTAssertEqual(result, [1, 3, 2, 1, 1, 3, 2, 1])
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ConsecutiveCharactersTests.swift:
--------------------------------------------------------------------------------
1 | // Created 01/06/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct ConsecutiveCharactersTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let s = "leetcode"
14 |
15 | let result = ConsecutiveCharacters().maxPower(s)
16 |
17 | #expect(result == 2)
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let s = "abbcccddddeeeeedcba"
23 |
24 | let result = ConsecutiveCharacters().maxPower(s)
25 |
26 | #expect(result == 5)
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ConstructBinarySearchTreeFromPreorderTraversalTests.swift:
--------------------------------------------------------------------------------
1 | // Created 13/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct ConstructBinarySearchTreeFromPreorderTraversalTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let preorder = [8,5,1,7,10,12]
14 |
15 | let result = ConstructBinarySearchTreeFromPreorderTraversal().bstFromPreorder(preorder)
16 | let values = TreeNode.serialize(result)
17 |
18 | #expect(values == [8,5,10,1,7,nil,12])
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let preorder = [1,3]
24 |
25 | let result = ConstructBinarySearchTreeFromPreorderTraversal().bstFromPreorder(preorder)
26 | let values = TreeNode.serialize(result)
27 |
28 | #expect(values == [1,nil,3])
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ConstructSmallestNumberFromDIStringTest.swift:
--------------------------------------------------------------------------------
1 | // Created 13/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct ConstructSmallestNumberFromDIStringTest {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let pattern = "IIIDIDDD"
14 |
15 | let result = ConstructSmallestNumberFromDIString().smallestNumber(pattern)
16 |
17 | #expect(result == "123549876")
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let pattern = "DDD"
23 |
24 | let result = ConstructSmallestNumberFromDIString().smallestNumber(pattern)
25 |
26 | #expect(result == "4321")
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ConstructStringFromBinaryTreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ConstructStringFromBinaryTreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 13/09/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class ConstructStringFromBinaryTreeTests: XCTestCase {
13 |
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let data = [1, 2, 3, 4]
19 | let root = TreeNode.deserialize(data)
20 |
21 | let result = ConstructStringFromBinaryTree().tree2str(root)
22 |
23 | XCTAssertEqual(result, "1(2(4))(3)")
24 | }
25 |
26 | func test_B() {
27 | let data = [1, 2, 3, nil, 4]
28 | let root = TreeNode.deserialize(data)
29 |
30 | let result = ConstructStringFromBinaryTree().tree2str(root)
31 |
32 | XCTAssertEqual(result, "1(2()(4))(3)")
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ContainsDuplicateTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ContainsDuplicateTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 08/04/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class ContainsDuplicateTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [1, 2, 3, 1]
18 |
19 | let result = ContainsDuplicate().containsDuplicate(nums)
20 |
21 | XCTAssertTrue(result)
22 | }
23 |
24 | func test_B() {
25 | let nums = [1, 2, 3, 4]
26 |
27 | let result = ContainsDuplicate().containsDuplicate(nums)
28 |
29 | XCTAssertFalse(result)
30 | }
31 |
32 | func test_C() {
33 | let nums = [1, 1, 1, 3, 3, 4, 3, 2, 4, 2]
34 |
35 | let result = ContainsDuplicate().containsDuplicate(nums)
36 |
37 | XCTAssertTrue(result)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ConvertBinaryNumberInALinkedListToIntegerTests.swift:
--------------------------------------------------------------------------------
1 | // Created 08/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct ConvertBinaryNumberInALinkedListToIntegerTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let data = [1,0,1]
14 | let head = ListNode.deserialize(data)
15 |
16 | let result = ConvertBinaryNumberInALinkedListToInteger().getDecimalValue(head)
17 |
18 | #expect(result == 5)
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let data = [0]
24 | let head = ListNode.deserialize(data)
25 |
26 | let result = ConvertBinaryNumberInALinkedListToInteger().getDecimalValue(head)
27 |
28 | #expect(result == 0)
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CountBinarySubstringsTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CountBinarySubstringsTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 11/06/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CountBinarySubstringsTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let s = "00110011"
18 |
19 | let result = CountBinarySubstrings().countBinarySubstrings(s)
20 |
21 | XCTAssertEqual(result, 6)
22 | }
23 |
24 | func test_B() {
25 | let s = "10101"
26 |
27 | let result = CountBinarySubstrings().countBinarySubstrings(s)
28 |
29 | XCTAssertEqual(result, 4)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CountNegativeNumbersInASortedMatrixTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CountNegativeNumbersInASortedMatrixTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 24/02/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CountNegativeNumbersInASortedMatrixTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
18 |
19 | let result = CountNegativeNumbersInASortedMatrix().countNegatives(grid)
20 |
21 | XCTAssertEqual(result, 8)
22 | }
23 |
24 | func test_B() {
25 | let grid = [[3,2],[1,0]]
26 |
27 | let result = CountNegativeNumbersInASortedMatrix().countNegatives(grid)
28 |
29 | XCTAssertEqual(result, 0)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CountNodesEqualToAverageOfSubtreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CountNodesEqualToAverageOfSubtreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 10/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CountNodesEqualToAverageOfSubtreeTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [4,8,5,0,1,nil,6]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = CountNodesEqualToAverageOfSubtree().averageOfSubtree(root)
21 |
22 | XCTAssertEqual(result, 5)
23 | }
24 |
25 | func test_B() {
26 | let data = [1]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = CountNodesEqualToAverageOfSubtree().averageOfSubtree(root)
30 |
31 | XCTAssertEqual(result, 1)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CountNodesWithTheHighestScoreTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CountNodesWithTheHighestScoreTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 20/02/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CountNodesWithTheHighestScoreTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let parents = [-1,2,0,2,0]
18 |
19 | let result = CountNodesWithTheHighestScore().countHighestScoreNodes(parents)
20 |
21 | XCTAssertEqual(result, 3)
22 | }
23 |
24 | func test_B() {
25 | let parents = [-1,2,0]
26 |
27 | let result = CountNodesWithTheHighestScore().countHighestScoreNodes(parents)
28 |
29 | XCTAssertEqual(result, 2)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CountPairsWhoseSumIsLessThanTargetTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CountPairsWhoseSumIsLessThanTargetTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 24/02/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CountPairsWhoseSumIsLessThanTargetTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [-1,1,2,3,1]
18 | let target = 2
19 |
20 | let result = CountPairsWhoseSumIsLessThanTarget().countPairs(nums, target)
21 |
22 | XCTAssertEqual(result, 3)
23 | }
24 |
25 | func test_B() {
26 | let nums = [-6,2,5,-2,-7,-1,3]
27 | let target = -2
28 |
29 | let result = CountPairsWhoseSumIsLessThanTarget().countPairs(nums, target)
30 |
31 | XCTAssertEqual(result, 10)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CountSortedVowelStringsTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CountSortedVowelStringsTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 11/05/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CountSortedVowelStringsTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let n = 1
18 |
19 | let result = CountSortedVowelStrings().countVowelStrings(n)
20 |
21 | XCTAssertEqual(result, 5)
22 | }
23 |
24 | func test_B() {
25 | let n = 2
26 |
27 | let result = CountSortedVowelStrings().countVowelStrings(n)
28 |
29 | XCTAssertEqual(result, 15)
30 | }
31 |
32 | func test_C() {
33 | let n = 33
34 |
35 | let result = CountSortedVowelStrings().countVowelStrings(n)
36 |
37 | XCTAssertEqual(result, 66045)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CourseScheduleTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CourseScheduleTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 12/04/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CourseScheduleTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let numCourses = 2
18 | let prerequisites = [[1, 0]]
19 |
20 | let result = CourseSchedule().canFinish(numCourses, prerequisites)
21 |
22 | XCTAssertTrue(result)
23 | }
24 |
25 | func test_B() {
26 | let numCourses = 2
27 | let prerequisites = [[1, 0],
28 | [0, 1]]
29 |
30 | let result = CourseSchedule().canFinish(numCourses, prerequisites)
31 |
32 | XCTAssertFalse(result)
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CousinsInBinaryTreeIITests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // CousinsInBinaryTreeIITests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 16/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class CousinsInBinaryTreeIITests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [5,4,9,1,10,nil,7]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = CousinsInBinaryTreeII().replaceValueInTree(root)
21 | let values = TreeNode.serialize(result)
22 |
23 | XCTAssertEqual(values, [0,0,0,7,7,nil,11])
24 | }
25 |
26 | func test_B() {
27 | let data = [3,1,2]
28 | let root = TreeNode.deserialize(data)
29 |
30 | let result = CousinsInBinaryTreeII().replaceValueInTree(root)
31 | let values = TreeNode.serialize(result)
32 |
33 | XCTAssertEqual(values, [0,0,0])
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/CrawlerLogFolderTests.swift:
--------------------------------------------------------------------------------
1 | // Created 11/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct CrawlerLogFolderTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let logs = ["d1/","d2/","./","d3/","../","d31/"]
14 |
15 | let result = CrawlerLogFolder().minOperations(logs)
16 |
17 | #expect(result == 3)
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let logs = ["d1/","../","../","../"]
23 |
24 | let result = CrawlerLogFolder().minOperations(logs)
25 |
26 | #expect(result == 0)
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/DIStringMatchTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // DIStringMatchTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 05/06/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class DIStringMatchTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let s = "IDID"
18 |
19 | let result = DIStringMatch().diStringMatch(s)
20 |
21 | XCTAssertEqual(result, [0,4,1,3,2])
22 | }
23 |
24 | func test_B() {
25 | let s = "III"
26 |
27 | let result = DIStringMatch().diStringMatch(s)
28 |
29 | XCTAssertEqual(result, [0,1,2,3])
30 | }
31 |
32 | func test_C() {
33 | let s = "DDI"
34 |
35 | let result = DIStringMatch().diStringMatch(s)
36 |
37 | XCTAssertEqual(result, [3,2,0,1])
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/DeepestLeavesSumTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // DeepestLeavesSumTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 10/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class DeepestLeavesSumTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [1,2,3,4,5,nil,6,7,nil,nil,nil,nil,8]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = DeepestLeavesSum().deepestLeavesSum(root)
21 |
22 | XCTAssertEqual(result, 15)
23 | }
24 |
25 | func test_B() {
26 | let data = [6,7,8,2,7,1,3,9,nil,1,4,nil,nil,nil,5]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = DeepestLeavesSum().deepestLeavesSum(root)
30 |
31 | XCTAssertEqual(result, 19)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/DiagonalTraverseTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // DiagonalTraverseTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 01/01/2022.
6 | // Copyright © 2022 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class DiagonalTraverseTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let mat = [[1, 2, 3],
19 | [4, 5, 6],
20 | [7, 8, 9]]
21 |
22 | let result = DiagonalTraverse().findDiagonalOrder(mat)
23 |
24 | XCTAssertEqual(result, [1, 2, 4, 7, 5, 3, 6, 8, 9])
25 | }
26 |
27 | func test_B() {
28 | let mat = [[1, 2],
29 | [3, 4]]
30 |
31 | let result = DiagonalTraverse().findDiagonalOrder(mat)
32 |
33 | XCTAssertEqual(result, [1, 2, 3, 4])
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/DiameterOfBinaryTreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // DiameterOfBinaryTreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 09/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class DiameterOfBinaryTreeTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let data = [1, 2, 3, 4, 5]
19 |
20 | let root = TreeNode.deserialize(data)
21 |
22 | let result = DiameterOfBinaryTree().diameterOfBinaryTree(root)
23 |
24 | XCTAssertEqual(result, 3)
25 | }
26 |
27 | func test_Bs() {
28 | let data = [1, 2]
29 |
30 | let root = TreeNode.deserialize(data)
31 |
32 | let result = DiameterOfBinaryTree().diameterOfBinaryTree(root)
33 |
34 | XCTAssertEqual(result, 1)
35 | }
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/DuplicateZerosTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // DuplicateZerosTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 02/09/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class DuplicateZerosTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | var arr = [1,0,2,3,0,4,5,0]
18 |
19 | DuplicateZeros().duplicateZeros(&arr)
20 |
21 | XCTAssertEqual(arr, [1,0,0,2,3,0,0,4])
22 | }
23 |
24 | func test_B() {
25 | var arr = [1,2,3]
26 |
27 | DuplicateZeros().duplicateZeros(&arr)
28 |
29 | XCTAssertEqual(arr, [1,2,3])
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/EvaluateBooleanBinaryTreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // EvaluateBooleanBinaryTreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 10/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class EvaluateBooleanBinaryTreeTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [2,1,3,nil,nil,0,1]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = EvaluateBooleanBinaryTree().evaluateTree(root)
21 |
22 | XCTAssertTrue(result)
23 | }
24 |
25 | func test_B() {
26 | let data = [0]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = EvaluateBooleanBinaryTree().evaluateTree(root)
30 |
31 | XCTAssertFalse(result)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ExcelSheetColumnNumberTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ExcelSheetColumnNumberTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 22/02/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class ExcelSheetColumnNumberTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let columnTitle = "A"
18 |
19 | let result = ExcelSheetColumnNumber().titleToNumber(columnTitle)
20 |
21 | XCTAssertEqual(result, 1)
22 | }
23 |
24 | func test_B() {
25 | let columnTitle = "AB"
26 |
27 | let result = ExcelSheetColumnNumber().titleToNumber(columnTitle)
28 |
29 | XCTAssertEqual(result, 28)
30 | }
31 |
32 | func test_C() {
33 | let columnTitle = "ZY"
34 |
35 | let result = ExcelSheetColumnNumber().titleToNumber(columnTitle)
36 |
37 | XCTAssertEqual(result, 701)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FindAllKDistantIndicesInAnArrayTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FindAllKDistantIndicesInAnArrayTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 11/06/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class FindAllKDistantIndicesInAnArrayTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [3,4,9,1,3,9,5]
18 | let key = 9
19 | let k = 1
20 |
21 | let result = FindAllKDistantIndicesInAnArray().findKDistantIndices(nums, key, k)
22 |
23 | XCTAssertEqual(result, [1,2,3,4,5,6])
24 | }
25 |
26 | func test_B() {
27 | let nums = [2,2,2,2,2]
28 | let key = 2
29 | let k = 2
30 |
31 | let result = FindAllKDistantIndicesInAnArray().findKDistantIndices(nums, key, k)
32 |
33 | XCTAssertEqual(result, [0,1,2,3,4])
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FindAllNumbersDisappearedInAnArrayTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FindAllNumbersDisappearedInAnArrayTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 07/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class FindAllNumbersDisappearedInAnArrayTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [4, 3, 2, 7, 8, 2, 3, 1]
18 |
19 | let result = FindAllNumbersDisappearedInAnArray().findDisappearedNumbers(nums)
20 |
21 | XCTAssertEqual(result, [5, 6])
22 | }
23 |
24 | func test_B() {
25 | let nums = [1, 1]
26 |
27 | let result = FindAllNumbersDisappearedInAnArray().findDisappearedNumbers(nums)
28 |
29 | XCTAssertEqual(result, [2])
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FindLargestValueInEachTreeRowTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FindLargestValueInEachTreeRowTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 15/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class FindLargestValueInEachTreeRowTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [1,3,2,5,3,nil,9]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = FindLargestValueInEachTreeRow().largestValues(root)
21 |
22 | XCTAssertEqual(result, [1,3,9])
23 | }
24 |
25 | func test_B() {
26 | let data = [1,2,3]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = FindLargestValueInEachTreeRow().largestValues(root)
30 |
31 | XCTAssertEqual(result, [1,3])
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FindLeavesOfBinaryTreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FindLeavesOfBinaryTreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 05/08/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class FindLeavesOfBinaryTreeTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [1, 2, 3, 4, 5]
18 |
19 | let root = TreeNode.deserialize(data)
20 |
21 | let result = FindLeavesOfBinaryTree().findLeaves(root)
22 |
23 | XCTAssertEqual(result, [[4, 5, 3], [2], [1]])
24 | }
25 |
26 | func test_B() {
27 | let data = [1]
28 |
29 | let root = TreeNode.deserialize(data)
30 |
31 | let result = FindLeavesOfBinaryTree().findLeaves(root)
32 |
33 | XCTAssertEqual(result, [[1]])
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FindNearestRightNodeInBinaryTreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FindNearestRightNodeInBinaryTreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 24/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class FindNearestRightNodeInBinaryTreeTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let u = TreeNode(4)
18 | let data = [1,2,3,nil,4,5,6]
19 | let root = TreeNode.deserialize(data)
20 |
21 | let result = FindNearestRightNodeInBinaryTree().findNearestRightNode(root, u)
22 |
23 | XCTAssertEqual(result?.val, 5)
24 | }
25 |
26 | func test_B() {
27 | let u = TreeNode(2)
28 | let data = [3,nil,4,2]
29 | let root = TreeNode.deserialize(data)
30 |
31 | let result = FindNearestRightNodeInBinaryTree().findNearestRightNode(root, u)
32 |
33 | XCTAssertNil(result)
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FindPivotIndexTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FindPivotIndexTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 07/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class FindPivotIndexTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [1, 7, 3, 6, 5, 6]
18 |
19 | let result = FindPivotIndex().pivotIndex(nums)
20 |
21 | XCTAssertEqual(result, 3)
22 | }
23 |
24 | func test_B() {
25 | let nums = [1, 2, 3]
26 |
27 | let result = FindPivotIndex().pivotIndex(nums)
28 |
29 | XCTAssertEqual(result, -1)
30 | }
31 |
32 | func test_C() {
33 | let nums = [2, 1, -1]
34 |
35 | let result = FindPivotIndex().pivotIndex(nums)
36 |
37 | XCTAssertEqual(result, 0)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FindTheArrayConcatenationValueTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FindTheArrayConcatenationValueTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 11/06/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class FindTheArrayConcatenationValueTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [7,52,2,4]
18 |
19 | let result = FindTheArrayConcatenationValue().findTheArrayConcVal(nums)
20 |
21 | XCTAssertEqual(result, 596)
22 | }
23 |
24 | func test_B() {
25 | let nums = [5,14,13,8,12]
26 |
27 | let result = FindTheArrayConcatenationValue().findTheArrayConcVal(nums)
28 |
29 | XCTAssertEqual(result, 673)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FirstBadVersionTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FirstBadVersionTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 18/11/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class FirstBadVersionTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let n = 5
19 | let bad = 4
20 |
21 | let sut = FirstBadVersion(badVersion: bad)
22 | let result = sut.firstBadVersion(n)
23 |
24 | XCTAssertEqual(result, bad)
25 | }
26 |
27 | func test_B() {
28 | let n = 1
29 | let bad = 1
30 |
31 | let sut = FirstBadVersion(badVersion: bad)
32 | let result = sut.firstBadVersion(n)
33 |
34 | XCTAssertEqual(result, bad)
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FixedPointTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FixedPointTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 27/02/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class FixedPointTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let arr = [-10,-5,0,3,7]
18 |
19 | let result = FixedPoint().fixedPoint(arr)
20 |
21 | XCTAssertEqual(result, 3)
22 | }
23 |
24 | func test_B() {
25 | let arr = [0,2,5,8,17]
26 |
27 | let result = FixedPoint().fixedPoint(arr)
28 |
29 | XCTAssertEqual(result, 0)
30 | }
31 |
32 | func test_C() {
33 | let arr = [-10,-5,3,4,7,9]
34 |
35 | let result = FixedPoint().fixedPoint(arr)
36 |
37 | XCTAssertEqual(result, -1)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/FlippingAnImageTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // FlippingAnImageTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 05/06/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class FlippingAnImageTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let image = [[1,1,0],[1,0,1],[0,0,0]]
18 |
19 | let result = FlippingAnImage().flipAndInvertImage(image)
20 |
21 | XCTAssertEqual(result, [[1,0,0],[0,1,0],[1,1,1]])
22 | }
23 |
24 | func test_B() {
25 | let image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
26 |
27 | let result = FlippingAnImage().flipAndInvertImage(image)
28 |
29 | XCTAssertEqual(result, [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]])
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/GameOfLifeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // GameOfLifeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 13/04/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class GameOfLifeTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | var board = [[0, 1, 0],
18 | [0, 0, 1],
19 | [1, 1, 1],
20 | [0, 0, 0]]
21 |
22 | GameOfLife().gameOfLife(&board)
23 |
24 | XCTAssertEqual(board, [[0, 0, 0], [1, 0, 1], [0, 1, 1], [0, 1, 0]])
25 | }
26 |
27 | func test_B() {
28 | var board = [[1, 1],
29 | [1, 0]]
30 |
31 | GameOfLife().gameOfLife(&board)
32 |
33 | XCTAssertEqual(board, [[1, 1], [1, 1]])
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/GenerateParenthesesTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // GenerateParenthesesTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 10/11/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class GenerateParenthesesTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let n = 3
19 |
20 | let result = GenerateParentheses().generateParenthesis(n)
21 |
22 | XCTAssertEqual(result, ["((()))", "(()())", "(())()", "()(())", "()()()"])
23 | }
24 |
25 | func test_B() {
26 | let n = 1
27 |
28 | let result = GenerateParentheses().generateParenthesis(n)
29 |
30 | XCTAssertEqual(result, ["()"])
31 | }
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/GoatLatinTests.swift:
--------------------------------------------------------------------------------
1 | // Created 31/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct GoatLatinTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let sentence = "I speak Goat Latin"
14 |
15 | let result = GoatLatin().toGoatLatin(sentence)
16 |
17 | #expect(result == "Imaa peaksmaaa oatGmaaaa atinLmaaaaa")
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let sentence = "The quick brown fox jumped over the lazy dog"
23 |
24 | let result = GoatLatin().toGoatLatin(sentence)
25 |
26 | #expect(result == "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa")
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/HappyNumberTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // HappyNumberTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 20/01/2022.
6 | // Copyright © 2022 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class HappyNumberTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let n = 19
19 |
20 | let result = HappyNumber().isHappy(n)
21 |
22 | XCTAssertTrue(result)
23 | }
24 |
25 | func test_B() {
26 | let n = 2
27 |
28 | let result = HappyNumber().isHappy(n)
29 |
30 | XCTAssertFalse(result)
31 | }
32 |
33 | func test_C() {
34 | let n = 1
35 |
36 | let result = HappyNumber().isHappy(n)
37 |
38 | XCTAssertTrue(result)
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/HeatersTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // HeatersTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 05/09/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class HeatersTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let houses = [1,2,3]
18 | let heaters = [2]
19 |
20 | let result = Heaters().findRadius(houses, heaters)
21 |
22 | XCTAssertEqual(result, 1)
23 | }
24 |
25 | func test_B() {
26 | let houses = [1,2,3,4]
27 | let heaters = [1,4]
28 |
29 | let result = Heaters().findRadius(houses, heaters)
30 |
31 | XCTAssertEqual(result, 1)
32 | }
33 |
34 | func test_C() {
35 | let houses = [1,5]
36 | let heaters = [2]
37 |
38 | let result = Heaters().findRadius(houses, heaters)
39 |
40 | XCTAssertEqual(result, 3)
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/HouseRobberIIITests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // HouseRobberIIITests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 13/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class HouseRobberIIITests: XCTestCase {
13 |
14 |
15 | //MARK: - Tests
16 |
17 | func test_A() {
18 | let data = [3,2,3,nil,3,nil,1]
19 | let root = TreeNode.deserialize(data)
20 |
21 | let result = HouseRobberIII().rob(root)
22 |
23 | XCTAssertEqual(result, 7)
24 | }
25 |
26 | func test_B() {
27 | let data = [3,4,5,1,3,nil,1]
28 | let root = TreeNode.deserialize(data)
29 |
30 | let result = HouseRobberIII().rob(root)
31 |
32 | XCTAssertEqual(result, 9)
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/InsertIntervalTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // InsertIntervalTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 14/03/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class InsertIntervalTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let intervals = [[1, 3], [6, 9]]
18 | let newInterval = [2, 5]
19 |
20 | let result = InsertInterval().insert(intervals, newInterval)
21 |
22 | XCTAssertEqual(result, [[1, 5], [6, 9]])
23 | }
24 |
25 | func test_B() {
26 | let intervals = [[1, 2], [3, 5], [6, 7], [8, 10], [12, 16]]
27 | let newInterval = [4, 8]
28 |
29 | let result = InsertInterval().insert(intervals, newInterval)
30 |
31 | XCTAssertEqual(result, [[1, 2], [3, 10], [12, 16]])
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/InsertionSortListTests.swift:
--------------------------------------------------------------------------------
1 | // Created 09/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct InsertionSortListTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let data = [4,2,1,3]
14 | let head = ListNode.deserialize(data)
15 |
16 | let result = InsertionSortList().insertionSortList(head)
17 | let values = ListNode.serialize(result)
18 |
19 | #expect(values == [1,2,3,4])
20 | }
21 |
22 | @Test
23 | func test_B() {
24 | let data = [-1,5,3,4,0]
25 | let head = ListNode.deserialize(data)
26 |
27 | let result = InsertionSortList().insertionSortList(head)
28 | let values = ListNode.serialize(result)
29 |
30 | #expect(values == [-1,0,3,4,5])
31 | }
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/IsGraphBipartiteTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // IsGraphBipartiteTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 03/04/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class IsGraphBipartiteTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let graph = [[1, 2, 3], [0, 2], [0, 1, 3], [0, 2]]
18 |
19 | let result = IsGraphBipartite().isBipartite(graph)
20 |
21 | XCTAssertFalse(result)
22 | }
23 |
24 | func test_B() {
25 | let graph = [[1, 3], [0, 2], [1, 3], [0, 2]]
26 |
27 | let result = IsGraphBipartite().isBipartite(graph)
28 |
29 | XCTAssertTrue(result)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/IsSubsequenceTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // IsSubsequence.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 07/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class IsSubsequenceTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let s = "abc"
18 | let t = "ahbgdc"
19 |
20 | let result = IsSubsequence().isSubsequence(s, t)
21 |
22 | XCTAssertTrue(result)
23 | }
24 |
25 | func test_B() {
26 | let s = "axc"
27 | let t = "ahbgdc"
28 |
29 | let result = IsSubsequence().isSubsequence(s, t)
30 |
31 | XCTAssertFalse(result)
32 | }
33 |
34 | func test_C() {
35 | let s = "abc"
36 | let t = "ahbgdcz"
37 |
38 | let result = IsSubsequence().isSubsequence(s, t)
39 |
40 | XCTAssertTrue(result)
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/JumpGameIITests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // JumpGameIITests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 09/03/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class JumpGameIITests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [2, 3, 1, 1, 4]
18 |
19 | let result = JumpGameII().jump(nums)
20 |
21 | XCTAssertEqual(result, 2)
22 | }
23 |
24 | func test_B() {
25 | let nums = [2, 3, 0, 1, 4]
26 |
27 | let result = JumpGameII().jump(nums)
28 |
29 | XCTAssertEqual(result, 2)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/KthSmallestPrimeFractionTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // KthSmallestPrimeFractionTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 12/09/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class KthSmallestPrimeFractionTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let arr = [1,2,3,5]
18 | let k = 3
19 |
20 | let result = KthSmallestPrimeFraction().kthSmallestPrimeFraction(arr, k)
21 |
22 | XCTAssertEqual(result, [2,5])
23 | }
24 |
25 | func test_B() {
26 | let arr = [1,7]
27 | let k = 1
28 |
29 | let result = KthSmallestPrimeFraction().kthSmallestPrimeFraction(arr, k)
30 |
31 | XCTAssertEqual(result, [1,7])
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/LengthOfLastWordTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // LengthOfLastWordTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 14/03/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class LengthOfLastWordTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let s = "Hello World"
18 |
19 | let result = LengthOfLastWord().lengthOfLastWord(s)
20 |
21 | XCTAssertEqual(result, 5)
22 | }
23 |
24 | func test_B() {
25 | let s = " fly me to the moon "
26 |
27 | let result = LengthOfLastWord().lengthOfLastWord(s)
28 |
29 | XCTAssertEqual(result, 4)
30 | }
31 |
32 | func test_C() {
33 | let s = "luffy is still joyboy"
34 |
35 | let result = LengthOfLastWord().lengthOfLastWord(s)
36 |
37 | XCTAssertEqual(result, 6)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/LongestConsecutiveSequenceTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // LongestConsecutiveSequenceTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 10/04/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class LongestConsecutiveSequenceTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [100, 4, 200, 1, 3, 2]
18 |
19 | let result = LongestConsecutiveSequence().longestConsecutive(nums)
20 |
21 | XCTAssertEqual(result, 4)
22 | }
23 |
24 | func test_B() {
25 | let nums = [0, 3, 7, 2, 5, 8, 4, 6, 0, 1]
26 |
27 | let result = LongestConsecutiveSequence().longestConsecutive(nums)
28 |
29 | XCTAssertEqual(result, 9)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/LongestSubsequenceWithLimitedSumTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // LongestSubsequenceWithLimitedSumTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 25/02/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class LongestSubsequenceWithLimitedSumTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [4,5,2,1]
18 | let queries = [3,10,21]
19 |
20 | let result = LongestSubsequenceWithLimitedSum().answerQueries(nums, queries)
21 |
22 | XCTAssertEqual(result, [2,3,4])
23 | }
24 |
25 | func test_B() {
26 | let nums = [2,3,4,5]
27 | let queries = [1]
28 |
29 | let result = LongestSubsequenceWithLimitedSum().answerQueries(nums, queries)
30 |
31 | XCTAssertEqual(result, [0])
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/LongestSubstringWithAtMostTwoDistinctCharactersTests.swift:
--------------------------------------------------------------------------------
1 | // Created 01/06/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct LongestSubstringWithAtMostTwoDistinctCharactersTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let s = "eceba"
14 |
15 | let result = LongestSubstringWithAtMostTwoDistinctCharacters().lengthOfLongestSubstringTwoDistinct(s)
16 |
17 | #expect(result == 3)
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let s = "ccaabbb"
23 |
24 | let result = LongestSubstringWithAtMostTwoDistinctCharacters().lengthOfLongestSubstringTwoDistinct(s)
25 |
26 | #expect(result == 5)
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MajorityElementIITests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MajorityElementIITests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 21/02/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MajorityElementIITests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [3, 2, 3]
18 |
19 | let result = MajorityElementII().majorityElement(nums)
20 |
21 | XCTAssertEqual(result, [3])
22 | }
23 |
24 | func test_B() {
25 | let nums = [1]
26 |
27 | let result = MajorityElementII().majorityElement(nums)
28 |
29 | XCTAssertEqual(result, [1])
30 | }
31 |
32 | func test_C() {
33 | let nums = [1, 2]
34 |
35 | let result = MajorityElementII().majorityElement(nums)
36 |
37 | XCTAssertEqual(result, [1, 2])
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MajorityElementTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MajorityElementTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 21/02/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MajorityElementTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [3, 2, 3]
18 |
19 | let result = MajorityElement().majorityElement(nums)
20 |
21 | XCTAssertEqual(result, 3)
22 | }
23 |
24 | func test_B() {
25 | let nums = [2, 2, 1, 1, 1, 2, 2]
26 |
27 | let result = MajorityElement().majorityElement(nums)
28 |
29 | XCTAssertEqual(result, 2)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MakeCostsOfPathsEqualInABinaryTreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MakeCostsOfPathsEqualInABinaryTreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 08/12/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MakeCostsOfPathsEqualInABinaryTreeTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let n = 7
18 | let cost = [1,5,2,2,3,3,1]
19 |
20 | let result = MakeCostsOfPathsEqualInABinaryTree().minIncrements(n, cost)
21 |
22 | XCTAssertEqual(result, 6)
23 | }
24 |
25 | func test_B() {
26 | let n = 3
27 | let cost = [5,3,3]
28 |
29 | let result = MakeCostsOfPathsEqualInABinaryTree().minIncrements(n, cost)
30 |
31 | XCTAssertEqual(result, 0)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MakeTheStringGreatTests.swift:
--------------------------------------------------------------------------------
1 | // Created 11/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct MakeTheStringGreatTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let s = "leEeetcode"
14 |
15 | let result = MakeTheStringGreat().makeGood(s)
16 |
17 | #expect(result == "leetcode")
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let s = "abBAcC"
23 |
24 | let result = MakeTheStringGreat().makeGood(s)
25 |
26 | #expect(result == "")
27 | }
28 |
29 | @Test
30 | func test_C() {
31 | let s = "s"
32 |
33 | let result = MakeTheStringGreat().makeGood(s)
34 |
35 | #expect(result == "s")
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/Matrix01Tests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // Matrix01Tests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 15/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class Matrix01Tests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let mat = [[0, 0, 0],
19 | [0, 1, 0],
20 | [0, 0, 0]]
21 |
22 | let result = Matrix01().updateMatrix(mat)
23 |
24 | XCTAssertEqual(result, [[0, 0, 0], [0, 1, 0], [0, 0, 0]])
25 | }
26 |
27 | func test_B() {
28 | let mat = [[0, 0, 0],
29 | [0, 1, 0],
30 | [1, 1, 1]]
31 |
32 | let result = Matrix01().updateMatrix(mat)
33 |
34 | XCTAssertEqual(result, [[0, 0, 0], [0, 1, 0], [1, 2, 1]])
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximalRangeThatEachElementIsMaximumInItTests.swift:
--------------------------------------------------------------------------------
1 | // Created 12/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct MaximalRangeThatEachElementIsMaximumInItTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let nums = [1,5,4,3,6]
14 |
15 | let result = MaximalRangeThatEachElementIsMaximumInIt().maximumLengthOfRanges(nums)
16 |
17 | #expect(result == [1,4,2,1,5])
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let nums = [1,2,3,4,5]
23 |
24 | let result = MaximalRangeThatEachElementIsMaximumInIt().maximumLengthOfRanges(nums)
25 |
26 | #expect(result == [1,2,3,4,5])
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumAverageSubtreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MaximumAverageSubtreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 07/12/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MaximumAverageSubtreeTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [5,6,1]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = MaximumAverageSubtree().maximumAverageSubtree(root)
21 |
22 | XCTAssertEqual(result, 6.0, accuracy: 0.00001)
23 | }
24 |
25 | func test_B() {
26 | let data = [0,nil,1]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = MaximumAverageSubtree().maximumAverageSubtree(root)
30 |
31 | XCTAssertEqual(result, 1.0, accuracy: 0.00001)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumBinaryTreeTests.swift:
--------------------------------------------------------------------------------
1 | // Created 07/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct MaximumBinaryTreeTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let nums = [3,2,1,6,0,5]
14 |
15 | let result = MaximumBinaryTree().constructMaximumBinaryTree(nums)
16 | let values = TreeNode.serialize(result)
17 |
18 | #expect(values == [6,3,5,nil,2,0,nil,nil,1])
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let nums = [3,2,1]
24 |
25 | let result = MaximumBinaryTree().constructMaximumBinaryTree(nums)
26 | let values = TreeNode.serialize(result)
27 |
28 | #expect(values == [3,nil,2,nil,1])
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumDifferenceBetweenNodeAndAncestorTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MaximumDifferenceBetweenNodeAndAncestorTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 15/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MaximumDifferenceBetweenNodeAndAncestorTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [8,3,10,1,6,nil,14,nil,nil,4,7,13]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = MaximumDifferenceBetweenNodeAndAncestor().maxAncestorDiff(root)
21 |
22 | XCTAssertEqual(result, 7)
23 | }
24 |
25 | func test_B() {
26 | let data = [1,nil,2,nil,0,3]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = MaximumDifferenceBetweenNodeAndAncestor().maxAncestorDiff(root)
30 |
31 | XCTAssertEqual(result, 3)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumEnemyFortsThatCanBeCapturedTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MaximumEnemyFortsThatCanBeCapturedTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 03/09/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MaximumEnemyFortsThatCanBeCapturedTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let forts = [1,0,0,-1,0,0,0,0,1]
18 |
19 | let result = MaximumEnemyFortsThatCanBeCaptured().captureForts(forts)
20 |
21 | XCTAssertEqual(result, 4)
22 | }
23 |
24 | func test_B() {
25 | let forts = [0,0,1,-1]
26 |
27 | let result = MaximumEnemyFortsThatCanBeCaptured().captureForts(forts)
28 |
29 | XCTAssertEqual(result, 0)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumLevelSumOfABinaryTreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MaximumLevelSumOfABinaryTreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 17/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MaximumLevelSumOfABinaryTreeTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [1,7,0,7,-8,nil,nil]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = MaximumLevelSumOfABinaryTree().maxLevelSum(root)
21 |
22 | XCTAssertEqual(result, 2)
23 | }
24 |
25 | func test_B() {
26 | let data = [989,nil,10250,98693,-89388,nil,nil,nil,-32127]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = MaximumLevelSumOfABinaryTree().maxLevelSum(root)
30 |
31 | XCTAssertEqual(result, 2)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumNestingDepthOfTheParenthesesTests.swift:
--------------------------------------------------------------------------------
1 | // Created 11/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct MaximumNestingDepthOfTheParenthesesTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let s = "(1+(2*3)+((8)/4))+1"
14 |
15 | let result = MaximumNestingDepthOfTheParentheses().maxDepth(s)
16 |
17 | #expect(result == 3)
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let s = "(1)+((2))+(((3)))"
23 |
24 | let result = MaximumNestingDepthOfTheParentheses().maxDepth(s)
25 |
26 | #expect(result == 3)
27 | }
28 |
29 | @Test
30 | func test_C() {
31 | let s = "()(())((()()))"
32 |
33 | let result = MaximumNestingDepthOfTheParentheses().maxDepth(s)
34 |
35 | #expect(result == 3)
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumNumberOfFishInAGridTests.swift:
--------------------------------------------------------------------------------
1 | // Created 06/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct MaximumNumberOfFishInAGridTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let grid = [[0,2,1,0],
14 | [4,0,0,3],
15 | [1,0,0,4],
16 | [0,3,2,0]]
17 |
18 | let result = MaximumNumberOfFishInAGrid().findMaxFish(grid)
19 |
20 | #expect(result == 7)
21 | }
22 |
23 | @Test
24 | func test_B() {
25 | let grid = [[1,0,0,0],
26 | [0,0,0,0],
27 | [0,0,0,0],
28 | [0,0,0,1]]
29 |
30 | let result = MaximumNumberOfFishInAGrid().findMaxFish(grid)
31 |
32 | #expect(result == 1)
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumProductSubarrayTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MaximumProductSubarrayTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 24/04/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MaximumProductSubarrayTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [2, 3, -2, 4]
18 |
19 | let result = MaximumProductSubarray().maxProduct(nums)
20 |
21 | XCTAssertEqual(result, 6)
22 | }
23 |
24 | func test_B() {
25 | let nums = [-2, 0, -1]
26 |
27 | let result = MaximumProductSubarray().maxProduct(nums)
28 |
29 | XCTAssertEqual(result, 0)
30 | }
31 |
32 | func test_C() {
33 | let nums = [-3, -1, -1]
34 |
35 | let result = MaximumProductSubarray().maxProduct(nums)
36 |
37 | XCTAssertEqual(result, 3)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumSubarrayTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MaximumSubarrayTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 31/01/2022.
6 | // Copyright © 2022 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class MaximumSubarrayTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
19 |
20 | let result = MaximumSubarray().maxSubArray(nums)
21 |
22 | XCTAssertEqual(result, 6)
23 | }
24 |
25 | func test_B() {
26 | let nums = [1]
27 |
28 | let result = MaximumSubarray().maxSubArray(nums)
29 |
30 | XCTAssertEqual(result, 1)
31 | }
32 |
33 | func test_C() {
34 | let nums = [5, 4, -1, 7, 8]
35 |
36 | let result = MaximumSubarray().maxSubArray(nums)
37 |
38 | XCTAssertEqual(result, 23)
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MaximumSwapTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MaximumSwapTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 03/01/2022.
6 | // Copyright © 2022 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class MaximumSwapTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let num = 2736
19 |
20 | let result = MaximumSwap().maximumSwap(num)
21 |
22 | XCTAssertEqual(result, 7236)
23 | }
24 |
25 | func test_B() {
26 | let num = 9973
27 |
28 | let result = MaximumSwap().maximumSwap(num)
29 |
30 | XCTAssertEqual(result, 9973)
31 | }
32 |
33 | func test_C() {
34 | let num = 98368
35 |
36 | let result = MaximumSwap().maximumSwap(num)
37 |
38 | XCTAssertEqual(result, 98863)
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MiniParserTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MiniParserTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 17/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class MiniParserTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let s = "324"
19 |
20 | let ni = MiniParser().deserialize(s)
21 |
22 | let result = NestedInteger.serialize(ni)
23 |
24 | XCTAssertEqual(result, s)
25 | }
26 |
27 | func test_B() {
28 | let s = "[123,[456,[789]]]"
29 |
30 | let ni = MiniParser().deserialize(s)
31 |
32 | let result = NestedInteger.serialize(ni)
33 |
34 | XCTAssertEqual(result, s)
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MinimumDepthOfBinaryTreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MinimumDepthOfBinaryTreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 10/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MinimumDepthOfBinaryTreeTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [3, 9, 20, nil, nil, 15, 7]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = MinimumDepthOfBinaryTree().minDepth(root)
21 |
22 | XCTAssertEqual(result, 2)
23 | }
24 |
25 | func test_B() {
26 | let data = [2, nil, 3, nil, 4, nil, 5, nil, 6]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = MinimumDepthOfBinaryTree().minDepth(root)
30 |
31 | XCTAssertEqual(result, 5)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MinimumDistanceBetweenBSTNodesTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MinimumDistanceBetweenBSTNodesTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 10/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MinimumDistanceBetweenBSTNodesTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let data = [4,2,6,1,3]
18 | let root = TreeNode.deserialize(data)
19 |
20 | let result = MinimumDistanceBetweenBSTNodes().minDiffInBST(root)
21 |
22 | XCTAssertEqual(result, 1)
23 | }
24 |
25 | func test_B() {
26 | let data = [1,0,48,nil,nil,12,49]
27 | let root = TreeNode.deserialize(data)
28 |
29 | let result = MinimumDistanceBetweenBSTNodes().minDiffInBST(root)
30 |
31 | XCTAssertEqual(result, 1)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MinimumPairRemovalToSortArrayITests.swift:
--------------------------------------------------------------------------------
1 | // Created 08/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct MinimumPairRemovalToSortArrayITests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let nums = [5,2,3,1]
14 |
15 | let result = MinimumPairRemovalToSortArrayI().minimumPairRemoval(nums)
16 |
17 | #expect(result == 2)
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let nums = [1,2,2]
23 |
24 | let result = MinimumPairRemovalToSortArrayI().minimumPairRemoval(nums)
25 |
26 | #expect(result == 0)
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MinimumPenaltyForAShopTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MinimumPenaltyForAShopTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 04/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MinimumPenaltyForAShopTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let customers = "YYNY"
18 |
19 | let result = MinimumPenaltyForAShop().bestClosingTime(customers)
20 |
21 | XCTAssertEqual(result, 2)
22 | }
23 |
24 | func test_B() {
25 | let customers = "NNNNN"
26 |
27 | let result = MinimumPenaltyForAShop().bestClosingTime(customers)
28 |
29 | XCTAssertEqual(result, 0)
30 | }
31 |
32 | func test_C() {
33 | let customers = "YYYY"
34 |
35 | let result = MinimumPenaltyForAShop().bestClosingTime(customers)
36 |
37 | XCTAssertEqual(result, 4)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MinimumStringLengthAfterRemovingSubstringsTests.swift:
--------------------------------------------------------------------------------
1 | // Created 11/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct MinimumStringLengthAfterRemovingSubstringsTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let s = "ABFCACDB"
14 |
15 | let result = MinimumStringLengthAfterRemovingSubstrings().minLength(s)
16 |
17 | #expect(result == 2)
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let s = "ACBBD"
23 |
24 | let result = MinimumStringLengthAfterRemovingSubstrings().minLength(s)
25 |
26 | #expect(result == 5)
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MissingElementInSortedArrayTests.swift:
--------------------------------------------------------------------------------
1 | // Created 31/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct MissingElementInSortedArrayTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let nums = [4,7,9,10]
14 | let k = 1
15 |
16 | let result = MissingElementInSortedArray().missingElement(nums, k)
17 |
18 | #expect(result == 5)
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let nums = [4,7,9,10]
24 | let k = 3
25 |
26 | let result = MissingElementInSortedArray().missingElement(nums, k)
27 |
28 | #expect(result == 8)
29 | }
30 |
31 | @Test
32 | func test_C() {
33 | let nums = [1,2,4]
34 | let k = 3
35 |
36 | let result = MissingElementInSortedArray().missingElement(nums, k)
37 |
38 | #expect(result == 6)
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MissingNumberTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MissingNumberTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 31/03/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MissingNumberTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [3, 0, 1]
18 |
19 | let result = MissingNumber().missingNumber(nums)
20 |
21 | XCTAssertEqual(result, 2)
22 | }
23 |
24 | func test_B() {
25 | let nums = [0, 1]
26 |
27 | let result = MissingNumber().missingNumber(nums)
28 |
29 | XCTAssertEqual(result, 2)
30 | }
31 |
32 | func test_C() {
33 | let nums = [9, 6, 4, 2, 3, 5, 7, 0, 1]
34 |
35 | let result = MissingNumber().missingNumber(nums)
36 |
37 | XCTAssertEqual(result, 8)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/MovingAverageTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // MovingAverageTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 28/02/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class MovingAverageTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let sut = MovingAverage(3)
18 |
19 | XCTAssertEqual(sut.next(1), 1.0, accuracy: 0.1)
20 | XCTAssertEqual(sut.next(10), 5.5, accuracy: 0.1)
21 | XCTAssertEqual(sut.next(3), 4.6, accuracy: 0.1)
22 | XCTAssertEqual(sut.next(5), 6.0, accuracy: 0.1)
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NaryTreePostorderTraversalTests.swift:
--------------------------------------------------------------------------------
1 | // Created 12/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct NaryTreePostorderTraversalTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let data = [1,nil,3,2,4,nil,5,6]
14 | let root = NaryTreeNode.deserialize(data)
15 |
16 | let result = NaryTreePostorderTraversal().postorder(root)
17 |
18 | #expect(result == [5,6,3,2,4,1])
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let data = [1,nil,2,3,4,5,nil,nil,6,7,nil,8,nil,9,10,nil,nil,11,nil,12,nil,13,nil,nil,14]
24 | let root = NaryTreeNode.deserialize(data)
25 |
26 | let result = NaryTreePostorderTraversal().postorder(root)
27 |
28 | #expect(result == [2,6,14,11,7,3,12,8,4,13,9,10,5,1])
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NaryTreePreorderTraversalTests.swift:
--------------------------------------------------------------------------------
1 | // Created 12/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct NaryTreePreorderTraversalTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let data = [1,nil,3,2,4,nil,5,6]
14 | let root = NaryTreeNode.deserialize(data)
15 |
16 | let result = NaryTreePreorderTraversal().preorder(root)
17 |
18 | #expect(result == [1,3,5,6,2,4])
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let data = [1,nil,2,3,4,5,nil,nil,6,7,nil,8,nil,9,10,nil,nil,11,nil,12,nil,13,nil,nil,14]
24 | let root = NaryTreeNode.deserialize(data)
25 |
26 | let result = NaryTreePreorderTraversal().preorder(root)
27 |
28 | #expect(result == [1,2,3,6,7,11,14,4,8,12,5,9,13,10])
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NestedListWeightSumIITests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // NestedListWeightSumIITests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 17/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class NestedListWeightSumIITests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let data = "[[1,1],2,[1,1]]"
19 | let nestedList = NestedInteger.deserialize(data)
20 |
21 | let result = NestedListWeightSumII().depthSumInverse([nestedList])
22 |
23 | XCTAssertEqual(result, 8)
24 | }
25 |
26 | func test_B() {
27 | let data = "[1,[4,[6]]]"
28 | let nestedList = NestedInteger.deserialize(data)
29 |
30 | let result = NestedListWeightSumII().depthSumInverse([nestedList])
31 |
32 | XCTAssertEqual(result, 17)
33 | }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NestedListWeightSumTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // NestedListWeightSumTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 30/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class NestedListWeightSumTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let data = "[[1,1],2,[1,1]]"
19 | let nestedList = NestedInteger.deserialize(data)
20 |
21 | let result = NestedListWeightSum().depthSum([nestedList])
22 |
23 | XCTAssertEqual(result, 10)
24 | }
25 |
26 | func test_B() {
27 | let data = "[1,[4,[6]]]"
28 | let nestedList = NestedInteger.deserialize(data)
29 |
30 | let result = NestedListWeightSum().depthSum([nestedList])
31 |
32 | XCTAssertEqual(result, 27)
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NextGreaterElementIITests.swift:
--------------------------------------------------------------------------------
1 | // Created 01/06/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct AANextGreaterElementIITests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let nums = [1,2,1]
14 |
15 | let result = NextGreaterElementII().nextGreaterElements(nums)
16 |
17 | #expect(result == [2,-1,2])
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let nums = [1,2,3,4,3]
23 |
24 | let result = NextGreaterElementII().nextGreaterElements(nums)
25 |
26 | #expect(result == [2,3,4,-1,4])
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NextGreaterElementITests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // NextGreaterElementITests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 14/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class NextGreaterElementITests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let nums1 = [4, 1, 2]
19 | let nums2 = [1, 3, 4, 2]
20 |
21 | let result = NextGreaterElementI().nextGreaterElement(nums1, nums2)
22 |
23 | XCTAssertEqual(result, [-1, 3, -1])
24 | }
25 |
26 | func test_B() {
27 | let nums1 = [2, 4]
28 | let nums2 = [1, 2, 3, 4]
29 |
30 | let result = NextGreaterElementI().nextGreaterElement(nums1, nums2)
31 |
32 | XCTAssertEqual(result, [3, -1])
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NextGreaterNodeInLinkedListTests.swift:
--------------------------------------------------------------------------------
1 | // Created 08/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct NextGreaterNodeInLinkedListTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let data = [2,1,5]
14 | let head = ListNode.deserialize(data)
15 |
16 | let result = NextGreaterNodeInLinkedList().nextLargerNodes(head)
17 |
18 | #expect(result == [5,5,0])
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let data = [2,7,4,3,5]
24 | let head = ListNode.deserialize(data)
25 |
26 | let result = NextGreaterNodeInLinkedList().nextLargerNodes(head)
27 |
28 | #expect(result == [7,0,5,5,0])
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NumberOfArithmeticTripletsTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // NumberOfArithmeticTripletsTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 06/03/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class NumberOfArithmeticTripletsTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [0,1,4,6,7,10]
18 | let diff = 3
19 |
20 | let result = NumberOfArithmeticTriplets().arithmeticTriplets(nums, diff)
21 |
22 | XCTAssertEqual(result, 2)
23 | }
24 |
25 | func test_B() {
26 | let nums = [4,5,6,7,8,9]
27 | let diff = 2
28 |
29 | let result = NumberOfArithmeticTriplets().arithmeticTriplets(nums, diff)
30 |
31 | XCTAssertEqual(result, 2)
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NumberOfDistinctAveragesTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // NumberOfDistinctAveragesTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 30/08/2024.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class NumberOfDistinctAveragesTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [4,1,4,0,3,5]
18 |
19 | let result = NumberOfDistinctAverages().distinctAverages(nums)
20 |
21 | XCTAssertEqual(result, 2)
22 | }
23 |
24 | func test_B() {
25 | let nums = [1,100]
26 |
27 | let result = NumberOfDistinctAverages().distinctAverages(nums)
28 |
29 | XCTAssertEqual(result, 1)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NumberOfEnclavesTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // NumberOfEnclavesTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 02/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class NumberOfEnclavesTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let grid = [[0,0,0,0],
18 | [1,0,1,0],
19 | [0,1,1,0],
20 | [0,0,0,0]]
21 |
22 | let result = NumberOfEnclaves().numEnclaves(grid)
23 |
24 | XCTAssertEqual(result, 3)
25 | }
26 |
27 | func test_B() {
28 | let grid = [[0,1,1,0],
29 | [0,0,1,0],
30 | [0,0,1,0],
31 | [0,0,0,0]]
32 |
33 | let result = NumberOfEnclaves().numEnclaves(grid)
34 |
35 | XCTAssertEqual(result, 0)
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NumberOfEquivalentDominoPairsTests.swift:
--------------------------------------------------------------------------------
1 | // Created 04/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct NumberOfEquivalentDominoPairsTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let dominoes = [[1,2],[2,1],[3,4],[5,6]]
14 |
15 | let result = NumberOfEquivalentDominoPairs().numEquivDominoPairs(dominoes)
16 |
17 | #expect(result == 1)
18 | }
19 |
20 | @Test
21 | func test_B() {
22 | let dominoes = [[1,2],[1,2],[1,1],[1,2],[2,2]]
23 |
24 | let result = NumberOfEquivalentDominoPairs().numEquivDominoPairs(dominoes)
25 |
26 | #expect(result == 3)
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NumberOfNodesWithValueOneTests.swift:
--------------------------------------------------------------------------------
1 | // Created 07/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct NumberOfNodesWithValueOneTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let n = 5
14 | let queries = [1,2,5]
15 |
16 | let result = NumberOfNodesWithValueOne().numberOfNodes(n, queries)
17 |
18 | #expect(result == 3)
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let n = 3
24 | let queries = [2,3,3]
25 |
26 | let result = NumberOfNodesWithValueOne().numberOfNodes(n, queries)
27 |
28 | #expect(result == 1)
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/NumberOfStudentsUnableToEatLunchTests.swift:
--------------------------------------------------------------------------------
1 | // Created 12/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct NumberOfStudentsUnableToEatLunchTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let students = [1,1,0,0]
14 | let sandwiches = [0,1,0,1]
15 |
16 | let result = NumberOfStudentsUnableToEatLunch().countStudents(students, sandwiches)
17 |
18 | #expect(result == 0)
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let students = [1,1,1,0,0,1]
24 | let sandwiches = [1,0,0,0,1,1]
25 |
26 | let result = NumberOfStudentsUnableToEatLunch().countStudents(students, sandwiches)
27 |
28 | #expect(result == 3)
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/OptimalPartitionOfStringTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // OptimalPartitionOfStringTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 16/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class OptimalPartitionOfStringTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let s = "abacaba"
18 |
19 | let result = OptimalPartitionOfString().partitionString(s)
20 |
21 | XCTAssertEqual(result, 4)
22 | }
23 |
24 | func test_B() {
25 | let s = "ssssss"
26 |
27 | let result = OptimalPartitionOfString().partitionString(s)
28 |
29 | XCTAssertEqual(result, 6)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PairsOfSongsWithTotalDurationsDivisibleBy60Tests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PairsOfSongsWithTotalDurationsDivisibleBy60Tests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 22/01/2022.
6 | // Copyright © 2022 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class PairsOfSongsWithTotalDurationsDivisibleBy60Tests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let time = [30, 20, 150, 100, 40]
19 |
20 | let result = PairsOfSongsWithTotalDurationsDivisibleBy60().numPairsDivisibleBy60(time)
21 |
22 | XCTAssertEqual(result, 3)
23 | }
24 |
25 | func test_B() {
26 | let time = [60, 60, 60]
27 |
28 | let result = PairsOfSongsWithTotalDurationsDivisibleBy60().numPairsDivisibleBy60(time)
29 |
30 | XCTAssertEqual(result, 3)
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PalindromePartitioningTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PalindromePartitioningTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 02/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class PalindromePartitioningTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let s = "aab"
18 |
19 | let result = PalindromePartitioning().partition(s)
20 |
21 | XCTAssertEqual(result, [["a", "a", "b"],["aa", "b"]])
22 | }
23 |
24 | func test_B() {
25 | let s = "a"
26 |
27 | let result = PalindromePartitioning().partition(s)
28 |
29 | XCTAssertEqual(result, [["a"]])
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PartitionLabelsTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PartitionLabelsTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 05/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class PartitionLabelsTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let s = "ababcbacadefegdehijhklij"
18 |
19 | let result = PartitionLabels().partitionLabels(s)
20 |
21 | XCTAssertEqual(result, [9, 7, 8])
22 | }
23 |
24 | func test_B() {
25 | let s = "eccbbbbdec"
26 |
27 | let result = PartitionLabels().partitionLabels(s)
28 |
29 | XCTAssertEqual(result, [10])
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PascalsTriangleIITests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PascalsTriangleIITests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 20/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class PascalsTriangleIITests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let rowIndex = 3
19 |
20 | let result = PascalsTriangleII().getRow(rowIndex)
21 |
22 | XCTAssertEqual(result, [1, 3, 3, 1])
23 | }
24 |
25 | func test_B() {
26 | let rowIndex = 0
27 |
28 | let result = PascalsTriangleII().getRow(rowIndex)
29 |
30 | XCTAssertEqual(result, [1])
31 | }
32 |
33 | func test_C() {
34 | let rowIndex = 1
35 |
36 | let result = PascalsTriangleII().getRow(rowIndex)
37 |
38 | XCTAssertEqual(result, [1, 1])
39 | }
40 |
41 | }
42 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PascalsTriangleTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PascalsTriangleTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 07/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class PascalsTriangleTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let numRows = 5
18 |
19 | let result = PascalsTriangle().generate(numRows)
20 |
21 | XCTAssertEqual(result, [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]])
22 | }
23 |
24 | func test_B() {
25 | let numRows = 1
26 | let result = PascalsTriangle().generate(numRows)
27 |
28 | XCTAssertEqual(result, [[1]])
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PathSumIVTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PathSumIVTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 22/11/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class PathSumIVTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [113,215,221]
18 |
19 | let result = PathSumIV().pathSum(nums)
20 |
21 | XCTAssertEqual(result, 12)
22 | }
23 |
24 | func test_B() {
25 | let nums = [113,221]
26 |
27 | let result = PathSumIV().pathSum(nums)
28 |
29 | XCTAssertEqual(result, 4)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PerfectSquaresTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PerfectSquaresTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 13/12/2021.
6 | // Copyright © 2021 Boles. All rights reserved.
7 | //
8 |
9 | import XCTest
10 |
11 | @testable import LeetCode
12 |
13 | final class PerfectSquaresTests: XCTestCase {
14 |
15 | // MARK: - Tests
16 |
17 | func test_A() {
18 | let n = 12
19 |
20 | let result = PerfectSquares().numSquares(n)
21 |
22 | XCTAssertEqual(result, 3)
23 | }
24 |
25 | func test_B() {
26 | let n = 13
27 |
28 | let result = PerfectSquares().numSquares(n)
29 |
30 | XCTAssertEqual(result, 2)
31 | }
32 |
33 | func test_C() {
34 | let n = 7168
35 |
36 | let result = PerfectSquares().numSquares(n)
37 |
38 | XCTAssertEqual(result, 4)
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PlusOneTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PlusOneTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 16/03/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class PlusOneTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let digits = [1, 2, 3]
18 |
19 | let result = PlusOne().plusOne(digits)
20 |
21 | XCTAssertEqual(result, [1, 2, 4])
22 | }
23 |
24 | func test_B() {
25 | let digits = [4, 3, 2, 1]
26 |
27 | let result = PlusOne().plusOne(digits)
28 |
29 | XCTAssertEqual(result, [4, 3, 2, 2])
30 | }
31 |
32 | func test_C() {
33 | let digits = [9]
34 |
35 | let result = PlusOne().plusOne(digits)
36 |
37 | XCTAssertEqual(result, [1, 0])
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PowerOfThreeTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PowerOfThreeTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 06/04/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class PowerOfThreeTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let n = 27
18 |
19 | let result = PowerOfThree().isPowerOfThree(n)
20 |
21 | XCTAssertTrue(result)
22 | }
23 |
24 | func test_B() {
25 | let n = -1
26 |
27 | let result = PowerOfThree().isPowerOfThree(n)
28 |
29 | XCTAssertFalse(result)
30 | }
31 |
32 | func test_C() {
33 | let n = 0
34 |
35 | let result = PowerOfThree().isPowerOfThree(n)
36 |
37 | XCTAssertFalse(result)
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/ProductOfArrayExceptSelfTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ProductOfArrayExceptSelfTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 31/03/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class ProductOfArrayExceptSelfTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let nums = [1, 2, 3, 4]
18 |
19 | let result = ProductOfArrayExceptSelf().productExceptSelf(nums)
20 |
21 | XCTAssertEqual(result, [24, 12, 8, 6])
22 | }
23 |
24 | func test_B() {
25 | let nums = [-1, 1, 0, -3, 3]
26 |
27 | let result = ProductOfArrayExceptSelf().productExceptSelf(nums)
28 |
29 | XCTAssertEqual(result, [0, 0, 9, 0, 0])
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/PushDominoesTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PushDominoesTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 14/07/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class PushDominoesTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let dominoes = "RR.L"
18 |
19 | let result = PushDominoes().pushDominoes(dominoes)
20 |
21 | XCTAssertEqual(result, "RR.L")
22 | }
23 |
24 | func test_B() {
25 | let dominoes = ".L.R...LR..L.."
26 |
27 | let result = PushDominoes().pushDominoes(dominoes)
28 |
29 | XCTAssertEqual(result, "LL.RR.LLRRLL..")
30 | }
31 |
32 | func test_C() {
33 | let dominoes = "."
34 |
35 | let result = PushDominoes().pushDominoes(dominoes)
36 |
37 | XCTAssertEqual(result, ".")
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/RandomizedSetTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // RandomizedSetTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 28/03/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class RandomizedSetTests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | let set = RandomizedSet()
18 |
19 | XCTAssertTrue(set.insert(0))
20 | XCTAssertTrue(set.insert(1))
21 | XCTAssertTrue(set.remove(0))
22 | XCTAssertFalse(set.remove(0))
23 | XCTAssertTrue(set.insert(2))
24 | XCTAssertFalse(set.insert(1))
25 | XCTAssertTrue(set.remove(1))
26 | XCTAssertEqual(set.getRandom(), 2)
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/RansomNoteTests.swift:
--------------------------------------------------------------------------------
1 | // Created 03/05/2025.
2 |
3 | import Testing
4 |
5 | @testable import LeetCode
6 |
7 | struct RansomNoteTests {
8 |
9 | // MARK: - Tests
10 |
11 | @Test
12 | func test_A() {
13 | let ransomNote = "a"
14 | let magazine = "b"
15 |
16 | let result = RansomNote().canConstruct(ransomNote, magazine)
17 |
18 | #expect(result == false)
19 | }
20 |
21 | @Test
22 | func test_B() {
23 | let ransomNote = "aa"
24 | let magazine = "ab"
25 |
26 | let result = RansomNote().canConstruct(ransomNote, magazine)
27 |
28 | #expect(result == false)
29 | }
30 |
31 | @Test
32 | func test_C() {
33 | let ransomNote = "aa"
34 | let magazine = "aab"
35 |
36 | let result = RansomNote().canConstruct(ransomNote, magazine)
37 |
38 | #expect(result == true)
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/RedundantConnectionTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // RedundantConnectionTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 11/05/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class RedundantConnectionTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let edges = [[1, 2], [1, 3], [2, 3]]
18 |
19 | let result = RedundantConnection().findRedundantConnection(edges)
20 |
21 | XCTAssertEqual(result, [2, 3])
22 | }
23 |
24 | func test_B() {
25 | let edges = [[1, 2], [2, 3], [3, 4], [1, 4], [1, 5]]
26 |
27 | let result = RedundantConnection().findRedundantConnection(edges)
28 |
29 | XCTAssertEqual(result, [1, 4])
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/RemoveDuplicateLettersTests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // RemoveDuplicateLettersTests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 06/04/2023.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class RemoveDuplicateLettersTests: XCTestCase {
13 |
14 | //MARK: - Tests
15 |
16 | func test_A() {
17 | let s = "bcabc"
18 |
19 | let result = RemoveDuplicateLetters().removeDuplicateLetters(s)
20 |
21 | XCTAssertEqual(result, "abc")
22 | }
23 |
24 | func test_B() {
25 | let s = "cbacdcbc"
26 |
27 | let result = RemoveDuplicateLetters().removeDuplicateLetters(s)
28 |
29 | XCTAssertEqual(result, "acdb")
30 | }
31 |
32 | func test_C() {
33 | let s = "dedabc"
34 |
35 | let result = RemoveDuplicateLetters().removeDuplicateLetters(s)
36 |
37 | XCTAssertEqual(result, "deabc")
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/LeetCode/LeetCodeTests/Tests/RemoveDuplicatesFromSortedArrayIITests.swift:
--------------------------------------------------------------------------------
1 | //
2 | // RemoveDuplicatesFromSortedArrayIITests.swift
3 | // LeetCodeTests
4 | //
5 | // Created by William Boles on 18/03/2022.
6 | //
7 |
8 | import XCTest
9 |
10 | @testable import LeetCode
11 |
12 | final class RemoveDuplicatesFromSortedArrayIITests: XCTestCase {
13 |
14 | // MARK: - Tests
15 |
16 | func test_A() {
17 | var nums = [1, 1, 1, 2, 2, 3]
18 |
19 | let result = RemoveDuplicatesFromSortedArrayII().removeDuplicates(&nums)
20 |
21 | XCTAssertEqual(result, 5)
22 | XCTAssertEqual(Array(nums[0..