├── .gitignore ├── Chapter06 ├── .gitignore ├── Abstraction │ ├── AbstractionViaAbstractClass │ │ ├── pom.xml │ │ └── src │ │ │ └── main │ │ │ └── java │ │ │ └── coding │ │ │ └── challenge │ │ │ ├── Car.java │ │ │ ├── ElectricCar.java │ │ │ ├── Main.java │ │ │ └── PetrolCar.java │ └── AbstractionViaInterface │ │ ├── pom.xml │ │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Car.java │ │ ├── ElectricCar.java │ │ ├── Main.java │ │ └── PetrolCar.java ├── Aggregation │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── Racket.java │ │ └── TennisPlayer.java ├── Association │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Address.java │ │ ├── Main.java │ │ └── Person.java ├── CircularByteBuffer │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── CircularByteBuffer.java │ │ └── Main.java ├── Composition │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Car.java │ │ ├── Engine.java │ │ └── Main.java ├── CovariantMethodOverriding │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Rectangle.java ├── DeckOfCards │ ├── DeckOfCardsUML.png │ ├── README.md │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── card │ │ ├── Card.java │ │ ├── Pack.java │ │ ├── StandardCard.java │ │ ├── StandardPack.java │ │ └── StandardSuit.java │ │ └── deck │ │ └── Deck.java ├── DependencyInversionPrinciple │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── bad │ │ ├── ConnectToDatabase.java │ │ └── PostgreSQLJdbcUrl.java │ │ └── good │ │ ├── ConnectToDatabase.java │ │ ├── JdbcUrl.java │ │ ├── MySQLJdbcUrl.java │ │ └── PostgreSQLJdbcUrl.java ├── Encapsulation │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Cat.java │ │ └── Main.java ├── FileSystem │ ├── FileSystemUML.png │ ├── README.md │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── filesystem │ │ ├── Directory.java │ │ ├── File.java │ │ └── Item.java ├── HashTable │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── HashTable.java │ │ └── Main.java ├── Inheritance │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Employee.java │ │ ├── Main.java │ │ └── Programmer.java ├── InterfaceSegregationPrinciple │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── bad │ │ ├── Connection.java │ │ └── WwwPingConnection.java │ │ └── good │ │ ├── Connection.java │ │ ├── HttpConnection.java │ │ ├── SocketConnection.java │ │ └── WwwPingConnection.java ├── Java8DefaultStaticMethods │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── ElectricCar.java │ │ ├── Main.java │ │ ├── PetrolCar.java │ │ ├── SteamCar.java │ │ └── Vehicle.java ├── Jukebox │ ├── JukeboxUML.png │ ├── README.md │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── jukebox │ │ ├── CD.java │ │ ├── CDPlayer.java │ │ ├── Jukebox.java │ │ ├── Playlist.java │ │ ├── Selector.java │ │ └── Song.java │ │ └── user │ │ └── User.java ├── LiskovSubstitutionPrinciple │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── bad │ │ ├── FreeMember.java │ │ ├── Member.java │ │ ├── PremiumMember.java │ │ └── VipMember.java │ │ └── good │ │ ├── FreeMember.java │ │ ├── Member.java │ │ ├── PremiumMember.java │ │ ├── TournamentJoiner.java │ │ ├── TournamentOrganizer.java │ │ └── VipMember.java ├── MethodHiding │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Car.java │ │ ├── Main.java │ │ └── Vehicle.java ├── MethodOverloding │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Foo.java │ │ └── Main.java ├── MethodOverriding │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── inheritance │ │ ├── Child.java │ │ └── Parent.java │ │ └── polymorphism │ │ ├── Base.java │ │ └── Concrete.java ├── MovieTicketBooking │ ├── MovieTicketBookingUML.png │ ├── README.md │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── cinema │ │ ├── Cinema.java │ │ ├── CinemaRoom.java │ │ ├── Movie.java │ │ ├── MovieTicket.java │ │ ├── Seat.java │ │ └── SeatType.java │ │ └── ticketing │ │ ├── MovieTicketing.java │ │ └── MovieTicketingMachine.java ├── OnlineReaderSystem │ ├── OnlineReaderSystemUML.png │ ├── README.md │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── reader │ │ ├── Book.java │ │ ├── Displayer.java │ │ ├── Library.java │ │ ├── OnlineReaderSystem.java │ │ ├── Reader.java │ │ └── ReaderManager.java ├── OpenClosedPrinciple │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── bad │ │ ├── AreaCalculator.java │ │ ├── Circle.java │ │ ├── Rectangle.java │ │ └── Shape.java │ │ └── good │ │ ├── AreaCalculator.java │ │ ├── Circle.java │ │ ├── Rectangle.java │ │ └── Shape.java ├── OverloadingException │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Clazz.java │ │ └── Main.java ├── OverridingException │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Child.java │ │ ├── Main.java │ │ └── Parent.java ├── ParkingLot │ ├── ParkingLotUML.png │ ├── README.md │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── parking │ │ ├── ParkingFloor.java │ │ ├── ParkingLot.java │ │ ├── ParkingSpot.java │ │ ├── ParkingTicket.java │ │ ├── Vehicle.java │ │ ├── VehicleType.java │ │ └── system │ │ ├── Parking.java │ │ └── ParkingSystem.java ├── Polymorphism │ ├── CompileTime │ │ ├── pom.xml │ │ └── src │ │ │ └── main │ │ │ └── java │ │ │ └── coding │ │ │ └── challenge │ │ │ ├── Main.java │ │ │ └── Triangle.java │ └── Runtime │ │ ├── pom.xml │ │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Circle.java │ │ ├── Main.java │ │ ├── Rectangle.java │ │ ├── Shape.java │ │ └── Triangle.java ├── README.md ├── SingleResponsibilityPrinciple │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── bad │ │ └── RectangleAreaCalculator.java │ │ └── good │ │ ├── AreaConverter.java │ │ └── RectangleAreaCalculator.java ├── Tuple │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Pair.java └── VendingMachine │ ├── README.md │ ├── VendingMachineUML.png │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── Main.java │ └── vending │ └── machine │ ├── Coin.java │ ├── Inventory.java │ ├── Item.java │ ├── Selector.java │ └── VendingMachine.java ├── Chapter08 ├── .gitignore ├── Braces │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Braces.java │ │ └── Main.java ├── Coins │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Coins.java │ │ └── Main.java ├── ColorSpots │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BiggestColorSpot.java │ │ └── Main.java ├── FiveTowers │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── FiveTower.java │ │ └── Main.java ├── HanoiTowers │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Hanoi.java │ │ └── Main.java ├── HighestColoredTower │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Box.java │ │ ├── Main.java │ │ └── Tower.java ├── Josephus │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Josephus.java │ │ └── Main.java ├── KnightTour │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── KnightTour.java │ │ └── Main.java ├── MagicIndex │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── MagicIndex.java │ │ └── Main.java ├── Permutations │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── DuplicatePermutation.java │ │ ├── Main.java │ │ ├── NoDuplicatePermutation.java │ │ └── SimplePermutation.java ├── README.md ├── RobotGridAllPaths │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── RobotGrid.java ├── RobotGridMaze │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── RobotGrid.java ├── Staircase │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Staircase.java ├── SubsetSum │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Subsets.java ├── TheFallingBall │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── FallingBall.java │ │ └── Main.java └── WordBreak │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── Main.java │ ├── Trie.java │ └── Words.java ├── Chapter09 ├── .gitignore ├── CheckEquality │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── ClearBits │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── ComputeModuloDivision │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── Conversion │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── DividingBinaries │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── FindDuplicates │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── FloatToBinaryAndBack │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── GetBitValue │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── LongestSequence │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── MultiplyingBinaries │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── NextNumber │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── NumberWithOneInLR │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── OddEven │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── OnceTwiceThrice │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Elements.java │ │ └── Main.java ├── PositionOfFirstBitOfOne │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── PowerSetOfSet │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Sets.java ├── README.md ├── ReplaceBits │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── RotateBits │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── SetBitValue │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── SubtractingBinaries │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── SummingBinaries │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── SwapOddEven │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java ├── SwapTwoIntegers │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bits.java │ │ └── Main.java └── TwoNonRepeating │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── Bits.java │ └── Main.java ├── Chapter10 ├── .gitignore ├── BestTimeToBuySellStock │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Stocks.java ├── ContainerMostWater │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Containers.java │ │ └── Main.java ├── CountDistinctAbsoluteSortedArray │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── CountDistinctInSubarray │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── CountScore3510 │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Scores.java ├── DuplicatesInArray │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── EncodedString │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Strings.java ├── ExtractIntegers │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Strings.java ├── ExtractSurrogatePairs │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Strings.java ├── FindPairsSumEqualK │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── LongestConsecutiveSequence │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Sequences.java ├── LongestDistinctSubstring │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Strings.java ├── MatrixWithZeros │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── MaxMatrixOfOne │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Matrices.java ├── MaximumInCircularArray │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── MedianOfSortedArrays │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── MergeIntervals │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ ├── Interval.java │ │ └── Main.java ├── MergeKSortedArr │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── MergeArrays.java │ │ └── MinHeap.java ├── MinimumInCircularArray │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── OneEditAway │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Strings.java ├── PetrolBunks │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bunks.java │ │ └── Main.java ├── README.md ├── ReplaceElementWithRank │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── RotateArrayKTimes │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── RotateMatrix │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── RotateString │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Strings.java ├── SearchInCircularArray │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── StringShrinker │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Strings.java ├── ThreeStacksInOneArray │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── StackNode.java │ │ ├── ThreeStack.java │ │ └── exception │ │ ├── OverflowException.java │ │ └── UnderflowException.java ├── ThreeStacksInOneArrayFixed │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── ThreeStack.java │ │ └── exception │ │ ├── OverflowException.java │ │ └── UnderflowException.java ├── TrapRainWater │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Bars.java │ │ └── Main.java ├── UniqueCharacters │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Strings.java └── UniqueCharactersAZ │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── Main.java │ └── Strings.java ├── Chapter11 ├── .gitignore ├── DoublyLinkedList │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── DoublyLinkedList.java │ │ └── Main.java ├── DoublyLinkedListOneHead │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── DoublyLinkedList.java │ │ └── Main.java ├── DoublyLinkedListReverse │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── DoublyLinkedList.java │ │ └── Main.java ├── LRUCache │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── LRUCache.java │ │ └── Main.java ├── LinkedListLoopDetection │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListMergeNSortedRecursion │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListMergeTwoSorted │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListMergeTwoSortedRecursion │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListMoveLastToFront │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListNthToLastNode │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListPairwiseSwap │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListPalindrome │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListRearranging │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListRemoveDuplicates │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListRemoveRedundantPath │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListSum │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── LinkedListsIntersection │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── Map │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MyMap.java ├── NutsAndBolts │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── NutsBolts.java ├── README.md ├── ReverseLinkedListInGroups │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── SinglyLinkedList │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java └── SinglyLinkedListOneHead │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── Main.java │ └── SinglyLinkedList.java ├── Chapter12 ├── .gitignore ├── MinStackConstantTime │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MyStack.java ├── MinStackConstantTimeAndSpace │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MyStack.java ├── MyQueue │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MyQueue.java ├── MyStack │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MyStack.java ├── QueueIslands │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Queues.java ├── QueueViaStack │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MyQueueViaStack.java ├── README.md ├── ShortestSafeRoute │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Sensors.java ├── SmallestNumber │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Numbers.java ├── StackBraces │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── StackBraces.java ├── StackHistogramArea │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Stacks.java ├── StackOfPlates │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MyStack.java ├── StackReverseString │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Stacks.java ├── StackViaQueue │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MyStackViaQueue.java └── StockSpan │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── Main.java │ └── StockSpan.java ├── Chapter13 ├── .gitignore ├── AVLTreeImpl │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── AVLTree.java │ │ └── Main.java ├── BinarySearchTreeDuplicates │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinarySearchTree.java │ │ └── Main.java ├── BinarySearchTreeKthLargestElement │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinarySearchTree.java │ │ └── Main.java ├── BinarySearchTreeSuccessor │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinarySearchTree.java │ │ └── Main.java ├── BinarySearchTreeSum │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinarySearchTree.java │ │ └── Main.java ├── BinarySearchTreeTraversal │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinarySearchTree.java │ │ └── Main.java ├── BinaryTreeBalanced │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreeCommonAncestor │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreeDistanceFromLeaf │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreeIsBST │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreeLandingReservation │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinarySearchTree.java │ │ └── Main.java ├── BinaryTreeMaxPathSum │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreePrintCorners │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreePrintDiagonal │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreeRightView │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreeSpiralTraversal │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreeSubtree │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreeTraversal │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── BinaryTreeVerticalSum │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── ChessKnight │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── ChessKnight.java │ │ └── Main.java ├── DirectedGraphPath │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Graph.java │ │ └── Main.java ├── GraphAdjacencyListTraversal │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Graph.java │ │ └── Main.java ├── GraphAdjacencyMatrixTraversal │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Graph.java │ │ └── Main.java ├── GraphTopologicalSort │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Graph.java │ │ └── Main.java ├── HeapConnectRopes │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MinHeap.java ├── IsSymmetricBinaryTree │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── ListPerBinaryTreeLevel │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── MaxHeap │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MaxHeap.java ├── MaxHeapToMinHeap │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Heaps.java │ │ └── Main.java ├── MirrorBinaryTree │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinaryTree.java │ │ └── Main.java ├── README.md ├── RedBlackTreeImpl │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── RedBlackTree.java ├── SortedArrayToMinBinarySearchTree │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinarySearchTree.java │ │ └── Main.java └── TwoBinaryTreesAreIsomorphic │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── BinaryTree.java │ └── Main.java ├── Chapter14 ├── .gitignore ├── BinarySearch │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BinarySearch.java │ │ └── Main.java ├── BucketSort │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── BucketSort.java │ │ └── Main.java ├── FindNearestMinimum │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Finds.java │ │ └── Main.java ├── GroupSortAnagrams │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Anagrams.java │ │ └── Main.java ├── HeapSort │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── HeapSort.java │ │ ├── Main.java │ │ └── Melon.java ├── InterspersedEmptyStrings │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Strings.java ├── MaxDiffBetweenTwoElements │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── MergeSort │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── MergeSort.java ├── MergeSortDoublyLinkedList │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── DoublyLinkedList.java │ │ └── Main.java ├── MergeSortSinglyLinkedList │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SinglyLinkedList.java ├── MergeTwoSortedArrays │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── SortArrays.java ├── PeaksAndValleys │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── PeaksValleys.java ├── PositionOfFirstOne │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Arrays.java │ │ └── Main.java ├── QuickSort │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── Melon.java │ │ └── QuickSort.java ├── README.md ├── RadixSort │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── RadixSort.java ├── RankInStream │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Stream.java ├── SearchInFullSortedMatrix │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Matrices.java ├── SearchInSortedMatrix │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Matrices.java ├── SortArrayBasedOnAnotherArray │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Sorts.java ├── SortArraysIn14Ways │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── ArraySorts.java │ │ ├── Main.java │ │ └── Melon.java ├── SortQueueViaTempQueue │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Queues.java ├── SortQueueWithoutExtraSpace │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Queues.java ├── SortStack │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Stacks.java ├── SortStackInPlace │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Stacks.java ├── UnknownSizeList │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── SizelessList.java │ │ └── UnknownSizeList.java └── WordSearch │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── Main.java │ └── Words.java ├── Chapter15 ├── .gitignore ├── Abcd │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Abcd.java │ │ └── Main.java ├── BreakChocolate │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Chocolates.java │ │ └── Main.java ├── DecodingDigitSequence │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Digits.java │ │ └── Main.java ├── FizzBuzz │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── FizzBuzz.java │ │ └── Main.java ├── HourMinuteAngle │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Clock.java │ │ └── Main.java ├── KthNumber357 │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Numbers.java ├── MultiplyLargeNumbers │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Numbers.java ├── NextElementSameDigits │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Numbers.java ├── NumberDivisibleDigits │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Numbers.java ├── PythagoreanTriplets │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Pythagoreans.java ├── README.md ├── RectangleOverlap │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── Rectangles.java ├── RomanNumbers │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── RomanNumbers.java ├── ScheduleOneElevator │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Elevators.java │ │ └── Main.java └── VisitToggle100Doors │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── Doors.java │ └── Main.java ├── Chapter16 ├── .gitignore ├── CancelThread │ ├── nbactions.xml │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── RandomList.java ├── Deadlock │ ├── nbactions.xml │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ └── Main.java ├── ExecutorAndExecutorService │ ├── nbactions.xml │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ ├── SimpleExecutor.java │ │ └── SimpleThreadPoolExecutor.java ├── ProducerConsumerQueue │ ├── nbactions.xml │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── ProducerConsumer.java ├── ProducerConsumerWaitNotify │ ├── nbactions.xml │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── Main.java │ │ └── ProducerConsumer.java ├── README.md ├── RunnableAndCallable │ ├── nbactions.xml │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── ExecuteTask.java │ │ └── Main.java └── ThreadLifecycleState │ ├── nbactions.xml │ ├── pom.xml │ └── src │ └── main │ └── java │ └── coding │ └── challenge │ ├── BlockedThread.java │ ├── Main.java │ ├── NewThread.java │ ├── RunnableThread.java │ ├── TerminatedThread.java │ ├── TimedWaitingThread.java │ └── WaitingThread.java ├── Chapter18 ├── .gitignore ├── README.md ├── junit4 │ ├── Assumptions │ │ ├── pom.xml │ │ └── src │ │ │ └── test │ │ │ └── java │ │ │ └── coding │ │ │ └── challenge │ │ │ └── test │ │ │ └── AssumptionsTest.java │ ├── BeforeAfterAnnotations │ │ ├── pom.xml │ │ └── src │ │ │ └── test │ │ │ └── java │ │ │ └── coding │ │ │ └── challenge │ │ │ └── test │ │ │ └── BeforeAfterTest.java │ ├── README.md │ ├── TestSuite │ │ ├── pom.xml │ │ └── src │ │ │ └── test │ │ │ └── java │ │ │ └── coding │ │ │ └── challenge │ │ │ └── test │ │ │ ├── TestConnect.java │ │ │ ├── TestDisconnect.java │ │ │ ├── TestHeartbeat.java │ │ │ └── TestSuite.java │ └── TestingExceptions │ │ ├── pom.xml │ │ └── src │ │ └── test │ │ └── java │ │ └── coding │ │ └── challenge │ │ └── test │ │ └── ExceptionTest.java └── junit5 │ ├── ArrangeActAssert │ ├── pom.xml │ └── src │ │ └── test │ │ └── java │ │ └── coding │ │ └── challenge │ │ └── test │ │ └── AAATest.java │ ├── Assumptions │ ├── pom.xml │ └── src │ │ └── test │ │ └── java │ │ └── coding │ │ └── challenge │ │ └── test │ │ └── AssumptionsTest.java │ ├── BeforeAfterAnnotations │ ├── pom.xml │ └── src │ │ └── test │ │ └── java │ │ └── coding │ │ └── challenge │ │ └── test │ │ └── BeforeAfterTest.java │ ├── NestedTests │ ├── pom.xml │ └── src │ │ └── test │ │ └── java │ │ └── coding │ │ └── challenge │ │ └── test │ │ └── NestedTest.java │ ├── README.md │ ├── TestFactory │ ├── pom.xml │ └── src │ │ └── test │ │ └── java │ │ └── coding │ │ └── challenge │ │ └── test │ │ └── ExampleOfDynamicTest.java │ ├── TestSuite │ ├── pom.xml │ └── src │ │ └── test │ │ └── java │ │ └── coding │ │ └── challenge │ │ ├── connection │ │ └── test │ │ │ ├── TestConnect.java │ │ │ ├── TestConnectionSuite.java │ │ │ ├── TestDisconnect.java │ │ │ └── TestHeartbeat.java │ │ └── login │ │ └── test │ │ ├── TestLogin.java │ │ ├── TestLoginSuite.java │ │ └── TestLogout.java │ └── TestingExceptions │ ├── pom.xml │ └── src │ └── test │ └── java │ └── coding │ └── challenge │ └── test │ └── ExceptionTest.java ├── LICENSE └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | /Chapter06/Abstraction/AbstractionViaInterface/target/ 2 | -------------------------------------------------------------------------------- /Chapter06/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | -------------------------------------------------------------------------------- /Chapter06/Abstraction/AbstractionViaAbstractClass/src/main/java/coding/challenge/Car.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | abstract class Car { 4 | 5 | private final String carType; 6 | 7 | // abstract class can have constructor 8 | public Car(String carType) { 9 | this.carType = carType; 10 | } 11 | 12 | // these are abstract methods 13 | abstract void speedUp(); 14 | abstract void slowDown(); 15 | abstract void turnRight(); 16 | abstract void turnLeft(); 17 | 18 | // this is a concrete method 19 | public String getCarType() { 20 | return carType; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Chapter06/Abstraction/AbstractionViaAbstractClass/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Car electricCar = new ElectricCar("BMW"); 8 | Car petrolCar = new PetrolCar("Audi"); 9 | 10 | System.out.println("Driving the electric car: " + electricCar.getCarType() + "\n"); 11 | electricCar.speedUp(); 12 | electricCar.turnLeft(); 13 | electricCar.slowDown(); 14 | 15 | System.out.println("\n\nDriving the petrol car: " + petrolCar.getCarType() + "\n"); 16 | petrolCar.slowDown(); 17 | petrolCar.turnRight(); 18 | petrolCar.turnLeft(); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Chapter06/Abstraction/AbstractionViaInterface/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | AbstractionViaInterface 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | -------------------------------------------------------------------------------- /Chapter06/Abstraction/AbstractionViaInterface/src/main/java/coding/challenge/Car.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public interface Car { 4 | 5 | public void speedUp(); 6 | 7 | public void slowDown(); 8 | 9 | public void turnRight(); 10 | 11 | public void turnLeft(); 12 | 13 | public String getCarType(); 14 | } 15 | -------------------------------------------------------------------------------- /Chapter06/Abstraction/AbstractionViaInterface/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Car electricCar = new ElectricCar("BMW"); 8 | Car petrolCar = new PetrolCar("Audi"); 9 | 10 | System.out.println("Driving the electric car: " + electricCar.getCarType() + "\n"); 11 | electricCar.speedUp(); 12 | electricCar.turnLeft(); 13 | electricCar.slowDown(); 14 | 15 | System.out.println("\n\nDriving the petrol car: " + petrolCar.getCarType() + "\n"); 16 | petrolCar.slowDown(); 17 | petrolCar.turnRight(); 18 | petrolCar.turnLeft(); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Chapter06/Aggregation/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Aggregation 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Aggregation 14 | -------------------------------------------------------------------------------- /Chapter06/Aggregation/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Racket racket = new Racket("Babolat Pure Aero", 100, 300); 8 | TennisPlayer player = new TennisPlayer("Rafael Nadal", racket); 9 | 10 | System.out.println("Player " + player.getName() 11 | + " plays with " + player.getRacket().getType()); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Chapter06/Aggregation/src/main/java/coding/challenge/TennisPlayer.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class TennisPlayer { 4 | 5 | private String name; 6 | private Racket racket; 7 | 8 | public TennisPlayer(String name, Racket racket) { 9 | this.name = name; 10 | this.racket = racket; 11 | } 12 | 13 | public String getName() { 14 | return name; 15 | } 16 | 17 | public void setName(String name) { 18 | this.name = name; 19 | } 20 | 21 | public Racket getRacket() { 22 | return racket; 23 | } 24 | 25 | public void setRacket(Racket racket) { 26 | this.racket = racket; 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /Chapter06/Association/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Association 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Association 14 | -------------------------------------------------------------------------------- /Chapter06/Association/src/main/java/coding/challenge/Address.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Address { 4 | 5 | private String city; 6 | private String zip; 7 | 8 | public Address(String city, String zip) { 9 | this.city = city; 10 | this.zip = zip; 11 | } 12 | 13 | public String getCity() { 14 | return city; 15 | } 16 | 17 | public void setCity(String city) { 18 | this.city = city; 19 | } 20 | 21 | public String getZip() { 22 | return zip; 23 | } 24 | 25 | public void setZip(String zip) { 26 | this.zip = zip; 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /Chapter06/Association/src/main/java/coding/challenge/Person.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Person { 4 | 5 | private String name; 6 | 7 | public Person(String name) { 8 | this.name = name; 9 | } 10 | 11 | public String getName() { 12 | return name; 13 | } 14 | 15 | public void setName(String name) { 16 | this.name = name; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter06/CircularByteBuffer/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | CircularByteBuffer cbb = new CircularByteBuffer(3); 8 | 9 | cbb.put(1); 10 | cbb.put(2); 11 | cbb.put(3); 12 | 13 | System.out.println("Available before get: " + cbb.available()); 14 | System.out.println("get: " + cbb.get()); 15 | System.out.println("Available after get: " + cbb.available()); 16 | cbb.clear(); 17 | System.out.println("Available after clear: " + cbb.available()); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /Chapter06/Composition/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Composition 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Composition 14 | -------------------------------------------------------------------------------- /Chapter06/Composition/src/main/java/coding/challenge/Car.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Car { 4 | 5 | private final String name; 6 | private final Engine engine; 7 | 8 | public Car(String name) { 9 | this.name = name; 10 | 11 | Engine engine = new Engine("petrol", 300); 12 | this.engine=engine; 13 | } 14 | 15 | public int getHorsepower() { 16 | return engine.getHorsepower(); 17 | } 18 | 19 | public String getName() { 20 | return name; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Chapter06/Composition/src/main/java/coding/challenge/Engine.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Engine { 4 | 5 | private String type; 6 | private int horsepower; 7 | 8 | public Engine(String type, int horsepower) { 9 | this.type = type; 10 | this.horsepower = horsepower; 11 | } 12 | 13 | public String getType() { 14 | return type; 15 | } 16 | 17 | public void setType(String type) { 18 | this.type = type; 19 | } 20 | 21 | public int getHorsepower() { 22 | return horsepower; 23 | } 24 | 25 | public void setHorsepower(int horsepower) { 26 | this.horsepower = horsepower; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Chapter06/Composition/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Car car = new Car("MyCar"); 8 | 9 | System.out.println("Horsepower: " + car.getHorsepower()); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /Chapter06/CovariantMethodOverriding/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) throws CloneNotSupportedException { 6 | 7 | Rectangle r = new Rectangle(4, 3); 8 | Rectangle clone = r.clone(); 9 | 10 | System.out.println("Width: " + clone.getWidth()); 11 | System.out.println("Height: " + clone.getHeight()); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Chapter06/CovariantMethodOverriding/src/main/java/coding/challenge/Rectangle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Rectangle implements Cloneable { 4 | 5 | private final int height; 6 | private final int width; 7 | 8 | public Rectangle(int height, int width) { 9 | this.height = height; 10 | this.width = width; 11 | } 12 | 13 | public int getHeight() { 14 | return height; 15 | } 16 | 17 | public int getWidth() { 18 | return width; 19 | } 20 | 21 | @Override 22 | protected Rectangle clone() throws CloneNotSupportedException { 23 | 24 | Rectangle clone = (Rectangle) super.clone(); 25 | 26 | return clone; 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /Chapter06/DeckOfCards/DeckOfCardsUML.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/1f589772a205368ec6634e0fcae6fe58e1130aee/Chapter06/DeckOfCards/DeckOfCardsUML.png -------------------------------------------------------------------------------- /Chapter06/DeckOfCards/README.md: -------------------------------------------------------------------------------- 1 | # Deck of Cards UML 2 | ![](https://github.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/blob/master/Chapter06/DeckOfCards/DeckOfCardsUML.png) 3 | -------------------------------------------------------------------------------- /Chapter06/DeckOfCards/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | DeckOfCards 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | DeckOfCards 14 | 15 | -------------------------------------------------------------------------------- /Chapter06/DeckOfCards/src/main/java/coding/challenge/card/Pack.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.card; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public abstract class Pack { 7 | 8 | private List cards; 9 | 10 | protected abstract List build(); 11 | 12 | public int packSize() { 13 | return cards.size(); 14 | } 15 | 16 | public List getCards() { 17 | return new ArrayList<>(cards); 18 | } 19 | 20 | protected void setCards(List cards) { 21 | this.cards = cards; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Chapter06/DeckOfCards/src/main/java/coding/challenge/card/StandardCard.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.card; 2 | 3 | public class StandardCard extends Card { 4 | 5 | private static final int MIN_VALUE = 1; 6 | private static final int MAX_VALUE = 13; 7 | 8 | public StandardCard(StandardSuit suit, int value) { 9 | super(suit, value); 10 | } 11 | 12 | public static int getMinValue() { 13 | return MIN_VALUE; 14 | } 15 | 16 | public static int getMaxValue() { 17 | return MAX_VALUE; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Chapter06/DeckOfCards/src/main/java/coding/challenge/card/StandardSuit.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.card; 2 | 3 | public enum StandardSuit { 4 | 5 | SPADES, HEARTS, DIAMONDS, CLUBS; 6 | } -------------------------------------------------------------------------------- /Chapter06/DependencyInversionPrinciple/src/main/java/coding/challenge/bad/ConnectToDatabase.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public class ConnectToDatabase { 4 | 5 | public void connect(PostgreSQLJdbcUrl postgresql) { 6 | System.out.println("Connecting to " + postgresql.get()); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Chapter06/DependencyInversionPrinciple/src/main/java/coding/challenge/bad/PostgreSQLJdbcUrl.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public class PostgreSQLJdbcUrl { 4 | 5 | private final String dbName; 6 | 7 | public PostgreSQLJdbcUrl(String dbName) { 8 | this.dbName = dbName; 9 | } 10 | 11 | public String get() { 12 | return "jdbc:postgresql:// ... " + this.dbName; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter06/DependencyInversionPrinciple/src/main/java/coding/challenge/good/ConnectToDatabase.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class ConnectToDatabase { 4 | 5 | public void connect(JdbcUrl jdbcUrl) { 6 | System.out.println("Connecting to " + jdbcUrl.get()); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Chapter06/DependencyInversionPrinciple/src/main/java/coding/challenge/good/JdbcUrl.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public interface JdbcUrl { 4 | 5 | public String get(); 6 | } 7 | -------------------------------------------------------------------------------- /Chapter06/DependencyInversionPrinciple/src/main/java/coding/challenge/good/MySQLJdbcUrl.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class MySQLJdbcUrl implements JdbcUrl { 4 | 5 | private final String dbName; 6 | 7 | public MySQLJdbcUrl(String dbName) { 8 | this.dbName = dbName; 9 | } 10 | 11 | @Override 12 | public String get() { 13 | return "jdbc:mysql:// ... " + this.dbName; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter06/DependencyInversionPrinciple/src/main/java/coding/challenge/good/PostgreSQLJdbcUrl.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class PostgreSQLJdbcUrl implements JdbcUrl { 4 | 5 | private final String dbName; 6 | 7 | public PostgreSQLJdbcUrl(String dbName) { 8 | this.dbName = dbName; 9 | } 10 | 11 | @Override 12 | public String get() { 13 | return "jdbc:postgresql:// ... " + this.dbName; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter06/Encapsulation/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Encapsulation 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Encapsulation 14 | -------------------------------------------------------------------------------- /Chapter06/Encapsulation/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Cat cat = new Cat(); 8 | 9 | cat.feed(); 10 | cat.play(); 11 | cat.feed(); 12 | cat.sleep(); 13 | 14 | System.out.println("Energy: " + cat.getEnergy()); 15 | System.out.println("Mood: " + cat.getMood()); 16 | System.out.println("Hungry: " + cat.getHungry()); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Chapter06/FileSystem/FileSystemUML.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/1f589772a205368ec6634e0fcae6fe58e1130aee/Chapter06/FileSystem/FileSystemUML.png -------------------------------------------------------------------------------- /Chapter06/FileSystem/README.md: -------------------------------------------------------------------------------- 1 | # File System UML 2 | ![](https://github.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/blob/master/Chapter06/FileSystem/FileSystemUML.png) 3 | -------------------------------------------------------------------------------- /Chapter06/FileSystem/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | FileSystem 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | FileSystem 14 | 15 | -------------------------------------------------------------------------------- /Chapter06/FileSystem/src/main/java/coding/challenge/filesystem/Directory.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.filesystem; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class Directory extends Item { 7 | 8 | protected List items; 9 | 10 | public Directory(String name, Directory parent) { 11 | 12 | super(name, parent); 13 | 14 | items = new ArrayList<>(); 15 | } 16 | 17 | @Override 18 | public long size() { return 0; } 19 | 20 | public int countFiles() { return 0; } 21 | 22 | protected boolean deleteItem(Item item) { return false; } 23 | protected void addEntry(Item item) {} 24 | protected List getItems() { return null; } 25 | } 26 | -------------------------------------------------------------------------------- /Chapter06/FileSystem/src/main/java/coding/challenge/filesystem/File.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.filesystem; 2 | 3 | public class File extends Item { 4 | 5 | private String content; 6 | private int size; 7 | 8 | public File(String name, Directory parent) { 9 | 10 | super(name, parent); 11 | } 12 | 13 | @Override 14 | public long size() { 15 | return size; 16 | } 17 | 18 | protected void setSize(int size) { 19 | this.size = size; 20 | } 21 | 22 | public void setContent(String content) {} 23 | 24 | public String getContent() { 25 | return content; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Chapter06/HashTable/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | HashTable 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | HashTable 14 | 15 | -------------------------------------------------------------------------------- /Chapter06/Inheritance/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Inheritance 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Inheritance 14 | -------------------------------------------------------------------------------- /Chapter06/Inheritance/src/main/java/coding/challenge/Employee.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Employee { 4 | 5 | private String name; 6 | 7 | public Employee(String name) { 8 | this.name = name; 9 | } 10 | 11 | public String getName() { 12 | return name; 13 | } 14 | 15 | public void setName(String name) { 16 | this.name = name; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter06/Inheritance/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Programmer p = new Programmer("Joana Nimar", "Toronto"); 8 | 9 | String name = p.getName(); 10 | String team = p.getTeam(); 11 | 12 | System.out.println(name + " is assigned to the " + team + " team"); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /Chapter06/Inheritance/src/main/java/coding/challenge/Programmer.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Programmer extends Employee { 4 | 5 | private String team; 6 | 7 | public Programmer(String name, String team) { 8 | super(name); 9 | this.team = team; 10 | } 11 | 12 | public String getTeam() { 13 | return team; 14 | } 15 | 16 | public void setTeam(String team) { 17 | this.team = team; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Chapter06/InterfaceSegregationPrinciple/src/main/java/coding/challenge/bad/Connection.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public interface Connection { 4 | 5 | public void socket(); 6 | 7 | public void http(); 8 | 9 | public void connect(); 10 | } 11 | -------------------------------------------------------------------------------- /Chapter06/InterfaceSegregationPrinciple/src/main/java/coding/challenge/good/Connection.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public interface Connection { 4 | 5 | public void connect(); 6 | } 7 | -------------------------------------------------------------------------------- /Chapter06/InterfaceSegregationPrinciple/src/main/java/coding/challenge/good/HttpConnection.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public interface HttpConnection extends Connection { 4 | 5 | public void http(); 6 | } 7 | -------------------------------------------------------------------------------- /Chapter06/InterfaceSegregationPrinciple/src/main/java/coding/challenge/good/SocketConnection.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public interface SocketConnection extends Connection { 4 | 5 | public void socket(); 6 | } 7 | -------------------------------------------------------------------------------- /Chapter06/InterfaceSegregationPrinciple/src/main/java/coding/challenge/good/WwwPingConnection.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class WwwPingConnection implements HttpConnection { 4 | 5 | private final String www; 6 | 7 | public WwwPingConnection(String www) { 8 | this.www = www; 9 | } 10 | 11 | @Override 12 | public void http() { 13 | System.out.println("Setup an HTTP connection to " + www); 14 | } 15 | 16 | @Override 17 | public void connect() { 18 | System.out.println("Connect to " + www); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /Chapter06/Java8DefaultStaticMethods/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Vehicle.description(); 8 | 9 | PetrolCar pc = new PetrolCar("Audi", 150); 10 | System.out.println("Petrol car consume: " 11 | + String.format("%.1f", pc.computeConsumption(250, 50, pc.getHorsePower())) 12 | + " l/100km"); 13 | 14 | ElectricCar ec = new ElectricCar("Audi", 150); 15 | System.out.println("Electric car consume: " 16 | + String.format("%.1f", ec.computeConsumption(250, 50, ec.getHorsePower())) 17 | + " kW/h"); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Chapter06/Java8DefaultStaticMethods/src/main/java/coding/challenge/SteamCar.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class SteamCar implements Vehicle { 4 | 5 | private String name; 6 | 7 | public SteamCar(String name) { 8 | this.name = name; 9 | } 10 | 11 | public String getName() { 12 | return name; 13 | } 14 | 15 | @Override 16 | public void speedUp() { 17 | System.out.println("Speed up the steam car ..."); 18 | } 19 | 20 | @Override 21 | public void slowDown() { 22 | System.out.println("Slow down the steam car ..."); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Chapter06/Java8DefaultStaticMethods/src/main/java/coding/challenge/Vehicle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public interface Vehicle { 4 | 5 | public void speedUp(); 6 | 7 | public void slowDown(); 8 | 9 | default double computeConsumption(int fuel, int distance, int horsePower) { 10 | return Math.random() * 10d; 11 | } 12 | 13 | static void description() { 14 | System.out.println("This interface control steam, petrol and electric cars"); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter06/Jukebox/JukeboxUML.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/1f589772a205368ec6634e0fcae6fe58e1130aee/Chapter06/Jukebox/JukeboxUML.png -------------------------------------------------------------------------------- /Chapter06/Jukebox/README.md: -------------------------------------------------------------------------------- 1 | # Juckebox UML 2 | ![](https://github.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/blob/master/Chapter06/Jukebox/JukeboxUML.png) 3 | -------------------------------------------------------------------------------- /Chapter06/Jukebox/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Jukebox 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Jukebox 14 | 15 | -------------------------------------------------------------------------------- /Chapter06/Jukebox/src/main/java/coding/challenge/jukebox/CD.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.jukebox; 2 | 3 | import java.util.List; 4 | 5 | public class CD { 6 | 7 | private List songs; 8 | 9 | // more details about CDs 10 | 11 | public List getSongs() { 12 | return songs; 13 | } 14 | 15 | public void setSongs(List songs) { 16 | this.songs = songs; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter06/Jukebox/src/main/java/coding/challenge/jukebox/Selector.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.jukebox; 2 | 3 | public interface Selector { 4 | 5 | public void nextSongBtn(); 6 | public void prevSongBtn(); 7 | public void addSongToPlaylistBtn(Song song); 8 | public void removeSongFromPlaylistBtn(Song song); 9 | public void shuffleBtn(); 10 | } 11 | -------------------------------------------------------------------------------- /Chapter06/Jukebox/src/main/java/coding/challenge/jukebox/Song.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.jukebox; 2 | 3 | public class Song { 4 | 5 | private final String title; 6 | private final CD cd; 7 | 8 | // more song details 9 | 10 | public Song(String title, CD cd) { 11 | this.title = title; 12 | this.cd = cd; 13 | } 14 | 15 | public CD getCd() { 16 | return cd; 17 | } 18 | 19 | public String getTitle() { 20 | return title; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Chapter06/Jukebox/src/main/java/coding/challenge/user/User.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.user; 2 | 3 | import coding.challenge.jukebox.Jukebox; 4 | 5 | public class User { 6 | private final Jukebox jukebox; 7 | 8 | public User(Jukebox jukebox) { 9 | this.jukebox = jukebox; 10 | } 11 | 12 | public Jukebox getJukebox() { 13 | return jukebox; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/bad/FreeMember.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public class FreeMember extends Member { 4 | 5 | public FreeMember(String name) { 6 | super(name); 7 | } 8 | 9 | @Override 10 | public void joinTournament() { 11 | System.out.println("Classic member joins tournament ..."); 12 | } 13 | 14 | // this method breaks Liskov’s Substitution Principle 15 | // since a free member cannot organize tournaments it cannot be 16 | // a substitute for the base class 17 | @Override 18 | public void organizeTournament() { 19 | System.out.println("A free member cannot organize tournaments"); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/bad/Member.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public abstract class Member { 4 | 5 | private final String name; 6 | 7 | public Member(String name) { 8 | this.name = name; 9 | } 10 | 11 | public abstract void joinTournament(); 12 | 13 | public abstract void organizeTournament(); 14 | } 15 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/bad/PremiumMember.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public class PremiumMember extends Member { 4 | 5 | public PremiumMember(String name) { 6 | super(name); 7 | } 8 | 9 | @Override 10 | public void joinTournament() { 11 | System.out.println("Premium member joins tournament ..."); 12 | } 13 | 14 | @Override 15 | public void organizeTournament() { 16 | System.out.println("Premium member organize tournament ..."); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/bad/VipMember.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public class VipMember extends Member { 4 | 5 | public VipMember(String name) { 6 | super(name); 7 | } 8 | 9 | @Override 10 | public void joinTournament() { 11 | System.out.println("VIP member joins tournament ..."); 12 | } 13 | 14 | @Override 15 | public void organizeTournament() { 16 | System.out.println("VIP member organize tournament ..."); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/good/FreeMember.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class FreeMember implements TournamentJoiner { 4 | 5 | private final String name; 6 | 7 | public FreeMember(String name) { 8 | this.name = name; 9 | } 10 | 11 | @Override 12 | public void joinTournament() { 13 | System.out.println("Free member joins tournament ..."); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/good/Member.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public abstract class Member implements TournamentJoiner, TournamentOrganizer { 4 | 5 | private final String name; 6 | 7 | public Member(String name) { 8 | this.name = name; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/good/PremiumMember.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class PremiumMember extends Member { 4 | 5 | public PremiumMember(String name) { 6 | super(name); 7 | } 8 | 9 | @Override 10 | public void joinTournament() { 11 | System.out.println("Premium member joins tournament ..."); 12 | } 13 | 14 | @Override 15 | public void organizeTournament() { 16 | System.out.println("Premium member organize tournament ..."); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/good/TournamentJoiner.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public interface TournamentJoiner { 4 | 5 | public void joinTournament(); 6 | } 7 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/good/TournamentOrganizer.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public interface TournamentOrganizer { 4 | 5 | public void organizeTournament(); 6 | } 7 | -------------------------------------------------------------------------------- /Chapter06/LiskovSubstitutionPrinciple/src/main/java/coding/challenge/good/VipMember.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class VipMember extends Member { 4 | 5 | public VipMember(String name) { 6 | super(name); 7 | } 8 | 9 | @Override 10 | public void joinTournament() { 11 | System.out.println("VIP member joins tournament ..."); 12 | } 13 | 14 | @Override 15 | public void organizeTournament() { 16 | System.out.println("VIP member organize tournament ..."); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter06/MethodHiding/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | MethodHiding 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | MethodHiding 14 | -------------------------------------------------------------------------------- /Chapter06/MethodHiding/src/main/java/coding/challenge/Car.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Car extends Vehicle { 4 | 5 | // this method hides Vehicle#move() 6 | public static void move() { 7 | System.out.println("Moving a car"); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /Chapter06/MethodHiding/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Vehicle.move(); // call Vehicle#move() 8 | Car.move(); // call Car#move() 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /Chapter06/MethodHiding/src/main/java/coding/challenge/Vehicle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Vehicle { 4 | 5 | public static void move() { 6 | System.out.println("Moving a vehicle"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Chapter06/MethodOverloding/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Foo foo = new Foo(); 8 | 9 | foo.foozzy("text", 1); 10 | foo.foozzy(1, "text"); 11 | foo.foozzy(-1, 1); 12 | foo.foozzy("text", -1, 1); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter06/MethodOverriding/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import coding.challenge.inheritance.Child; 4 | import coding.challenge.inheritance.Parent; 5 | import coding.challenge.polymorphism.Concrete; 6 | 7 | public class Main { 8 | 9 | public static void main(String[] args) { 10 | 11 | // Method overriding in Inheritance 12 | Parent parent = new Parent(); 13 | Child child = new Child(); 14 | 15 | parent.execute(); 16 | child.execute(); 17 | 18 | // Method inheritance in Runtime Polymorphism 19 | Concrete concrete = new Concrete(); 20 | 21 | concrete.execute(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Chapter06/MethodOverriding/src/main/java/coding/challenge/inheritance/Child.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.inheritance; 2 | 3 | public class Child extends Parent { 4 | 5 | @Override 6 | public void execute() { 7 | // super.execute(); - if you want to execute the parent code first 8 | System.out.println("Execute child code ..."); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /Chapter06/MethodOverriding/src/main/java/coding/challenge/inheritance/Parent.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.inheritance; 2 | 3 | public class Parent { 4 | 5 | public void execute() { 6 | System.out.println("Execute parent code ..."); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Chapter06/MethodOverriding/src/main/java/coding/challenge/polymorphism/Base.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.polymorphism; 2 | 3 | public interface Base { 4 | 5 | public void execute(); 6 | } 7 | -------------------------------------------------------------------------------- /Chapter06/MethodOverriding/src/main/java/coding/challenge/polymorphism/Concrete.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.polymorphism; 2 | 3 | public class Concrete implements Base { 4 | 5 | @Override 6 | public void execute() { 7 | System.out.println("Execute concrete code ..."); 8 | } 9 | 10 | } 11 | -------------------------------------------------------------------------------- /Chapter06/MovieTicketBooking/MovieTicketBookingUML.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/1f589772a205368ec6634e0fcae6fe58e1130aee/Chapter06/MovieTicketBooking/MovieTicketBookingUML.png -------------------------------------------------------------------------------- /Chapter06/MovieTicketBooking/README.md: -------------------------------------------------------------------------------- 1 | # Movie Ticket Booking UML 2 | ![](https://github.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/blob/master/Chapter06/MovieTicketBooking/MovieTicketBookingUML.png) 3 | -------------------------------------------------------------------------------- /Chapter06/MovieTicketBooking/src/main/java/coding/challenge/cinema/SeatType.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.cinema; 2 | 3 | public enum SeatType { 4 | 5 | SIMPLE(1), SILVER(5), GOLD(10); 6 | 7 | private final int price; 8 | 9 | private SeatType(int price) { 10 | this.price = price; 11 | } 12 | 13 | protected int getPrice() { 14 | return price; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter06/MovieTicketBooking/src/main/java/coding/challenge/ticketing/MovieTicketing.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.ticketing; 2 | 3 | import coding.challenge.cinema.Movie; 4 | import coding.challenge.cinema.MovieTicket; 5 | 6 | public interface MovieTicketing { 7 | 8 | // this is like the Template design pattern 9 | public boolean selectMovieBtn(Movie movie); // step 1 10 | public boolean selectStartTimeBtn(); // step 2 11 | public boolean selectCinemaRoom(); // step 3 12 | public boolean selectSeats(); // step 4 13 | 14 | public MovieTicket buyTicketBtn(); // step 5 15 | } 16 | -------------------------------------------------------------------------------- /Chapter06/OnlineReaderSystem/OnlineReaderSystemUML.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/1f589772a205368ec6634e0fcae6fe58e1130aee/Chapter06/OnlineReaderSystem/OnlineReaderSystemUML.png -------------------------------------------------------------------------------- /Chapter06/OnlineReaderSystem/README.md: -------------------------------------------------------------------------------- 1 | # Online Reader System UML 2 | ![](https://github.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/blob/master/Chapter06/OnlineReaderSystem/OnlineReaderSystemUML.png) 3 | -------------------------------------------------------------------------------- /Chapter06/OnlineReaderSystem/src/main/java/coding/challenge/reader/Library.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.reader; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class Library { 7 | 8 | private final Map books = new HashMap<>(); 9 | 10 | protected void addBook(Book book) { 11 | books.putIfAbsent(book.getIsbn(), book); 12 | } 13 | 14 | protected boolean remove(Book book) { 15 | return books.remove(book.getIsbn(), book); 16 | } 17 | 18 | protected Book find(String isbn) { 19 | return books.get(isbn); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Chapter06/OnlineReaderSystem/src/main/java/coding/challenge/reader/ReaderManager.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.reader; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class ReaderManager { 7 | 8 | private final Map readers = new HashMap<>(); 9 | 10 | protected void addReader(Reader reader) { 11 | readers.putIfAbsent(reader.getEmail(), reader); 12 | } 13 | 14 | protected boolean remove(Reader reader) { 15 | return readers.remove(reader.getEmail(), reader); 16 | } 17 | 18 | protected Reader find(String email) { 19 | return readers.get(email); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Chapter06/OpenClosedPrinciple/src/main/java/coding/challenge/bad/Circle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public class Circle implements Shape { 4 | 5 | private final int radius; 6 | 7 | public Circle(int radius) { 8 | this.radius = radius; 9 | } 10 | 11 | public int getRadius() { 12 | return radius; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter06/OpenClosedPrinciple/src/main/java/coding/challenge/bad/Rectangle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public class Rectangle implements Shape { 4 | 5 | private final int width; 6 | private final int height; 7 | 8 | public Rectangle(int width, int height) { 9 | this.width = width; 10 | this.height = height; 11 | } 12 | 13 | public int getWidth() { 14 | return width; 15 | } 16 | 17 | public int getHeight() { 18 | return height; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /Chapter06/OpenClosedPrinciple/src/main/java/coding/challenge/bad/Shape.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.bad; 2 | 3 | public interface Shape { 4 | } 5 | -------------------------------------------------------------------------------- /Chapter06/OpenClosedPrinciple/src/main/java/coding/challenge/good/AreaCalculator.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | import java.util.List; 4 | 5 | public class AreaCalculator { 6 | 7 | private final List shapes; 8 | 9 | public AreaCalculator(List shapes) { 10 | this.shapes = shapes; 11 | } 12 | 13 | public double sum() { 14 | int sum = 0; 15 | for (Shape shape : shapes) { 16 | sum += shape.area(); 17 | } 18 | 19 | return sum; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Chapter06/OpenClosedPrinciple/src/main/java/coding/challenge/good/Circle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class Circle implements Shape { 4 | 5 | private final int radius; 6 | 7 | public Circle(int radius) { 8 | this.radius = radius; 9 | } 10 | 11 | @Override 12 | public double area() { 13 | return Math.PI * Math.pow(radius, 2); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter06/OpenClosedPrinciple/src/main/java/coding/challenge/good/Rectangle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class Rectangle implements Shape { 4 | 5 | private final int width; 6 | private final int height; 7 | 8 | public Rectangle(int width, int height) { 9 | this.width = width; 10 | this.height = height; 11 | } 12 | 13 | public double area() { 14 | return width * height; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter06/OpenClosedPrinciple/src/main/java/coding/challenge/good/Shape.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public interface Shape { 4 | 5 | public double area(); 6 | } 7 | -------------------------------------------------------------------------------- /Chapter06/OverloadingException/src/main/java/coding/challenge/Clazz.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.sql.SQLException; 4 | 5 | public class Clazz { 6 | 7 | public void foo(String foozzy) { 8 | System.out.println("Executing Clazz#foo() that doesn't throw any exception"); 9 | } 10 | 11 | public void foo() throws SQLException { 12 | System.out.println("Executing Clazz#foo() that throws SQLException"); 13 | throw new SQLException("Cazz#foo() did this!"); 14 | } 15 | 16 | public void foo(int foozzy) { 17 | System.out.println("Executing Clazz#foo() that throws RuntimeException"); 18 | throw new RuntimeException("Clazz#foo(int foozzy) did this!"); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /Chapter06/OverloadingException/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.sql.SQLException; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | Clazz clazz = new Clazz(); 10 | 11 | clazz.foo("Foozzy"); 12 | 13 | System.out.println(); 14 | 15 | try { 16 | clazz.foo(); 17 | } catch (SQLException ex) { 18 | System.err.println(ex); 19 | } 20 | 21 | System.out.println(); 22 | 23 | try { 24 | clazz.foo(1); 25 | } catch (RuntimeException ex) { 26 | System.err.println(ex); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Chapter06/OverridingException/src/main/java/coding/challenge/Parent.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.sql.SQLException; 4 | 5 | public class Parent { 6 | 7 | public void foo() throws SQLException { 8 | System.out.println("Executing Parent#foo() that throws SQLException"); 9 | throw new SQLException("Parent#foo() did this!"); 10 | } 11 | 12 | public void buzz() { 13 | System.out.println("Executing Parent#buzz() that doesn't throw any exception"); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter06/ParkingLot/ParkingLotUML.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/1f589772a205368ec6634e0fcae6fe58e1130aee/Chapter06/ParkingLot/ParkingLotUML.png -------------------------------------------------------------------------------- /Chapter06/ParkingLot/README.md: -------------------------------------------------------------------------------- 1 | # Parking Lot UML 2 | ![](https://github.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/blob/master/Chapter06/ParkingLot/ParkingLotUML.png) 3 | -------------------------------------------------------------------------------- /Chapter06/ParkingLot/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | ParkingLot 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | ParkingLot 14 | 15 | -------------------------------------------------------------------------------- /Chapter06/ParkingLot/src/main/java/coding/challenge/parking/VehicleType.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.parking; 2 | 3 | public enum VehicleType { 4 | 5 | CAR(1), VAN(2), TRUCK(5); 6 | 7 | private final int spotsNeeded; 8 | 9 | private VehicleType(int spotsNeeded) { 10 | this.spotsNeeded = spotsNeeded; 11 | } 12 | 13 | public int getSpotsNeeded() { 14 | return spotsNeeded; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter06/ParkingLot/src/main/java/coding/challenge/parking/system/Parking.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.parking.system; 2 | 3 | import coding.challenge.parking.ParkingTicket; 4 | import coding.challenge.parking.VehicleType; 5 | 6 | public interface Parking { 7 | 8 | public ParkingTicket parkVehicleBtn(String licensePlate, VehicleType type); 9 | public boolean unparkVehicleBtn(String licensePlate, VehicleType type); 10 | public boolean unparkVehicleBtn(ParkingTicket parkingTicket); 11 | } 12 | -------------------------------------------------------------------------------- /Chapter06/Polymorphism/CompileTime/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Triangle triangle = new Triangle(); 8 | 9 | triangle.draw(); 10 | triangle.draw("red"); 11 | triangle.draw(10, "blue"); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Chapter06/Polymorphism/CompileTime/src/main/java/coding/challenge/Triangle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Triangle { 4 | 5 | public void draw() { 6 | System.out.println("Draw default triangle ..."); 7 | } 8 | 9 | public void draw(String color) { 10 | System.out.println("Draw a triangle of color " + color); 11 | } 12 | 13 | public void draw(int size, String color) { 14 | System.out.println("Draw a triangle of color " 15 | + color + " and scale it up with the new size of " + size); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter06/Polymorphism/Runtime/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Runtime 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Runtime 14 | -------------------------------------------------------------------------------- /Chapter06/Polymorphism/Runtime/src/main/java/coding/challenge/Circle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Circle implements Shape { 4 | 5 | @Override 6 | public void draw() { 7 | System.out.println("Draw a circle ..."); 8 | } 9 | 10 | } 11 | -------------------------------------------------------------------------------- /Chapter06/Polymorphism/Runtime/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Shape triangle = new Triangle(); 8 | Shape rectangle = new Rectangle(); 9 | Shape circle = new Circle(); 10 | 11 | triangle.draw(); 12 | rectangle.draw(); 13 | circle.draw(); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /Chapter06/Polymorphism/Runtime/src/main/java/coding/challenge/Rectangle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Rectangle implements Shape { 4 | 5 | @Override 6 | public void draw() { 7 | System.out.println("Draw a rectangle ..."); 8 | } 9 | 10 | } 11 | -------------------------------------------------------------------------------- /Chapter06/Polymorphism/Runtime/src/main/java/coding/challenge/Shape.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public interface Shape { 4 | 5 | public void draw(); 6 | } 7 | -------------------------------------------------------------------------------- /Chapter06/Polymorphism/Runtime/src/main/java/coding/challenge/Triangle.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Triangle implements Shape { 4 | 5 | @Override 6 | public void draw() { 7 | System.out.println("Draw a triangle ..."); 8 | } 9 | 10 | } 11 | -------------------------------------------------------------------------------- /Chapter06/README.md: -------------------------------------------------------------------------------- 1 | # Object-Oriented Programming 2 | This chapter explains the most popular questions and problems concerning object-oriented programming encountered at Java interviews, 3 | including the SOLID principles and coding challenges such as Jukebox, Parking Lot, and Hash Table. 4 | -------------------------------------------------------------------------------- /Chapter06/SingleResponsibilityPrinciple/src/main/java/coding/challenge/good/AreaConverter.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class AreaConverter { 4 | 5 | private static final double INCH_TERM = 0.0254d; 6 | private static final double FEET_TERM = 0.3048d; 7 | 8 | public double metersToInches(int area) { 9 | return area / INCH_TERM; 10 | } 11 | 12 | public double metersToFeet(int area) { 13 | return area / FEET_TERM; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter06/SingleResponsibilityPrinciple/src/main/java/coding/challenge/good/RectangleAreaCalculator.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.good; 2 | 3 | public class RectangleAreaCalculator { 4 | 5 | private final int width; 6 | private final int height; 7 | 8 | public RectangleAreaCalculator(int width, int height) { 9 | this.width = width; 10 | this.height = height; 11 | } 12 | 13 | public int area() { 14 | return width * height; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter06/Tuple/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Tuple 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Tuple 14 | -------------------------------------------------------------------------------- /Chapter06/Tuple/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Pair pair = Pair.of("left", "right"); 8 | 9 | System.out.println(pair.left); 10 | System.out.println(pair.right); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /Chapter06/VendingMachine/README.md: -------------------------------------------------------------------------------- 1 | # Vending Machine UML 2 | ![](https://github.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/blob/master/Chapter06/VendingMachine/VendingMachineUML.png) 3 | -------------------------------------------------------------------------------- /Chapter06/VendingMachine/VendingMachineUML.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PacktPublishing/The-Complete-Coding-Interview-Guide-in-Java/1f589772a205368ec6634e0fcae6fe58e1130aee/Chapter06/VendingMachine/VendingMachineUML.png -------------------------------------------------------------------------------- /Chapter06/VendingMachine/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import coding.challenge.vending.machine.VendingMachine; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | VendingMachine vm = new VendingMachine(); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /Chapter06/VendingMachine/src/main/java/coding/challenge/vending/machine/Coin.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.vending.machine; 2 | 3 | public enum Coin { 4 | 5 | PENNY(1), NICKEL(5), DIME(10), QUARTER(25); 6 | 7 | private final int denomination; 8 | 9 | private Coin(int denomination) { 10 | this.denomination = denomination; 11 | } 12 | 13 | public int getDenomination() { 14 | return denomination; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter06/VendingMachine/src/main/java/coding/challenge/vending/machine/Inventory.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.vending.machine; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public final class Inventory { 7 | 8 | private Map inventory = new HashMap<>(); 9 | 10 | protected int getQuantity(T item) { 11 | Integer quantity = inventory.get(item); 12 | return quantity == null ? 0 : quantity; 13 | } 14 | 15 | protected boolean hasItem(T item) { 16 | return getQuantity(item) > 0; 17 | } 18 | 19 | protected void clear() {} 20 | protected void add(T item) {} 21 | protected void put(T item, int quantity) {} 22 | protected void deduct(T item) {} 23 | } 24 | -------------------------------------------------------------------------------- /Chapter06/VendingMachine/src/main/java/coding/challenge/vending/machine/Item.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.vending.machine; 2 | 3 | public enum Item { 4 | 5 | SKITTLES("Skittles", 15), TWIX("Twix", 35), SNICKERS("Snickers", 25); 6 | 7 | private final String name; 8 | private final int price; 9 | 10 | private Item(String name, int price) { 11 | this.name = name; 12 | this.price = price; 13 | } 14 | 15 | public String getName() { 16 | return name; 17 | } 18 | 19 | public long getPrice() { 20 | return price; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /Chapter06/VendingMachine/src/main/java/coding/challenge/vending/machine/Selector.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.vending.machine; 2 | 3 | import java.util.List; 4 | import java.util.Map; 5 | 6 | public interface Selector { 7 | 8 | public int checkPriceBtn(Item item); 9 | public void insertCoinBtn(Coin coin); 10 | public Map> buyBtn(); 11 | 12 | public List refundBtn(); 13 | public void resetBtn(); 14 | } 15 | -------------------------------------------------------------------------------- /Chapter08/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | -------------------------------------------------------------------------------- /Chapter08/Braces/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Braces 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Braces 14 | -------------------------------------------------------------------------------- /Chapter08/Braces/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.List; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | List results = Braces.embrace(3); 10 | 11 | System.out.println("Output: " + results); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Chapter08/Coins/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Coins 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Coins 14 | -------------------------------------------------------------------------------- /Chapter08/Coins/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | System.out.println("Count (plain recursion): " + Coins.calculateChange(25)); 8 | System.out.println("Count (Memoization): " + Coins.calculateChange(25)); 9 | } 10 | 11 | } 12 | -------------------------------------------------------------------------------- /Chapter08/ColorSpots/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | ColorSpots 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | ColorSpots 14 | -------------------------------------------------------------------------------- /Chapter08/FiveTowers/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | FiveTowers 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | FiveTowers 14 | -------------------------------------------------------------------------------- /Chapter08/FiveTowers/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | import java.util.HashSet; 5 | import java.util.Set; 6 | 7 | public class Main { 8 | 9 | public static void main(String[] args) { 10 | 11 | Set solutions = new HashSet<>(); 12 | 13 | FiveTower.buildTowers(0, new Integer[FiveTower.GRID_SIZE], solutions); 14 | 15 | System.out.println("Solutions:"); 16 | for (Integer[] solution : solutions) { 17 | System.out.println(Arrays.toString(solution)); 18 | } 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Chapter08/HanoiTowers/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | HanoiTowers 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | HanoiTowers 14 | -------------------------------------------------------------------------------- /Chapter08/HanoiTowers/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int n = 3; // Number of disks 8 | 9 | // A - origin-rod 10 | // B - intermediate-rod 11 | // C - target-rod 12 | Hanoi.moveDisks(n, 'A', 'C', 'B'); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /Chapter08/Josephus/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Josephus 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Josephus 14 | -------------------------------------------------------------------------------- /Chapter08/Josephus/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | // 15 people, eliminating every 3th person until only one person is left 8 | // the survivor should be number 5 9 | int n = 15; 10 | int k = 3; 11 | 12 | System.out.println("Using recursion! Survivor: " + Josephus.josephus(n, k) + "\n"); 13 | 14 | Josephus.printJosephus(n, k); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /Chapter08/KnightTour/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | KnightTour 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | KnightTour 14 | -------------------------------------------------------------------------------- /Chapter08/KnightTour/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static final int GRID_SIZE = 5; // minim 5 6 | 7 | public static void main(String[] args) { 8 | 9 | KnightTour knightTour = new KnightTour(GRID_SIZE); 10 | 11 | // visited[][] stores the current path 12 | int visited[][] = new int[GRID_SIZE][GRID_SIZE]; 13 | 14 | int cell = 1; 15 | 16 | // start knight tour from corner cell (0, 0) 17 | knightTour.knightTour(0, 0, cell, visited); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /Chapter08/MagicIndex/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | MagicIndex 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | MagicIndex 14 | -------------------------------------------------------------------------------- /Chapter08/MagicIndex/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] arr = new int[]{1, 4, 4, 4, 5, 5, 6, 6, 6, 11, 12, 12, 12, 15, 17, 20, 21, 21}; 8 | int resultIndex = MagicIndex.find(arr); 9 | 10 | System.out.println("Index " + resultIndex + " has value " + arr[resultIndex]); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /Chapter08/Permutations/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Permutations 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Permutations 14 | -------------------------------------------------------------------------------- /Chapter08/README.md: -------------------------------------------------------------------------------- 1 | # Recursion and Dynamic Programming 2 | This chapter covers one of the favorite topics of interviewers – recursion and Dynamic Programming. Both of these topics work hand in hand with each other, so you have to be able to cover both. 3 | 4 | -------------------------------------------------------------------------------- /Chapter08/RobotGridAllPaths/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | // 6x6 grid 8 | int result1 = RobotGrid.countPaths(6, 6); 9 | int result2 = RobotGrid.countPathsBottomUp(6, 6); 10 | 11 | System.out.println("Number of unique paths via plain recursion: " + result1); 12 | System.out.println("Number of unique paths via Bottom Up: " + result2); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter08/RobotGridMaze/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | RobotGridMaze 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | RobotGridMaze 14 | -------------------------------------------------------------------------------- /Chapter08/Staircase/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Staircase 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Staircase 14 | -------------------------------------------------------------------------------- /Chapter08/Staircase/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | private static final int STEPS = 3; 6 | 7 | public static void main(String[] args) { 8 | 9 | int count = Staircase.count(STEPS); 10 | System.out.println("Count: " + count); 11 | 12 | int countMemo = Staircase.countViaMemoization(STEPS); 13 | System.out.println("Count via memo: " + countMemo); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /Chapter08/SubsetSum/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | SubsetSum 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | SubsetSum 14 | -------------------------------------------------------------------------------- /Chapter08/SubsetSum/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] arr = {5, 1, 6, 10, 7, 11, 2}; 8 | 9 | int[] subset = new int[arr.length]; 10 | 11 | System.out.println("Recursive approach:"); 12 | Subsets.findSumRecursive(arr, 0, 0, 9, subset); 13 | 14 | System.out.println("\n\nDynamic Programming approach:"); 15 | Subsets.findSumDP(arr, 9); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Chapter08/TheFallingBall/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | TheFallingBall 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | TheFallingBall 14 | -------------------------------------------------------------------------------- /Chapter08/WordBreak/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | WordBreak 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | WordBreak 14 | -------------------------------------------------------------------------------- /Chapter09/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | -------------------------------------------------------------------------------- /Chapter09/CheckEquality/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | CheckEquality 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | CheckEquality 14 | -------------------------------------------------------------------------------- /Chapter09/CheckEquality/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static boolean checkEquality(int p, int q) { 10 | 11 | return ((p ^ q) == 0); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Chapter09/CheckEquality/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | System.out.println("(2 equal 4) -> " + Bits.checkEquality(2, 4)); 8 | System.out.println("(67 equal 66) -> " + Bits.checkEquality(67, 66)); 9 | System.out.println("(0 equal 0) -> " + Bits.checkEquality(0, 0)); 10 | System.out.println("(-2 equal -4) -> " + Bits.checkEquality(-2, -4)); 11 | System.out.println("(-2 equal -2) -> " + Bits.checkEquality(-2, -2)); 12 | System.out.println("(12 equal 12) -> " + Bits.checkEquality(12, 12)); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /Chapter09/ClearBits/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | ClearBits 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | ClearBits 14 | -------------------------------------------------------------------------------- /Chapter09/ComputeModuloDivision/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | // 'q' must be power of 2 10 | public static int compute(int p, int q) { 11 | return p & (q - 1); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Chapter09/ComputeModuloDivision/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | // the second number must be power of 2 8 | System.out.println(Bits.compute(3, 4)); 9 | System.out.println(Bits.compute(10, 8)); 10 | System.out.println(Bits.compute(7, 8)); 11 | System.out.println(Bits.compute(9, 4)); 12 | System.out.println(Bits.compute(128, 16)); 13 | System.out.println(Bits.compute(125, 16)); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /Chapter09/Conversion/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Conversion 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Conversion 14 | -------------------------------------------------------------------------------- /Chapter09/Conversion/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static int count(int q, int p) { 10 | 11 | if (q < 0 || p < 0) { 12 | throw new IllegalArgumentException("The q and p numbers must be positive"); 13 | } 14 | 15 | int count = 0; 16 | 17 | int xor = q ^ p; // each 1 represents a bit that is different between q and p 18 | 19 | while (xor != 0) { 20 | count += xor & 1; // only 1 & 1 = 1 21 | xor = xor >> 1; 22 | } 23 | 24 | return count; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Chapter09/Conversion/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int q = 290932; 8 | int p = 352345; 9 | 10 | int result = Bits.count(q, p); 11 | 12 | System.out.println("q: " + Integer.toBinaryString(q)); 13 | System.out.println("p: " + Integer.toBinaryString(p)); 14 | 15 | System.out.println("\nResult: " + result); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Chapter09/FindDuplicates/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | FindDuplicates 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | FindDuplicates 14 | -------------------------------------------------------------------------------- /Chapter09/FindDuplicates/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] numbers = {0, 4, 2, 3, 1, 5, 6, 2, 3, 12, 0, 4, 1}; 8 | 9 | Bits.printDuplicates(numbers); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /Chapter09/FloatToBinaryAndBack/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | float n = -404.0324f; 8 | 9 | int tobinary = Bits.toBinary(n); 10 | float tofloat = Bits.toFloat(tobinary); 11 | 12 | System.out.println("N: " + n); 13 | System.out.println(); 14 | 15 | System.out.println("Result: " + Integer.toBinaryString(tobinary)); 16 | System.out.println("Test: " + Integer.toBinaryString(Float.floatToRawIntBits(n))); 17 | 18 | System.out.println("Float: " + tofloat); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Chapter09/GetBitValue/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | GetBitValue 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | GetBitValue 14 | -------------------------------------------------------------------------------- /Chapter09/GetBitValue/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static char getValue(int n, int k) { 10 | 11 | if (k < 0 || k > 31) { 12 | throw new IllegalArgumentException("The position must be between 0 and 31"); 13 | } 14 | 15 | int result = 1 & (n >> k); 16 | // or, int result = n & (1 << k); 17 | 18 | if (result == 0) { 19 | return '0'; 20 | } 21 | 22 | return '1'; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Chapter09/GetBitValue/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int number = 423; 8 | int position = 7; 9 | 10 | char result = Bits.getValue(number, position); 11 | 12 | System.out.println("Bit at position " + position + " of binary " 13 | + Integer.toBinaryString(number) + " is: " + result); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /Chapter09/LongestSequence/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int n = 67; 8 | 9 | int result = Bits.sequence(n); 10 | 11 | System.out.println("A sequence of 101 is considered 111!"); 12 | System.out.println("The longest sequence of 1 in " 13 | + Integer.toBinaryString(n) + " is equal to " + result); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /Chapter09/MultiplyingBinaries/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int q = 124; 8 | int p = 29; 9 | 10 | int result = Bits.multiply(q, p); 11 | 12 | System.out.println(q + "(" + Integer.toBinaryString(q) + ")" + " * " 13 | + p + "(" + Integer.toBinaryString(p) + ")" + " = " + result 14 | + "(" + Integer.toBinaryString(result) + ")"); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /Chapter09/NextNumber/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | NextNumber 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | NextNumber 14 | -------------------------------------------------------------------------------- /Chapter09/NextNumber/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int number = 124344; 8 | 9 | int resultNext = Bits.next(number); 10 | int resultPrev = Bits.previous(number); 11 | 12 | System.out.println("Number:\t\t" + number + "\t" + Integer.toBinaryString(number)); 13 | System.out.println("Next:\t\t" + resultNext + "\t" + Integer.toBinaryString(resultNext)); 14 | System.out.println("Previous:\t" + resultPrev + "\t" + Integer.toBinaryString(resultPrev)); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /Chapter09/NumberWithOneInLR/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static int setBetween(int left, int right) { 10 | return (1 << (right + 1)) - (1 << left); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Chapter09/NumberWithOneInLR/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int left = 3; 8 | int right = 7; 9 | 10 | int result = Bits.setBetween(left, right); 11 | System.out.println("Result: " + result 12 | + "(" + Integer.toBinaryString(result) + ")"); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /Chapter09/OddEven/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | OddEven 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | OddEven 14 | -------------------------------------------------------------------------------- /Chapter09/OddEven/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static boolean isOdd(int p) { 10 | 11 | return ((p & 1) != 0); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Chapter09/OnceTwiceThrice/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] arr = {4, 4, 3, 1, 7, 7, 7, 1, 1, 4}; 8 | 9 | int result1 = Elements.unique1(arr); 10 | int result2 = Elements.unique2(arr); 11 | System.out.println("Result: " + result1 + " | " + result2); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Chapter09/PositionOfFirstBitOfOne/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static int findPosition(int n) { 10 | 11 | int count = 0; 12 | 13 | if(!isPowerOfTwo(n)) { 14 | return -1; 15 | } 16 | 17 | while (n != 0) { 18 | n = n >> 1; 19 | ++count; 20 | } 21 | 22 | return count; 23 | } 24 | 25 | private static boolean isPowerOfTwo(int n) { 26 | 27 | return (n > 0) && ((n & (n - 1)) == 0); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Chapter09/PositionOfFirstBitOfOne/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int number = 4; 8 | 9 | System.out.println("Result: " + Bits.findPosition(number)); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /Chapter09/PowerSetOfSet/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | PowerSetOfSet 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | PowerSetOfSet 14 | -------------------------------------------------------------------------------- /Chapter09/PowerSetOfSet/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Set; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | char[] set = {'a', 'b', 'c'}; 10 | 11 | Set> subsets = Sets.powerSet(set); 12 | 13 | System.out.println("Result: " + subsets); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /Chapter09/README.md: -------------------------------------------------------------------------------- 1 | # Bit manipulation 2 | This chapter explains the most important aspects of bit manipulation that you should know in a technical interview. Such problems are often encountered in interviews and they are not easy. In this chapter, you have 25 such coding challenges. 3 | -------------------------------------------------------------------------------- /Chapter09/ReplaceBits/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | ReplaceBits 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | ReplaceBits 14 | -------------------------------------------------------------------------------- /Chapter09/RotateBits/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | RotateBits 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | RotateBits 14 | -------------------------------------------------------------------------------- /Chapter09/SetBitValue/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | SetBitValue 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | SetBitValue 14 | -------------------------------------------------------------------------------- /Chapter09/SetBitValue/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static int setValueTo1(int n, int k) { 10 | 11 | if (k < 0 || k > 31) { 12 | throw new IllegalArgumentException("The position must be between 0 and 31"); 13 | } 14 | 15 | return n | (1 << k); 16 | } 17 | 18 | public static int setValueTo0(int n, int k) { 19 | 20 | if (k < 0 || k > 31) { 21 | throw new IllegalArgumentException("The position must be between 0 and 31"); 22 | } 23 | 24 | return n & ~(1 << k); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Chapter09/SubtractingBinaries/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static int subtract(int q, int p) { 10 | 11 | while (p != 0) { 12 | 13 | // borrow is the unset bits of q AND set bits of p 14 | int borrow = (~q) & p; 15 | 16 | // subtraction of bits of q and p 17 | // where at least one of the bits is not set 18 | q = q ^ p; 19 | 20 | // left shift borrow by one position 21 | p = borrow << 1; 22 | } 23 | 24 | return q; 25 | } 26 | } -------------------------------------------------------------------------------- /Chapter09/SubtractingBinaries/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int q = 124; 8 | int p = 29; 9 | 10 | int result = Bits.subtract(q, p); 11 | 12 | System.out.println(q + "(" + Integer.toBinaryString(q) + ")" + " - " 13 | + p + "(" + Integer.toBinaryString(p) + ")" + " = " + result 14 | + "(" + Integer.toBinaryString(result) + ")"); 15 | 16 | System.out.println(); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Chapter09/SummingBinaries/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int q = 23; 8 | int p = 45; 9 | 10 | int result = Bits.sum(q, p); 11 | 12 | System.out.println(q + "(" + Integer.toBinaryString(q) + ")" + " + " 13 | + p + "(" + Integer.toBinaryString(p) + ")" + " = " + result 14 | + "(" + Integer.toBinaryString(result) + ")"); 15 | 16 | System.out.println(); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Chapter09/SwapOddEven/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | SwapOddEven 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | SwapOddEven 14 | -------------------------------------------------------------------------------- /Chapter09/SwapOddEven/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static int swap(int n) { 10 | 11 | if (n < 0) { 12 | return -1; 13 | } 14 | 15 | int moveToEvenPositions = (n & 0b10101010101010101010101010101010) >>> 1; 16 | int moveToOddPositions = (n & 0b1010101010101010101010101010101) << 1; 17 | 18 | return moveToEvenPositions | moveToOddPositions; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /Chapter09/SwapOddEven/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int number = 663; 8 | 9 | int result = Bits.swap(number); 10 | 11 | System.out.println("Initial:\t\t" + Integer.toBinaryString(number)); 12 | System.out.println("Swapped:\t\t" + Integer.toBinaryString(result)); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /Chapter09/SwapTwoIntegers/src/main/java/coding/challenge/Bits.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Bits { 4 | 5 | private Bits() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static void swap(int p, int q) { 10 | 11 | System.out.println(); 12 | System.out.println("Before swap: p=" + p + ", q=" + q); 13 | p = p ^ q ^ (q = p); 14 | System.out.println("After swap: p=" + p + ", q=" + q); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter09/SwapTwoIntegers/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Bits.swap(2, 4); 8 | Bits.swap(-2, 4); 9 | Bits.swap(0, 1); 10 | Bits.swap(42, 11); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /Chapter09/TwoNonRepeating/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] arr = {2, 7, 1, 5, 9, 4, 1, 2, 5, 4}; 8 | 9 | Bits.findNonRepeatable(arr); 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /Chapter10/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | 8 | -------------------------------------------------------------------------------- /Chapter10/ContainerMostWater/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] heights = {1, 4, 6, 2, 7, 3, 8, 5, 3}; 8 | 9 | int max1 = Containers.maxArea(heights); 10 | int max2 = Containers.maxAreaOptimized(heights); 11 | 12 | System.out.println("Result 1: " + max1); 13 | System.out.println("Result 2: " + max2); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /Chapter10/CountDistinctAbsoluteSortedArray/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] m = {-3, -3, -2, -1, -1, -1, 0, 1, 1, 1, 2, 2, 3, 5, 6, 7, 7}; 8 | 9 | int result = Arrays.findAbsoluteDistinct(m); 10 | 11 | System.out.println("Array: " + java.util.Arrays.toString(m)); 12 | System.out.print("The number of distinct absolute values is: " 13 | + result); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter10/CountDistinctInSubarray/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] m = {7, 11, 11, -5, 13, 13, 13, 15, -4, -3, -4, 15, -2, 0, 0, 0, 14, 3, 7, 42, 3}; 8 | int k = 5; 9 | 10 | System.out.println("Array: " + java.util.Arrays.toString(m)); 11 | 12 | Arrays.find(m, k); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter10/CountScore3510/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | CountScore3510 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | CountScore3510 14 | -------------------------------------------------------------------------------- /Chapter10/CountScore3510/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | System.out.println("33: " + Scores.count(33)); 8 | System.out.println("18: " + Scores.count(18)); 9 | } 10 | 11 | } 12 | -------------------------------------------------------------------------------- /Chapter10/EncodedString/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | EncodedString 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | EncodedString 14 | -------------------------------------------------------------------------------- /Chapter10/EncodedString/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | char[] str = "x ".toCharArray(); 10 | 11 | System.out.println("Before: " + Arrays.toString(str)); 12 | 13 | char[] result = Strings.encodeWhitespaces(str); 14 | 15 | System.out.println("After: " + Arrays.toString(result)); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Chapter10/ExtractIntegers/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | String str = "cv dd 4 k 2321 2 11 k4k2 66 4d"; 8 | 9 | System.out.println("String: " + str); 10 | System.out.println("Integers : " + Strings.extract(str)); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /Chapter10/FindPairsSumEqualK/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.List; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | int sum = 10; 10 | int[] arr = new int[]{-5, -2, 5, 4, 3, 7, 2, 1, -1, -2, 15, 6, 12, -4, 3}; 11 | 12 | List result = Arrays.pairs(arr, sum); 13 | 14 | System.out.println("Result: " + result); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter10/LongestConsecutiveSequence/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] sequence = {4, 2, 9, 5, 12, 6, 8}; 8 | 9 | int longestSequence = Sequences.findLongestConsecutive(sequence); 10 | System.out.println("Longest sequence has " + longestSequence + " element(s)"); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /Chapter10/LongestDistinctSubstring/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | String str = "abcc#$%^&ccdbeeebdd012333dbsssbesbaas"; 8 | 9 | String result = Strings.longestDistinctSubstring(str); 10 | 11 | System.out.println("String: " + str); 12 | System.out.println("Result: " + result); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /Chapter10/MaxMatrixOfOne/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | MaxMatrixOfOne 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | MaxMatrixOfOne 14 | -------------------------------------------------------------------------------- /Chapter10/MaxMatrixOfOne/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[][] matrix = { 8 | {0, 0, 1, 1, 0, 0, 0}, 9 | {0, 0, 1, 1, 1, 1, 1}, 10 | {1, 1, 0, 0, 1, 1, 1}, 11 | {1, 1, 0, 0, 1, 1, 1}, 12 | {0, 1, 1, 0, 0, 0, 0}, 13 | }; 14 | 15 | // int max = Matrices.ofOne(matrix); 16 | int max = Matrices.ofOneOptimized(matrix); 17 | System.out.println("\n\nMax: " + max); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /Chapter10/MaximumInCircularArray/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] m = {7, 11, 12, 13, 15, -4, -3, -2, 0, 1, 1, 3, 4, 7, 7}; 8 | 9 | int max = Arrays.findMax(m); 10 | 11 | System.out.println("Array: " + java.util.Arrays.toString(m)); 12 | System.out.println("Max value is: " + max); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter10/MedianOfSortedArrays/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] q = {2, 6, 9, 10, 11, 65, 67}; 8 | int[] p = {1, 5, 17, 18, 25, 28, 39, 77, 88}; 9 | 10 | float result = Arrays.median(q, p); 11 | 12 | System.out.println("Array 'q': " + java.util.Arrays.toString(q)); 13 | System.out.println("Array 'p': " + java.util.Arrays.toString(p)); 14 | System.out.println(); 15 | 16 | System.out.println("Median is: " + result); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter10/MergeIntervals/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | MergeIntervals 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | MergeIntervals 14 | -------------------------------------------------------------------------------- /Chapter10/MergeIntervals/src/main/java/coding/challenge/Interval.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Interval { 4 | 5 | int start, end; 6 | 7 | public Interval(int start, int end) { 8 | this.start = start; 9 | this.end = end; 10 | } 11 | 12 | @Override 13 | public String toString() { 14 | return "[" + start + ", " + end + "]"; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /Chapter10/MergeKSortedArr/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | int[][] arrs = { 10 | {1, 2, 32, 46}, 11 | {-4, 5, 15, 18, 20}, 12 | {3}, 13 | {6, 8}, 14 | {-2, -1, 0} 15 | }; 16 | 17 | int[] result = MergeArrays.merge(arrs, arrs.length); 18 | System.out.println(Arrays.toString(result)); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /Chapter10/MergeKSortedArr/src/main/java/coding/challenge/MinHeap.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class MinHeap { 4 | 5 | int data; 6 | int heapIndex; 7 | int currentIndex; 8 | 9 | public MinHeap(int data, int heapIndex, int currentIndex) { 10 | this.data = data; 11 | this.heapIndex = heapIndex; 12 | this.currentIndex = currentIndex; 13 | } 14 | 15 | @Override 16 | public String toString() { 17 | return data+""; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Chapter10/MinimumInCircularArray/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] m = {7, 11, 12, 13, 15, -4, -3, -2, 0, 1, 1, 3, 4, 7, 7}; 8 | 9 | int min = Arrays.findMin(m); 10 | 11 | System.out.println("Array: " + java.util.Arrays.toString(m)); 12 | System.out.println("Min value is: " + min); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter10/OneEditAway/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | OneEditAway 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | OneEditAway 14 | -------------------------------------------------------------------------------- /Chapter10/OneEditAway/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | String q = "tank"; 8 | String p = "tlank"; 9 | 10 | System.out.println("Result: " + Strings.isOneEditAway(q, p)); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /Chapter10/PetrolBunks/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | PetrolBunks 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | PetrolBunks 14 | -------------------------------------------------------------------------------- /Chapter10/PetrolBunks/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] dist = {5, 4, 6, 3, 5, 7}; 8 | int[] fuel = {3, 3, 5, 5, 6, 8}; 9 | 10 | int startPoint = Bunks.circularTour(fuel, dist); 11 | System.out.println("Start point: " + startPoint); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Chapter10/README.md: -------------------------------------------------------------------------------- 1 | # Arrays and strings 2 | This chapter covers 29 popular problems involving strings and arrays. 3 | 4 | -------------------------------------------------------------------------------- /Chapter10/ReplaceElementWithRank/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | // no duplicates allowed 8 | int[] m = {7, 11, -5, 13, 15, -4, -3, -2, 0, 14, 3, 42}; 9 | 10 | System.out.println("Before: " + java.util.Arrays.toString(m)); 11 | 12 | Arrays.replace(m); 13 | 14 | System.out.println("After: " + java.util.Arrays.toString(m)); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter10/RotateArrayKTimes/src/main/java/coding/challenge/Arrays.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Arrays { 4 | 5 | private Arrays() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static void rightRotate(int[] m, int k) { 10 | 11 | int[] cm = m.clone(); 12 | int len = m.length; 13 | 14 | for (int i = 0; i < len; i++) { 15 | m[(i + k) % len] = cm[i]; 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter10/RotateArrayKTimes/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int A[] = {5, 5, 2, 3, 1, -2, 33, -1}; 8 | int k = 5; 9 | 10 | System.out.println("Before: " + java.util.Arrays.toString(A)); 11 | 12 | Arrays.rightRotate(A, k); 13 | 14 | System.out.println("After: " + java.util.Arrays.toString(A)); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter10/RotateMatrix/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | RotateMatrix 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | RotateMatrix 14 | -------------------------------------------------------------------------------- /Chapter10/RotateString/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | RotateString 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | RotateString 14 | -------------------------------------------------------------------------------- /Chapter10/RotateString/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | String str1 = "helloworld"; 8 | String str2 = "orldhellow"; 9 | 10 | System.out.println("'" + str1 + "' is rotation of '" 11 | + str2 + "': " + Strings.isRotation(str1, str2)); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Chapter10/RotateString/src/main/java/coding/challenge/Strings.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.regex.Pattern; 4 | 5 | public final class Strings { 6 | 7 | private Strings() { 8 | throw new AssertionError("Cannot be instantiated"); 9 | } 10 | 11 | public static boolean isRotation(String str1, String str2) { 12 | 13 | if (str1 == null || str2 == null || str1.isBlank() || str2.isBlank()) { 14 | return false; 15 | } 16 | 17 | if (str1.length() != str2.length()) { 18 | return false; 19 | } 20 | 21 | return (str1 + str1).matches("(?i).*" + Pattern.quote(str2) + ".*"); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Chapter10/SearchInCircularArray/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] m = {11, 14, 23, 24, -1, 3, 5, 6, 8, 9, 10}; 8 | int x = 14; 9 | 10 | int foundIndex = Arrays.find(m, x); 11 | 12 | System.out.println("Array: " + java.util.Arrays.toString(m)); 13 | System.out.println("The value " + x + " was found at index " + foundIndex); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter10/StringShrinker/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | StringShrinker 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | StringShrinker 14 | -------------------------------------------------------------------------------- /Chapter10/StringShrinker/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | String str = "abbb vvvv s rttt rr eeee f"; 8 | 9 | System.out.println("Initial: " + str); 10 | System.out.println("Result : " + Strings.shrink(str)); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /Chapter10/ThreeStacksInOneArray/src/main/java/coding/challenge/StackNode.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class StackNode { 4 | 5 | int value; 6 | int backLink; 7 | 8 | StackNode(int value, int backLink) { 9 | this.value = value; 10 | this.backLink = backLink; 11 | } 12 | 13 | @Override 14 | public String toString() { 15 | return value + "(back link: " + backLink + ")"; 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Chapter10/ThreeStacksInOneArray/src/main/java/coding/challenge/exception/OverflowException.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.exception; 2 | 3 | public class OverflowException extends Exception { 4 | 5 | private static final long serialVersionUID = 7718828512143293558L; 6 | 7 | public OverflowException(String message) { 8 | super(message); 9 | } 10 | 11 | public OverflowException(String message, Throwable cause) { 12 | super(message, cause); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter10/ThreeStacksInOneArray/src/main/java/coding/challenge/exception/UnderflowException.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.exception; 2 | 3 | public class UnderflowException extends Exception { 4 | 5 | private static final long serialVersionUID = 7718828512143293558L; 6 | 7 | public UnderflowException(String message) { 8 | super(message); 9 | } 10 | 11 | public UnderflowException(String message, Throwable cause) { 12 | super(message, cause); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter10/ThreeStacksInOneArrayFixed/src/main/java/coding/challenge/exception/OverflowException.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.exception; 2 | 3 | public class OverflowException extends Exception { 4 | 5 | private static final long serialVersionUID = 7718828512143293558L; 6 | 7 | public OverflowException(String message) { 8 | super(message); 9 | } 10 | 11 | public OverflowException(String message, Throwable cause) { 12 | super(message, cause); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter10/ThreeStacksInOneArrayFixed/src/main/java/coding/challenge/exception/UnderflowException.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.exception; 2 | 3 | public class UnderflowException extends Exception { 4 | 5 | private static final long serialVersionUID = 7718828512143293558L; 6 | 7 | public UnderflowException(String message) { 8 | super(message); 9 | } 10 | 11 | public UnderflowException(String message, Throwable cause) { 12 | super(message, cause); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter10/TrapRainWater/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | TrapRainWater 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | TrapRainWater 14 | -------------------------------------------------------------------------------- /Chapter10/UniqueCharactersAZ/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | String text1 = "abcdefhzqoc"; 8 | String text2 = "abcdefhzqow"; 9 | 10 | boolean resultText1 = Strings.isUnique(text1); 11 | boolean resultText2 = Strings.isUnique(text2); 12 | 13 | System.out.println("Text1 has unique characters? " + resultText1); 14 | System.out.println("Text2 has unique characters? " + resultText2); 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /Chapter11/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | 8 | -------------------------------------------------------------------------------- /Chapter11/DoublyLinkedListReverse/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | DoublyLinkedList dll = new DoublyLinkedList(); 8 | 9 | dll.insertFirst(122); 10 | dll.insertFirst(4); 11 | dll.insertFirst(7); 12 | dll.insertFirst(-2); 13 | dll.insertFirst(2); 14 | dll.insertFirst(21); 15 | dll.insertFirst(22); 16 | 17 | System.out.println("\nInitial:"); 18 | dll.print(); 19 | 20 | dll.reverse(); 21 | 22 | System.out.println("\nReversed:"); 23 | dll.print(); 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /Chapter11/LRUCache/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | LRUCache 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | LRUCache 14 | -------------------------------------------------------------------------------- /Chapter11/LinkedListLoopDetection/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | SinglyLinkedList sll = new SinglyLinkedList(); 8 | 9 | sll.insertFirst(10); 10 | sll.insertFirst(9); 11 | sll.insertFirst(8); 12 | sll.insertFirst(7); 13 | sll.insertFirst(6); 14 | sll.insertFirst(5); 15 | sll.insertFirst(4); 16 | sll.insertFirst(3); 17 | sll.insertFirst(2); 18 | sll.insertFirst(1); 19 | sll.insertFirst(0); 20 | 21 | sll.generateLoop(); 22 | sll.print(); 23 | 24 | sll.findLoopStartNode(); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /Chapter11/LinkedListMoveLastToFront/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | SinglyLinkedList sll = new SinglyLinkedList(); 8 | 9 | sll.insertFirst(7); 10 | sll.insertFirst(10); 11 | sll.insertFirst(3); 12 | sll.insertFirst(9); 13 | sll.insertFirst(1); 14 | 15 | System.out.println("\nInitial:"); 16 | sll.print(); 17 | 18 | sll.moveLastToFront1(); 19 | // sll.moveLastToFront2(); 20 | 21 | System.out.println("\nResult:"); 22 | sll.print(); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Chapter11/LinkedListPalindrome/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | SinglyLinkedList sll = new SinglyLinkedList(); 8 | 9 | sll.insertFirst(11); 10 | sll.insertFirst(10); 11 | sll.insertFirst(9); 12 | sll.insertFirst(8); 13 | sll.insertFirst(9); 14 | sll.insertFirst(10); 15 | sll.insertFirst(11); 16 | 17 | sll.print(); 18 | 19 | boolean result = sll.isPalindrome(); 20 | 21 | System.out.println("\nIs it palindrome? " + result); 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /Chapter11/LinkedListSum/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | SinglyLinkedList sll1 = new SinglyLinkedList(); 8 | sll1.insertFirst(2); 9 | sll1.insertFirst(1); 10 | sll1.insertFirst(4); 11 | sll1.insertFirst(9); 12 | sll1.insertFirst(8); 13 | sll1.insertFirst(3); 14 | sll1.insertFirst(7); 15 | 16 | SinglyLinkedList sll2 = new SinglyLinkedList(); 17 | sll2.insertFirst(4); 18 | sll2.insertFirst(8); 19 | sll2.insertFirst(9); 20 | sll2.insertFirst(7); 21 | 22 | sll1.sum(sll2); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Chapter11/LinkedListsIntersection/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | SinglyLinkedList sll = new SinglyLinkedList(); 8 | 9 | int intersection = sll.intersection(); 10 | 11 | System.out.println("\nIntersection node has the value (-1 means no intersection): " + intersection); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /Chapter11/Map/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Map 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Map 14 | -------------------------------------------------------------------------------- /Chapter11/Map/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | MyMap map = new MyMap<>(); 8 | 9 | map.put("Alex", 1); 10 | map.put("Tomy", 2); 11 | map.put("Anna", 3); 12 | 13 | System.out.println("Alex value is: " + map.get("Alex")); 14 | 15 | map.remove("Alex"); 16 | 17 | System.out.println(map); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /Chapter11/NutsAndBolts/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | NutsAndBolts 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | NutsAndBolts 14 | -------------------------------------------------------------------------------- /Chapter11/NutsAndBolts/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | char[] nuts = {'$', '%', '&', 'x', '@'}; 8 | char[] bolts = {'%', '@', 'x', '$', '&'}; 9 | 10 | NutsBolts.match(nuts, bolts); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /Chapter11/README.md: -------------------------------------------------------------------------------- 1 | # Linked lists and maps 2 | This chapter teaches you the 17 most famous coding challenges that involve maps and linked lists encountered in interviews. 3 | -------------------------------------------------------------------------------- /Chapter11/ReverseLinkedListInGroups/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | SinglyLinkedList sll = new SinglyLinkedList(); 8 | 9 | sll.insertFirst(0); 10 | sll.insertFirst(9); 11 | sll.insertFirst(2); 12 | sll.insertFirst(8); 13 | sll.insertFirst(1); 14 | sll.insertFirst(3); 15 | sll.insertFirst(4); 16 | sll.insertFirst(7); 17 | 18 | sll.print(); 19 | 20 | sll.reverseInKGroups(3); 21 | 22 | sll.print(); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Chapter12/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | 8 | -------------------------------------------------------------------------------- /Chapter12/MinStackConstantTime/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | MyStack stack = new MyStack(); 8 | 9 | stack.push(25); 10 | stack.push(35); 11 | stack.push(15); 12 | 13 | System.out.println("Min: " + stack.min()); 14 | 15 | stack.push(-1); 16 | stack.push(-3); 17 | stack.push(6); 18 | 19 | System.out.println("Min: " + stack.min()); 20 | 21 | stack.pop(); 22 | stack.pop(); 23 | 24 | System.out.println("Min: " + stack.min()); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /Chapter12/MyQueue/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | MyQueue 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | MyQueue 14 | -------------------------------------------------------------------------------- /Chapter12/MyStack/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | MyStack 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | MyStack 14 | -------------------------------------------------------------------------------- /Chapter12/QueueIslands/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | QueueIslands 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | QueueIslands 14 | -------------------------------------------------------------------------------- /Chapter12/README.md: -------------------------------------------------------------------------------- 1 | # Linked lists and maps 2 | This chapter explains the 11 most popular interview coding challenges involving stacks and queues. Mainly, you have to learn how to provide a stack/queue implementation from scratch and how to tackle coding challenges via the Java built-in implementations. 3 | -------------------------------------------------------------------------------- /Chapter12/SmallestNumber/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | String nr = "4321"; 8 | 9 | Numbers.smallestAfterRemove(nr, 2); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Chapter12/StackBraces/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | StackBraces 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | StackBraces 14 | -------------------------------------------------------------------------------- /Chapter12/StackBraces/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | String goodBracesStr = "{}{{{}}}{{}}{}"; 8 | String wrongBracesStr = "{}{{{}}}{{}{{}"; 9 | 10 | System.out.println("Good (should return true): " 11 | + StackBraces.bracesMatching(goodBracesStr)); 12 | 13 | System.out.println("Wrong (should return false): " 14 | + StackBraces.bracesMatching(wrongBracesStr)); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter12/StackHistogramArea/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] histogram = {4, 2, 8, 6, 5, 3}; 8 | 9 | int ma = Stacks.maxAreaUsingStack(histogram); 10 | 11 | System.out.println("Max area: " + ma); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Chapter12/StackReverseString/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | String str = "dlrow olleh"; 8 | 9 | String result = Stacks.reverse(str); 10 | System.out.println("Result: " + result); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Chapter12/StockSpan/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | StockSpan 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | StockSpan 14 | -------------------------------------------------------------------------------- /Chapter12/StockSpan/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | int stockPrices[] = {55, 34, 22, 23, 27, 88, 70, 42, 51, 100}; 10 | int[] spanResult = StockSpan.stockSpan(stockPrices); 11 | 12 | System.out.println("Stock prices: " + Arrays.toString(stockPrices)); 13 | System.out.println("Span results: " + Arrays.toString(spanResult)); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter13/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | 8 | -------------------------------------------------------------------------------- /Chapter13/AVLTreeImpl/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | AVLTreeImpl 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | AVLTreeImpl 14 | -------------------------------------------------------------------------------- /Chapter13/AVLTreeImpl/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | AVLTree bst = new AVLTree(); 8 | 9 | bst.insert(11); 10 | bst.insert(21); 11 | bst.insert(3); 12 | bst.insert(34); 13 | bst.insert(5); 14 | bst.insert(64); 15 | bst.insert(7); 16 | bst.insert(58); 17 | 18 | bst.print(); 19 | 20 | System.out.println("\nDelete 5 and 11: \n"); 21 | bst.delete(5); 22 | bst.delete(11); 23 | 24 | bst.print(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Chapter13/BinarySearchTreeSuccessor/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | /* 8 | 70 9 | / \ 10 | 50 75 11 | / \ / \ 12 | 40 55 72 77 13 | / / \ 14 | 35 54 60 15 | / 16 | 58 17 | \ 18 | 59 19 | */ 20 | BinarySearchTree bt = new BinarySearchTree(); 21 | 22 | bt.buildTreeSample(); 23 | 24 | bt.inOrderSuccessor(); 25 | bt.preOrderSuccessor(); 26 | bt.postOrderSuccessor(); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Chapter13/BinaryTreeDistanceFromLeaf/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | BinaryTree bt = new BinaryTree<>(); 8 | 9 | bt.leafDistance(2); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Chapter13/BinaryTreeRightView/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | BinaryTree bt = new BinaryTree(); 8 | 9 | System.out.println("Iterative approach:"); 10 | bt.printRightViewIterative(); 11 | 12 | System.out.println("\n\nRecursive approach:"); 13 | bt.printRightViewRecursive(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Chapter13/BinaryTreeVerticalSum/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | BinaryTree bt = new BinaryTree<>(); 8 | 9 | bt.verticalSum(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Chapter13/ChessKnight/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | ChessKnight 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | ChessKnight 14 | -------------------------------------------------------------------------------- /Chapter13/ChessKnight/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | ChessKnight ck = new ChessKnight(); 8 | 9 | int movesNr = ck.countknightMoves(0, 7, 7, 0, 8); 10 | 11 | System.out.println("Minimum number of needed moves: " + movesNr); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Chapter13/HeapConnectRopes/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] ropesLength = {1, 4, 6, 3}; 8 | MinHeap heap = new MinHeap(); 9 | 10 | int result = heap.minimumCost(ropesLength); 11 | 12 | System.out.println("Result: " + result); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter13/MaxHeap/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | MaxHeap 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | MaxHeap 14 | -------------------------------------------------------------------------------- /Chapter13/README.md: -------------------------------------------------------------------------------- 1 | # Trees and graphs 2 | This chapter covers one of the most tricky topics in interviews – trees and graphs. While there are tons of problems related to these two topics, only a handful of them are actually encountered in interviews. It is therefore very important to give a high priority to the most popular problems concerning trees and graphs. 3 | -------------------------------------------------------------------------------- /Chapter13/RedBlackTreeImpl/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | RedBlackTree rbt = new RedBlackTree(); 8 | rbt.insert(5); 9 | rbt.insert(15); 10 | rbt.insert(35); 11 | rbt.insert(3); 12 | rbt.insert(18); 13 | rbt.insert(6); 14 | rbt.insert(135); 15 | rbt.insert(65); 16 | rbt.print(); 17 | 18 | System.out.println("\nDelete 5 and 35 ..."); 19 | rbt.delete(5); 20 | rbt.delete(35); 21 | 22 | rbt.print(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Chapter13/TwoBinaryTreesAreIsomorphic/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | BinaryTree bt = new BinaryTree(); 8 | 9 | boolean result = bt.isIsomorphic(); 10 | System.out.println("Is isomorphic: " + result); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Chapter14/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | 8 | -------------------------------------------------------------------------------- /Chapter14/BinarySearch/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | BinarySearch 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | BinarySearch 14 | -------------------------------------------------------------------------------- /Chapter14/BinarySearch/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | // initialize an array integers 8 | int[] integers = {1, 4, 5, 7, 10, 16, 17, 18, 20, 23, 24, 25, 26, 30, 31, 33}; 9 | int p = 17; 10 | 11 | int resultIterative = BinarySearch.runIterative(integers, p); 12 | int resultRecursive = BinarySearch.runRecursive(integers, 0, integers.length - 1, p); 13 | 14 | System.out.println("Iterative approach - found at index: " + resultIterative); 15 | System.out.println("Recursive approach - found at index: " + resultRecursive); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter14/BucketSort/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | BucketSort 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | BucketSort 14 | -------------------------------------------------------------------------------- /Chapter14/FindNearestMinimum/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | // Output: _, _, 1, 1, 3, 1, 2, 6, 2, 4, 8 | int[] integers = {4, 1, 8, 3, 8, 2, 6, 7, 4, 9}; 9 | 10 | Finds.leftSmaller(integers); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Chapter14/HeapSort/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | HeapSort 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | HeapSort 14 | -------------------------------------------------------------------------------- /Chapter14/HeapSort/src/main/java/coding/challenge/Melon.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Melon { 4 | 5 | private final String type; 6 | private final int weight; 7 | 8 | public Melon(String type, int weight) { 9 | this.type = type; 10 | this.weight = weight; 11 | } 12 | 13 | public String getType() { 14 | return type; 15 | } 16 | 17 | public int getWeight() { 18 | return weight; 19 | } 20 | 21 | @Override 22 | public String toString() { 23 | return type + "(" + weight + "g)"; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /Chapter14/MaxDiffBetweenTwoElements/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] integers = {4, 1, 8, 3, 8, 2, 6, 7, 4, 9}; 8 | 9 | int md = Arrays.maxDiff(integers); 10 | System.out.println("Max diff: " + md); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Chapter14/MergeSort/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | MergeSort 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | MergeSort 14 | -------------------------------------------------------------------------------- /Chapter14/MergeSort/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | // initialize an array integers 10 | int[] integers = {4, 5, 2, 7, 1}; 11 | 12 | System.out.println("\n\nSort via Merge sort:"); 13 | System.out.println("----------------------"); 14 | 15 | MergeSort.sort(integers); 16 | System.out.println("Sorted: " + Arrays.toString(integers)); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter14/MergeTwoSortedArrays/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | // 0, 0, 0, 0, 0, 0 are spots needed for adding q in p 10 | int[] p = {-3, -2, 0, 3, 8, 12, 16, 17, 24, 39, 0, 0, 0, 0, 0, 0}; 11 | int[] q = {-4, -2, -1, 1, 4, 36}; 12 | 13 | SortArrays.merge(p, q); 14 | 15 | System.out.println("Result: " + Arrays.toString(p)); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter14/PeaksAndValleys/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | int[] integers = {4, 5, 8, 3, 2, 1, 7, 8, 5, 9}; 10 | 11 | System.out.println("Before sorting: " + Arrays.toString(integers)); 12 | PeaksValleys.sort(integers); 13 | System.out.println("After sorting: " + Arrays.toString(integers)); 14 | 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter14/PositionOfFirstOne/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] zerosAndOnes = {0, 0, 1, 1, 1, 1, 1}; 8 | 9 | int index = Arrays.firstOneIndex(zerosAndOnes); 10 | System.out.println("Index: " + index); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Chapter14/QuickSort/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | QuickSort 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | QuickSort 14 | -------------------------------------------------------------------------------- /Chapter14/QuickSort/src/main/java/coding/challenge/Melon.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Melon { 4 | 5 | private final String type; 6 | private final int weight; 7 | 8 | public Melon(String type, int weight) { 9 | this.type = type; 10 | this.weight = weight; 11 | } 12 | 13 | public String getType() { 14 | return type; 15 | } 16 | 17 | public int getWeight() { 18 | return weight; 19 | } 20 | 21 | @Override 22 | public String toString() { 23 | return type + "(" + weight + "g)"; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /Chapter14/README.md: -------------------------------------------------------------------------------- 1 | # Sorting and searching 2 | This chapter covers the most popular sorting and searching algorithms encountered in technical interviews. We will cover sorting algorithms such 3 | as Merge Sort, Quick Sort, Radix Sort, Heap Sort, and Bucket Sort, and searching algorithms such as Binary Search. By the end of this chapter, you should be able to tackle a wide range of problems that involve sorting and searching algorithms. 4 | -------------------------------------------------------------------------------- /Chapter14/RadixSort/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | RadixSort 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | RadixSort 14 | -------------------------------------------------------------------------------- /Chapter14/RadixSort/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | // initialize an array integers 10 | int[] integers = {323, 2, 33, 123, 45, 6, 788}; 11 | 12 | System.out.println("\n\nSort via Radi sort:"); 13 | System.out.println("-----------------------"); 14 | 15 | RadixSort.sort(integers, 10); 16 | System.out.println("Sorted: " + Arrays.toString(integers)); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter14/RankInStream/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | RankInStream 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | RankInStream 14 | -------------------------------------------------------------------------------- /Chapter14/SearchInFullSortedMatrix/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[][] matrix = { 8 | {1, 3, 7, 8}, 9 | {10, 16, 19, 22}, 10 | {28, 36, 39, 53} 11 | }; 12 | 13 | int elementToFind = 19; 14 | 15 | System.out.println("Found (" + elementToFind + "): " 16 | + Matrices.search(matrix, elementToFind)); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter14/SortArrayBasedOnAnotherArray/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | int[] firstArr = {4, 1, 8, 1, 3, 8, 6, 7, 4, 9, 8, 2, 5, 3}; 10 | int[] secondArr = {7, 4, 8, 11, 2}; 11 | 12 | System.out.println("Before: " + Arrays.toString(firstArr)); 13 | Sorts.custom(firstArr, secondArr); 14 | System.out.println("After: " + Arrays.toString(firstArr)); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Chapter14/SortArraysIn14Ways/src/main/java/coding/challenge/Melon.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Melon { 4 | 5 | private final String type; 6 | private final int weight; 7 | 8 | public Melon(String type, int weight) { 9 | this.type = type; 10 | this.weight = weight; 11 | } 12 | 13 | public String getType() { 14 | return type; 15 | } 16 | 17 | public int getWeight() { 18 | return weight; 19 | } 20 | 21 | @Override 22 | public String toString() { 23 | return type + "(" + weight + "g)"; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /Chapter14/SortQueueViaTempQueue/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.Queue; 5 | 6 | public class Main { 7 | 8 | public static void main(String[] args) { 9 | 10 | Queue queue = new ArrayDeque<>(); 11 | queue.add(7); 12 | queue.add(1); 13 | queue.add(4); 14 | queue.add(0); 15 | queue.add(2); 16 | queue.add(-4); 17 | queue.add(-4); 18 | queue.add(1); 19 | queue.add(0); 20 | queue.add(14); 21 | 22 | System.out.println("Given queue: " + queue); 23 | 24 | Queues.sort(queue); 25 | 26 | System.out.println("Sorted queue: " + queue); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Chapter14/SortStack/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | SortStack 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | SortStack 14 | -------------------------------------------------------------------------------- /Chapter14/SortStack/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Stack; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | Stack stack = new Stack<>(); 10 | 11 | stack.push(1); 12 | stack.push(2); 13 | stack.push(1); 14 | stack.push(3); 15 | stack.push(5); 16 | stack.push(4); 17 | 18 | System.out.println("Before sorting: " + stack); 19 | 20 | Stacks.sort(stack); 21 | 22 | System.out.println("After sorting: " + stack); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Chapter14/SortStackInPlace/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Stack; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | Stack stack = new Stack<>(); 10 | 11 | stack.push(1); 12 | stack.push(2); 13 | stack.push(8); 14 | stack.push(3); 15 | stack.push(5); 16 | stack.push(4); 17 | 18 | System.out.println("Before sorting: " + stack); 19 | 20 | Stacks.sort(stack); 21 | 22 | System.out.println("After sorting: " + stack); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Chapter14/UnknownSizeList/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] slArr = {-2, 3, 12, 14, 16, 22, 23, 27}; 8 | SizelessList sl = new SizelessList(slArr); 9 | 10 | System.out.println("Search 2: " + UnknownSizeList.search(sl, 3)); 11 | System.out.println("Search 23: " +UnknownSizeList.search(sl, 23)); 12 | System.out.println("Search 1: " +UnknownSizeList.search(sl, 1)); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter14/UnknownSizeList/src/main/java/coding/challenge/SizelessList.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class SizelessList { 4 | 5 | private final int[] arr; 6 | 7 | public SizelessList(int[] arr) { 8 | this.arr = arr.clone(); 9 | } 10 | 11 | public int peekAt(int index) { 12 | if (index >= arr.length) { 13 | return -1; 14 | } 15 | 16 | return arr[index]; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter14/WordSearch/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | WordSearch 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | WordSearch 14 | -------------------------------------------------------------------------------- /Chapter14/WordSearch/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | char[][] board 10 | = { 11 | {'T', 'A', 'C'}, 12 | {'A', 'B', 'L'}, 13 | {'X', 'I', 'E'} 14 | }; 15 | 16 | boolean resultTable = Words.exist(board, "TABLE"); 17 | boolean resultTaxi = Words.exist(board, "TAXI"); 18 | 19 | System.out.println("Found 'TABLE'? " + resultTable); 20 | System.out.println("Found 'TAXI'? " + resultTaxi); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Chapter15/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | 8 | -------------------------------------------------------------------------------- /Chapter15/Abcd/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Abcd 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Abcd 14 | -------------------------------------------------------------------------------- /Chapter15/Abcd/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | Abcd.find(); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /Chapter15/BreakChocolate/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int result = Chocolates.breakit(12, 10, 8); 8 | 9 | System.out.println("(-1: not possible; 0: no breaks needed; " 10 | + "1: one break; 2: two breaks): " + result); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Chapter15/DecodingDigitSequence/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | /* 8 | 1 2 3 2 1 1 9 | 12 3 2 1 1 10 | 12 3 21 1 11 | 12 3 2 11 12 | 1 23 2 1 1 13 | 1 23 21 1 14 | 1 23 2 11 15 | 1 2 3 11 16 | 1 2 3 21 1 17 | */ 18 | char digits[] = {'1', '2', '3', '2', '1', '1'}; 19 | 20 | System.out.println("Recursive approach: " + Digits.decoding(digits, digits.length)); 21 | System.out.println("DP approach: " + Digits.decoding(digits)); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Chapter15/FizzBuzz/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | FizzBuzz 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | FizzBuzz 14 | -------------------------------------------------------------------------------- /Chapter15/FizzBuzz/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | FizzBuzz.print(100); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /Chapter15/HourMinuteAngle/src/main/java/coding/challenge/Clock.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Clock { 4 | 5 | private Clock() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static float findAngle(int hour, int min) { 10 | 11 | if (hour <= 0 || hour > 12) { 12 | throw new IllegalArgumentException("Hour must be between 1-12"); 13 | } 14 | 15 | if (min < 0 || min > 60) { 16 | throw new IllegalArgumentException("Minute must be between 0-60"); 17 | } 18 | 19 | float angle = (float) Math.abs(((30f * hour) + (0.5f * min)) - (6f * min)); 20 | 21 | return angle > 180f ? (360f - angle) : angle; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Chapter15/KthNumber357/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | KthNumber357 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | KthNumber357 14 | -------------------------------------------------------------------------------- /Chapter15/KthNumber357/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | // sample of the array: 8 | // 1, 3, 5, 7, 3 * 3, 3 * 5, 3 * 7, 5 * 5, 3 * 3 * 3, 5 * 7, 3 * 3 * 5, 7 * 7 ... 9 | int result1 = Numbers.kth1(7); 10 | int result2 = Numbers.kth2(7); 11 | 12 | System.out.println("Result: " + result1 + " | " + result2); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter15/MultiplyLargeNumbers/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | // result 3198328601925 8 | String a = "4145775"; 9 | String b = "771467"; 10 | 11 | String result = Numbers.multiply(a, b); 12 | System.out.print(result); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter15/NextElementSameDigits/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int digits[] = { 6, 2, 1, 8, 7, 3 }; 8 | Numbers.findNextGreater(digits); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /Chapter15/NumberDivisibleDigits/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | System.out.println("1: " + Numbers.isDivisible(1)); 8 | System.out.println("6242: " + Numbers.isDivisible(6242)); 9 | System.out.println("123: " + Numbers.isDivisible(123)); 10 | System.out.println("46: " + Numbers.isDivisible(46)); 11 | System.out.println("144: " + Numbers.isDivisible(144)); 12 | System.out.println("250: " + Numbers.isDivisible(250)); 13 | System.out.println("1030: " + Numbers.isDivisible(1030)); 14 | System.out.println("1010: " + Numbers.isDivisible(1010)); 15 | } 16 | } 17 | 18 | -------------------------------------------------------------------------------- /Chapter15/NumberDivisibleDigits/src/main/java/coding/challenge/Numbers.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public final class Numbers { 4 | 5 | private Numbers() { 6 | throw new AssertionError("Cannot be instantiated"); 7 | } 8 | 9 | public static boolean isDivisible(int n) { 10 | 11 | int t = n; 12 | 13 | while (n > 0) { 14 | 15 | int k = n % 10; 16 | 17 | if (k != 0 && t % k != 0) { 18 | return false; 19 | } 20 | 21 | n /= 10; 22 | } 23 | 24 | return true; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Chapter15/PythagoreanTriplets/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] arr = {3, 6, 8, 5, 10, 4, 12, 14}; 8 | 9 | Pythagoreans.triplet(arr); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Chapter15/README.md: -------------------------------------------------------------------------------- 1 | # Math and logical puzzles 2 | This chapter talks about a controversial topic in interviews: mathematics and puzzle problems. A significant number of companies consider that these 3 | kinds of problems should not be part of a technical interview, while other companies still regard this topic as relevant for interviews. 4 | -------------------------------------------------------------------------------- /Chapter15/RectangleOverlap/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.awt.Point; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | Point r1lt = new Point(1, 8); 10 | Point r1rb = new Point(5, 6); 11 | 12 | Point r2lt = new Point(3, 7); 13 | Point r2rb = new Point(6, 5); 14 | 15 | boolean result1 = Rectangles.overlap1(r1lt, r1rb, r2lt, r2rb); 16 | boolean result2 = Rectangles.overlap2(r1lt, r1rb, r2lt, r2rb); 17 | System.out.println("Result: " + result1 + " | " + result2); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Chapter15/RomanNumbers/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | RomanNumbers 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | RomanNumbers 14 | -------------------------------------------------------------------------------- /Chapter15/ScheduleOneElevator/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | int k = 3; 8 | int floors[] = {4, 2, 1, 2, 4}; 9 | 10 | System.out.println("Minimum time: " + Elevators.time(k, floors)); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Chapter15/VisitToggle100Doors/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.Arrays; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | 9 | int[] result = Doors.visitToggle(); 10 | 11 | System.out.println("Result: " + Arrays.toString(result)); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Chapter16/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | 8 | -------------------------------------------------------------------------------- /Chapter16/CancelThread/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | CancelThread 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | CancelThread 14 | -------------------------------------------------------------------------------- /Chapter16/Deadlock/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4.0.0 4 | coding.challenge 5 | Deadlock 6 | 1.0 7 | jar 8 | 9 | UTF-8 10 | 13 11 | 13 12 | 13 | Deadlock 14 | -------------------------------------------------------------------------------- /Chapter16/ExecutorAndExecutorService/src/main/java/coding/challenge/SimpleExecutor.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.concurrent.Executor; 4 | 5 | public class SimpleExecutor implements Executor { 6 | 7 | @Override 8 | public void execute(Runnable r) { 9 | (new Thread(r)).start(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Chapter16/ProducerConsumerQueue/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) throws InterruptedException { 6 | 7 | System.setProperty("java.util.logging.SimpleFormatter.format", 8 | "[%1$tT] [%4$-7s] %5$s %n"); 9 | 10 | ProducerConsumer.startProducerConsumer(); 11 | Thread.sleep(10 * 1000); 12 | ProducerConsumer.stopProducerConsumer(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter16/ProducerConsumerWaitNotify/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) throws InterruptedException { 6 | 7 | System.setProperty("java.util.logging.SimpleFormatter.format", 8 | "[%1$tT] [%4$-7s] %5$s %n"); 9 | 10 | ProducerConsumer.startProducerConsumer(); 11 | Thread.sleep(10 * 1000); 12 | ProducerConsumer.stopProducerConsumer(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Chapter16/README.md: -------------------------------------------------------------------------------- 1 | # Concurrency 2 | This chapter covers the most popular questions about Java concurrency (multithreading) that occur in general interviews involving the Java language. 3 | -------------------------------------------------------------------------------- /Chapter16/RunnableAndCallable/src/main/java/coding/challenge/Main.java: -------------------------------------------------------------------------------- 1 | package coding.challenge; 2 | 3 | import java.util.concurrent.ExecutionException; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) 8 | throws InterruptedException, ExecutionException { 9 | 10 | ExecuteTask et = new ExecuteTask(); 11 | 12 | System.out.println("Run the Callable example\n------------------------"); 13 | et.callableExample(); 14 | 15 | System.out.println("\n\nRun the Runnable example\n-----------------------"); 16 | et.runnableExample(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Chapter18/.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | dist/ 3 | nbproject/ 4 | target/ 5 | build.xml 6 | manifest.mf 7 | 8 | -------------------------------------------------------------------------------- /Chapter18/README.md: -------------------------------------------------------------------------------- 1 | # Unit testing 2 | This chapter talks about unit-testing interview problems that you may encounter if you apply for a position such as a developer or software engineer. Of course, if you are looking for a tester (manual/automation) position, then this chapter may represent just another perspective on testing. Therefore, do not expect to see questions here specific to manual/automation tester positions. 3 | -------------------------------------------------------------------------------- /Chapter18/junit4/Assumptions/src/test/java/coding/challenge/test/AssumptionsTest.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.test; 2 | 3 | import java.io.File; 4 | import static org.hamcrest.CoreMatchers.is; 5 | import static org.junit.Assert.assertThat; 6 | import static org.junit.Assume.assumeThat; 7 | import org.junit.Test; 8 | import org.junit.runner.RunWith; 9 | import org.junit.runners.JUnit4; 10 | 11 | @RunWith(JUnit4.class) 12 | public class AssumptionsTest { 13 | 14 | @Test 15 | public void givenFolderWhenGetAbsolutePathThenSuccess() { 16 | 17 | assumeThat(File.separatorChar, is('/')); 18 | assertThat(new File(".").getAbsolutePath(), is("C:/SBPBP/GitHub/Chapter18/junit4")); 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Chapter18/junit4/README.md: -------------------------------------------------------------------------------- 1 | Junit 4 examples 2 | -------------------------------------------------------------------------------- /Chapter18/junit4/TestSuite/src/test/java/coding/challenge/test/TestConnect.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.test; 2 | 3 | import java.util.logging.Logger; 4 | import org.junit.Test; 5 | import org.junit.runner.RunWith; 6 | import org.junit.runners.JUnit4; 7 | 8 | @RunWith(JUnit4.class) 9 | public class TestConnect { 10 | 11 | private static final Logger log = Logger.getLogger(TestConnect.class.getName()); 12 | 13 | @Test 14 | public void givenCredentialsWhenConnectThenSuccess() { 15 | log.info("Connection successfully complete ..."); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter18/junit4/TestSuite/src/test/java/coding/challenge/test/TestDisconnect.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.test; 2 | 3 | import java.util.logging.Logger; 4 | import org.junit.Test; 5 | import org.junit.runner.RunWith; 6 | import org.junit.runners.JUnit4; 7 | 8 | @RunWith(JUnit4.class) 9 | public class TestDisconnect { 10 | 11 | private static final Logger log = Logger.getLogger(TestDisconnect.class.getName()); 12 | 13 | @Test 14 | public void givenConnectionWhenDisconnectThenSuccess() { 15 | log.info("Disconnect successfully complete ..."); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter18/junit4/TestSuite/src/test/java/coding/challenge/test/TestHeartbeat.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.test; 2 | 3 | import java.util.logging.Logger; 4 | import org.junit.Test; 5 | import org.junit.runner.RunWith; 6 | import org.junit.runners.JUnit4; 7 | 8 | @RunWith(JUnit4.class) 9 | public class TestHeartbeat { 10 | 11 | private static final Logger log = Logger.getLogger(TestHeartbeat.class.getName()); 12 | 13 | @Test 14 | public void givenConnectionWhenHeartbeatThenSuccess() { 15 | log.info("Heartbeat successfully complete ..."); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter18/junit4/TestSuite/src/test/java/coding/challenge/test/TestSuite.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.test; 2 | 3 | import org.junit.runner.RunWith; 4 | import org.junit.runners.Suite; 5 | 6 | @RunWith(Suite.class) 7 | @Suite.SuiteClasses({ 8 | TestConnect.class, 9 | TestHeartbeat.class, 10 | TestDisconnect.class 11 | }) 12 | public class TestSuite { 13 | // this class was intentionally left empty 14 | } 15 | -------------------------------------------------------------------------------- /Chapter18/junit5/ArrangeActAssert/src/test/java/coding/challenge/test/AAATest.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.test; 2 | 3 | import java.util.stream.Stream; 4 | 5 | import static org.junit.jupiter.api.Assertions.assertEquals; 6 | import org.junit.jupiter.api.Test; 7 | import org.junit.platform.runner.JUnitPlatform; 8 | import org.junit.runner.RunWith; 9 | 10 | @RunWith(JUnitPlatform.class) 11 | public class AAATest { 12 | 13 | @Test 14 | public void givenStreamWhenSumThenEquals6() { 15 | 16 | // Arrange 17 | Stream theStream = Stream.of(1, 2, 3); 18 | 19 | // Act 20 | int sum = theStream.mapToInt(i -> i).sum(); 21 | 22 | // Assert 23 | assertEquals(6, sum); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /Chapter18/junit5/README.md: -------------------------------------------------------------------------------- 1 | JUnit 5 examples 2 | -------------------------------------------------------------------------------- /Chapter18/junit5/TestSuite/src/test/java/coding/challenge/connection/test/TestConnect.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.connection.test; 2 | 3 | import java.util.logging.Logger; 4 | import org.junit.jupiter.api.Test; 5 | import org.junit.platform.runner.JUnitPlatform; 6 | import org.junit.runner.RunWith; 7 | 8 | @RunWith(JUnitPlatform.class) 9 | public class TestConnect { 10 | 11 | private static final Logger log = Logger.getLogger(TestConnect.class.getName()); 12 | 13 | @Test 14 | public void givenCredentialsWhenConnectThenSuccess() { 15 | log.info("Connection successfully complete ..."); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter18/junit5/TestSuite/src/test/java/coding/challenge/connection/test/TestConnectionSuite.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.connection.test; 2 | 3 | import org.junit.platform.runner.JUnitPlatform; 4 | import org.junit.platform.suite.api.SelectClasses; 5 | import org.junit.platform.suite.api.SuiteDisplayName; 6 | import org.junit.runner.RunWith; 7 | 8 | @RunWith(JUnitPlatform.class) 9 | @SuiteDisplayName("TEST CONNECTION") 10 | @SelectClasses({ 11 | TestConnect.class, 12 | TestHeartbeat.class, 13 | TestDisconnect.class 14 | }) 15 | public class TestConnectionSuite { 16 | // this class was intentionally left empty 17 | } 18 | -------------------------------------------------------------------------------- /Chapter18/junit5/TestSuite/src/test/java/coding/challenge/connection/test/TestDisconnect.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.connection.test; 2 | 3 | import java.util.logging.Logger; 4 | import org.junit.jupiter.api.Test; 5 | import org.junit.platform.runner.JUnitPlatform; 6 | import org.junit.runner.RunWith; 7 | 8 | @RunWith(JUnitPlatform.class) 9 | public class TestDisconnect { 10 | 11 | private static final Logger log = Logger.getLogger(TestDisconnect.class.getName()); 12 | 13 | @Test 14 | public void givenConnectionWhenDisconnectThenSuccess() { 15 | log.info("Disconnect successfully complete ..."); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter18/junit5/TestSuite/src/test/java/coding/challenge/connection/test/TestHeartbeat.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.connection.test; 2 | 3 | import java.util.logging.Logger; 4 | import org.junit.jupiter.api.Test; 5 | import org.junit.platform.runner.JUnitPlatform; 6 | import org.junit.runner.RunWith; 7 | 8 | @RunWith(JUnitPlatform.class) 9 | public class TestHeartbeat { 10 | 11 | private static final Logger log = Logger.getLogger(TestHeartbeat.class.getName()); 12 | 13 | @Test 14 | public void givenConnectionWhenHeartbeatThenSuccess() { 15 | log.info("Heartbeat successfully complete ..."); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter18/junit5/TestSuite/src/test/java/coding/challenge/login/test/TestLogin.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.login.test; 2 | 3 | import java.util.logging.Logger; 4 | import org.junit.jupiter.api.Test; 5 | import org.junit.platform.runner.JUnitPlatform; 6 | import org.junit.runner.RunWith; 7 | 8 | @RunWith(JUnitPlatform.class) 9 | public class TestLogin { 10 | 11 | private static final Logger log = Logger.getLogger(TestLogin.class.getName()); 12 | 13 | @Test 14 | public void givenCredentialsWhenLoginThenSuccess() { 15 | log.info("Login successfully complete ..."); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Chapter18/junit5/TestSuite/src/test/java/coding/challenge/login/test/TestLoginSuite.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.login.test; 2 | 3 | import org.junit.platform.runner.JUnitPlatform; 4 | import org.junit.platform.suite.api.SelectPackages; 5 | import org.junit.platform.suite.api.SuiteDisplayName; 6 | import org.junit.runner.RunWith; 7 | 8 | @RunWith(JUnitPlatform.class) 9 | @SuiteDisplayName("TEST LOGIN AND CONNECTION") 10 | @SelectPackages({ 11 | "coding.challenge.connection.test", 12 | "coding.challenge.login.test" 13 | }) 14 | public class TestLoginSuite { 15 | // this class was intentionally left empty 16 | } 17 | -------------------------------------------------------------------------------- /Chapter18/junit5/TestSuite/src/test/java/coding/challenge/login/test/TestLogout.java: -------------------------------------------------------------------------------- 1 | package coding.challenge.login.test; 2 | 3 | import java.util.logging.Logger; 4 | import org.junit.jupiter.api.Test; 5 | import org.junit.platform.runner.JUnitPlatform; 6 | import org.junit.runner.RunWith; 7 | 8 | @RunWith(JUnitPlatform.class) 9 | public class TestLogout { 10 | 11 | private static final Logger log = Logger.getLogger(TestLogout.class.getName()); 12 | 13 | @Test 14 | public void givenCredentialsWhenLogoutThenSuccess() { 15 | log.info("Logout successfully complete ..."); 16 | } 17 | } 18 | --------------------------------------------------------------------------------