Repository: neemiassgc/CodeSignal-Solutions Branch: master Commit: 8e67ac2dc9ca Files: 550 Total size: 187.2 KB Directory structure: gitextract_u9jox9z0/ ├── .gitignore ├── Arcade/ │ ├── Databases/ │ │ ├── alarmClocks.sql │ │ ├── automaticNotifications.sql │ │ ├── battleshipGameResults.sql │ │ ├── booksCatalogs.sql │ │ ├── bugsInComponent.sql │ │ ├── checkExpenditure.sql │ │ ├── closestCells.sql │ │ ├── combinationLock.sql │ │ ├── companyEmployees.sql │ │ ├── consecutiveIds.sql │ │ ├── contestLeaderboard.sql │ │ ├── correctIPs.sql │ │ ├── countriesInfo.sql │ │ ├── countriesSelection.sql │ │ ├── coursesDistribution.sql │ │ ├── currencyCodes.sql │ │ ├── customerMessages.sql │ │ ├── dancingCompetition.sql │ │ ├── dateFormatting.sql │ │ ├── driversInfo.sql │ │ ├── emptyDepartments.sql │ │ ├── expressionsVerification.sql │ │ ├── filmLibrary.sql │ │ ├── findTable.sql │ │ ├── freeSeats.sql │ │ ├── giftPackaging.sql │ │ ├── gradeDistribution.sql │ │ ├── habitatArea.sql │ │ ├── holidayEvent.sql │ │ ├── hostnamesOrdering.sql │ │ ├── importantEvents.sql │ │ ├── interestClub.sql │ │ ├── itemCounts.sql │ │ ├── legsCount.sql │ │ ├── localCalendar.sql │ │ ├── marketReport.sql │ │ ├── mischievousNephews.sql │ │ ├── monthlyScholarships.sql │ │ ├── mostExpensive.sql │ │ ├── movieDirectors.sql │ │ ├── netIncome.sql │ │ ├── newsSubscribers.sql │ │ ├── nicknames.sql │ │ ├── nullIntern.sql │ │ ├── officeBranches.sql │ │ ├── orderAnalytics.sql │ │ ├── orderOfSuccession.sql │ │ ├── orderPrices.sql │ │ ├── orderingEmails.sql │ │ ├── pastEvents.sql │ │ ├── personalHobbies.sql │ │ ├── placesOfInterest.sql │ │ ├── placesOfInterestPairs.sql │ │ ├── projectList.sql │ │ ├── projectsTeam.sql │ │ ├── queriesExecution.sql │ │ ├── recentHires.sql │ │ ├── restaurantInfo.sql │ │ ├── routeLength.sql │ │ ├── salaryDifference.sql │ │ ├── scholarshipsDistribution.sql │ │ ├── securityBreach.sql │ │ ├── soccerGamesSeries.sql │ │ ├── soccerPlayers.sql │ │ ├── sortBook.sql │ │ ├── storageOptimization.sql │ │ ├── stringsStatistics.sql │ │ ├── studentsInClubs.sql │ │ ├── sunnyHolidays.sql │ │ ├── suspectsInvestigation.sql │ │ ├── suspectsInvestigation2.sql │ │ ├── tableSecurity.sql │ │ ├── testCheck.sql │ │ ├── tictactoeTournament.sql │ │ ├── top5AverageGrade.sql │ │ ├── trackingSystem.sql │ │ ├── travelDiary.sql │ │ ├── typeInheritance.sql │ │ ├── unluckyEmployees.sql │ │ ├── userCountries.sql │ │ ├── usersByContinent.sql │ │ ├── validPhoneNumbers.sql │ │ ├── volleyballResults.sql │ │ └── websiteHacking.sql │ ├── Intro/ │ │ ├── Java/ │ │ │ ├── AbsoluteValuesSumMinimization.java │ │ │ ├── Add.java │ │ │ ├── AddBorder.java │ │ │ ├── AdjacentElementsProduct.java │ │ │ ├── AllLongestStrings.java │ │ │ ├── AlmostIncreasingSequence.java │ │ │ ├── AlphabeticShift.java │ │ │ ├── AlternatingSums.java │ │ │ ├── AreEquallyStrong.java │ │ │ ├── AreSimilar.java │ │ │ ├── ArrayChange.java │ │ │ ├── ArrayMaxConsecutiveSum.java │ │ │ ├── ArrayMaximalAdjacentDifference.java │ │ │ ├── ArrayReplace.java │ │ │ ├── AvoidObstacles.java │ │ │ ├── BishopAndPawn.java │ │ │ ├── BoxBlur.java │ │ │ ├── BuildPalindrome.java │ │ │ ├── CenturyFromYear.java │ │ │ ├── CheckPalindrome.java │ │ │ ├── ChessBoardCellColor.java │ │ │ ├── ChessKnight.java │ │ │ ├── CircleOfNumbers.java │ │ │ ├── CommonCharacterCount.java │ │ │ ├── DeleteDigit.java │ │ │ ├── DepositProfit.java │ │ │ ├── DifferentSquares.java │ │ │ ├── DifferentSymbolsNaive.java │ │ │ ├── DigitDegree.java │ │ │ ├── DigitsProduct.java │ │ │ ├── ElectionsWinners.java │ │ │ ├── EvenDigitsOnly.java │ │ │ ├── ExtractEachKth.java │ │ │ ├── FileNaming.java │ │ │ ├── FindEmailDomain.java │ │ │ ├── FirstDigit.java │ │ │ ├── GrowingPlant.java │ │ │ ├── IsBeautifulString.java │ │ │ ├── IsDigit.java │ │ │ ├── IsIPv4Address.java │ │ │ ├── IsLucky.java │ │ │ ├── IsMAC48Adress.java │ │ │ ├── KnapsackLight.java │ │ │ ├── LineEnconding.java │ │ │ ├── LongestDigitsPrefix.java │ │ │ ├── LongestWord.java │ │ │ ├── MakeArrayConsecutive2.java │ │ │ ├── MatrixElementsSum.java │ │ │ ├── MessageFromBinaryCode.java │ │ │ ├── Minesweeper.java │ │ │ ├── PalindromeRearranging.java │ │ │ ├── RemoveKFromList.java │ │ │ ├── ReverseInParentheses.java │ │ │ ├── ShapeArea.java │ │ │ ├── SortByHeight.java │ │ │ ├── SpiralNumbers.java │ │ │ ├── StringsRearrangement.java │ │ │ ├── Sudoku.java │ │ │ ├── SumUpNumbers.java │ │ │ ├── ValidTime.java │ │ │ └── VariableName.java │ │ ├── Python/ │ │ │ └── stringsRearrangement.py │ │ ├── Ruby/ │ │ │ ├── absoluteValuesSumMinimization.rb │ │ │ ├── add.rb │ │ │ ├── addBorder.rb │ │ │ ├── adjacentElementsProduct.rb │ │ │ ├── allLongestStrings.rb │ │ │ ├── almostIncreasingSequence.rb │ │ │ ├── alphabeticShift.rb │ │ │ ├── alternatingSums.rb │ │ │ ├── areEquallyStrong.rb │ │ │ ├── areSimilar.rb │ │ │ ├── arrayChange.rb │ │ │ ├── arrayMaxConsecutiveSum.rb │ │ │ ├── arrayMaximalAdjacentDifference.rb │ │ │ ├── arrayReplace.rb │ │ │ ├── avoidObstacles.rb │ │ │ ├── bishopAndPawn.rb │ │ │ ├── boxBlur.rb │ │ │ ├── buildPalindrome.rb │ │ │ ├── centuryFromYear.rb │ │ │ ├── checkPalindrome.rb │ │ │ ├── chessBoardCellColor.rb │ │ │ ├── chessKnight.rb │ │ │ ├── circleOfNumbers.rb │ │ │ ├── commonCharacterCount.rb │ │ │ ├── deleteDigit.rb │ │ │ ├── depositProfit.rb │ │ │ ├── differentSquares.rb │ │ │ ├── differentSymbolsNaive.rb │ │ │ ├── digitDegree.rb │ │ │ ├── digitsProduct.rb │ │ │ ├── electionsWinners.rb │ │ │ ├── evenDigitsOnly.rb │ │ │ ├── extractEachKth.rb │ │ │ ├── fileNaming.rb │ │ │ ├── findEmailDomain.rb │ │ │ ├── firstDigit.rb │ │ │ ├── growingPlant.rb │ │ │ ├── isBeautifulString.rb │ │ │ ├── isDigit.rb │ │ │ ├── isIPv4Address.rb │ │ │ ├── isLuck.rb │ │ │ ├── isMAC48Address.rb │ │ │ ├── isPowerOfTwo2.rb │ │ │ ├── knapsackLight.rb │ │ │ ├── lineEncoding.rb │ │ │ ├── longestDigitsPrefix.rb │ │ │ ├── longestWord.rb │ │ │ ├── makeArrayConsecutive2.rb │ │ │ ├── matrixElementsSum.rb │ │ │ ├── messageFromBinaryCode.rb │ │ │ ├── palindromeRearranging.rb │ │ │ ├── reverseInParentheses.rb │ │ │ ├── shapeArea.rb │ │ │ ├── sortByHeight.rb │ │ │ ├── sudoku.rb │ │ │ ├── sumUpNumbers.rb │ │ │ ├── validTime.rb │ │ │ └── variableName.rb │ │ └── javascript/ │ │ ├── absoluteValuesSumMinimization.js │ │ ├── addBorder.js │ │ ├── adjacentElementsProduct.js │ │ ├── allLongestStrings.js │ │ ├── almostIncreasingSequence.js │ │ ├── alphabeticShift.js │ │ ├── alternatingSums.js │ │ ├── areEquallyStrong.js │ │ ├── areSimilar.js │ │ ├── arrayChange.js │ │ ├── arrayMaxConsecutiveSum.js │ │ ├── arrayMaximalAdjacentDifference.js │ │ ├── arrayReplace.js │ │ ├── avoidObstacles.js │ │ ├── bishopAndPawn.js │ │ ├── boxBlur.js │ │ ├── buildPalindrome.js │ │ ├── centuryFromYear.js │ │ ├── checkPalindrome.js │ │ ├── chessBoardCellColo.js │ │ ├── chessKnight.js │ │ ├── circleOfNumbers.js │ │ ├── commonCharacterCount.js │ │ ├── deleteDigit.js │ │ ├── depositProfit.js │ │ ├── differentSquares.js │ │ ├── differentSymbolsNaive.js │ │ ├── digitDegree.js │ │ ├── digitsProduct.js │ │ ├── electionsWinners.js │ │ ├── evenDigitsOnly.js │ │ ├── extractEachKth.js │ │ ├── fileNaming.js │ │ ├── findEmailDomain.js │ │ ├── firstDigit.js │ │ ├── isBeautifulString.js │ │ ├── isDigit.js │ │ ├── isIPv4Address.js │ │ ├── isLucky.js │ │ ├── isMAC48Address.js │ │ ├── knapsackLight.js │ │ ├── lineEncoding.js │ │ ├── longestDigitsPrefix.js │ │ ├── longestWord.js │ │ ├── makeArrayConsecutive2.js │ │ ├── matrixElementsSum.js │ │ ├── messageFromBinaryCode.js │ │ ├── minesweeper.js │ │ ├── palindromeRearranging.js │ │ ├── reverseInParentheses.js │ │ ├── shapeArea.js │ │ ├── sortByHeight.js │ │ ├── spiralNumbers.js │ │ ├── sudoku.js │ │ ├── sumUpNumbers.js │ │ ├── validTime.js │ │ └── variableName.js │ └── TheCore/ │ ├── C++/ │ │ ├── differentRightmostBit.cpp │ │ ├── equalPairOfBits.cpp │ │ ├── killKthBit.cpp │ │ ├── secondRightmostZeroBit.cpp │ │ └── swapAdjacentBits.cpp │ ├── Java/ │ │ ├── AddTwoDigits.java │ │ ├── AdditionWithoutCarrying.java │ │ ├── AppleBoxes.java │ │ ├── ArithmeticExpression.java │ │ ├── ArrayPacking.java │ │ ├── ArrayReplace.java │ │ ├── Candies.java │ │ ├── Candles.java │ │ ├── CircleOfNumbers.java │ │ ├── ComfortableNumbers.java │ │ ├── ConcatenateArrays.java │ │ ├── CountBlackCells.java │ │ ├── CountSumOfTwoRepresentations2.java │ │ ├── CreateArray.java │ │ ├── ExtraNumber.java │ │ ├── FirstReverseTry.java │ │ ├── IncreaseNumberRoundness.java │ │ ├── IsInfiniteProcess.java │ │ ├── IsPower.java │ │ ├── IsSmooth.java │ │ ├── IsSumOfConsecutive2.java │ │ ├── KnapsackLight.java │ │ ├── LargestNumber.java │ │ ├── LateRide.java │ │ ├── LeastFactorial.java │ │ ├── LineUp.java │ │ ├── MagicalWell.java │ │ ├── MakeArrayConsecutive2.java │ │ ├── MaxMultiple.java │ │ ├── MetroCard.java │ │ ├── MirrorBits.java │ │ ├── PagesNumberingWithInk.java │ │ ├── PhoneCall.java │ │ ├── RangeBitCount.java │ │ ├── ReachNextLevel.java │ │ ├── RectangleRotation.java │ │ ├── RemoveArrayPart.java │ │ ├── ReplaceMiddle.java │ │ ├── Rounders.java │ │ ├── SeatsInTheater.java │ │ ├── SquareDigitsSequence.java │ │ ├── TennisSet.java │ │ ├── WeakNumbers.java │ │ └── WillYou.java │ ├── Javascript/ │ │ ├── addTwoDigits.js │ │ ├── additionWithoutCarrying.js │ │ ├── appleBoxes.js │ │ ├── arithmeticExpression.js │ │ ├── arrayPacking.js │ │ ├── arrayReplace.js │ │ ├── candies.js │ │ ├── candles.js │ │ ├── circleOfNumbers.js │ │ ├── comfortableNumbers.js │ │ ├── concatenateArrays.js │ │ ├── countBlackCells.js │ │ ├── countSumOfTwoRepresentations2.js │ │ ├── createArray.js │ │ ├── differentRightmostBit.js │ │ ├── extraNumber.js │ │ ├── firstReverseTry.js │ │ ├── increaseNumberRoundness.js │ │ ├── isInfiniteProcess.js │ │ ├── isPower.js │ │ ├── isSmooth.js │ │ ├── isSumOfConsecutive2.js │ │ ├── knapsackLight.js │ │ ├── largestNumber.js │ │ ├── lateRide.js │ │ ├── leastFactorial.js │ │ ├── lineUp.js │ │ ├── magicalWell.js │ │ ├── makeArrayConsecutive2.js │ │ ├── maxMultiple.js │ │ ├── metroCard.js │ │ ├── mirrorBits.js │ │ ├── pagesNumberingWithInk.js │ │ ├── phoneCall.js │ │ ├── rangeBitCount.js │ │ ├── reachNextLevel.js │ │ ├── rectangleRotation.js │ │ ├── removeArrayPart.js │ │ ├── replaceMiddle.js │ │ ├── rounders.js │ │ ├── seatsInTheater.js │ │ ├── squareDigitsSequence.js │ │ ├── tennisSet.js │ │ ├── weakNumbers.js │ │ └── willYou.js │ └── Kotlin/ │ ├── addTwoDigits.kt │ ├── additionWithoutCarrying.kt │ ├── appleBoxes.kt │ ├── arithmeticExpression.kt │ ├── arrayPacking.kt │ ├── arrayReplace.kt │ ├── candies.kt │ ├── candles.kt │ ├── circleOfNumbers.kt │ ├── comfortableNumbers.kt │ ├── concatenateArrays.kt │ ├── countBlackCells.kt │ ├── countSumOfTwoRepresentations2.kt │ ├── createArray.kt │ ├── extraNumber.kt │ ├── firstReverseTry.kt │ ├── increaseNumberRoundness.kt │ ├── isInfiniteProcess.kt │ ├── isPower.kt │ ├── isSmooth.kt │ ├── isSumOfConsecutive2.kt │ ├── knapsackLight.kt │ ├── largestNumber.kt │ ├── lateRide.kt │ ├── leastFactorial.kt │ ├── lineUp.kt │ ├── magicalWell.kt │ ├── makeArrayConsecutive2.kt │ ├── maxMultiple.kt │ ├── metroCard.kt │ ├── mirrorBits.kt │ ├── pagesNumberingWithInk.kt │ ├── phoneCall.kt │ ├── rangeBitCount.kt │ ├── reachNextLevel.kt │ ├── rectangleRotation.kt │ ├── removeArrayPart.kt │ ├── replaceMiddle.kt │ ├── rounders.kt │ ├── seatsInTheater.kt │ ├── squareDigitsSequence.kt │ ├── tennisSet.kt │ ├── weakNumbers.kt │ └── willYou.kt ├── Challenges/ │ ├── Java/ │ │ ├── AddTwoDigits.java │ │ ├── AddTwoHugeNumbers.java │ │ ├── AdditionWithoutCarrying.java │ │ ├── AmendTheSentence.java │ │ ├── Bomber.java │ │ ├── CampusCup.java │ │ ├── CatalogUpdate.java │ │ ├── CharacterParity.java │ │ ├── ChristmasTree.java │ │ ├── ClassifyStrings.java │ │ ├── ClosestInTree.java │ │ ├── CommonCharacterCount2.java │ │ ├── CompanyBotStrategy.java │ │ ├── ComposeRanges.java │ │ ├── ContainsCloseNums.java │ │ ├── ContainsDuplicates.java │ │ ├── CorrectNonogram.java │ │ ├── CountClouds.java │ │ ├── DayOfWeek.java │ │ ├── DomainType.java │ │ ├── DrawRectangle.java │ │ ├── EquilibriumPoint.java │ │ ├── ExcelSheetColumnNumber.java │ │ ├── FancyRide.java │ │ ├── FareEstimator.java │ │ ├── FileNaming.java │ │ ├── FindMiddleElement.java │ │ ├── FindSubarrayBySum.java │ │ ├── FractionReducing.java │ │ ├── GiftSafety.java │ │ ├── HappyNumber.java │ │ ├── HigherVersion2.java │ │ ├── InsertBits.java │ │ ├── IsListPalindrome.java │ │ ├── IsPowerOfTwo2.java │ │ ├── JumpingJimmy.java │ │ ├── KthLargestElement.java │ │ ├── LongestCommonSubstring.java │ │ ├── Lrc2subRip.java │ │ ├── LunchSequenceChecker.java │ │ ├── MaximumSum.java │ │ ├── MergeTwoLinkedLists.java │ │ ├── MirrorBits.java │ │ ├── MissingNumber.java │ │ ├── NewRoadSystem.java │ │ ├── NextLarger.java │ │ ├── NthElementFromTheEnd.java │ │ ├── PairsSum.java │ │ ├── PolygonPerimeter.java │ │ ├── PrimesSum2.java │ │ ├── ProCategorization.java │ │ ├── RangeBitCount.java │ │ ├── RemoveArrayPart.java │ │ ├── RemoveDuplicateStrings.java │ │ ├── ReverseInteger.java │ │ ├── ReverseLinkedList.java │ │ ├── ReverseSentence.java │ │ ├── ReverseVowelsOfString.java │ │ ├── RotateImage.java │ │ ├── ShoppingCart.java │ │ ├── ShoppingList.java │ │ ├── ShuffledArray.java │ │ ├── SortByString.java │ │ ├── SortedSquareArray.java │ │ ├── Sudoku2.java │ │ ├── SugarHigh.java │ │ ├── SumOfTwo.java │ │ ├── SwitchLights.java │ │ ├── TriangleExistence.java │ │ ├── TwoArraysNthElement.java │ │ └── Zigzag.java │ ├── Javascript/ │ │ ├── amendTheSentence.js │ │ ├── characterParity.js │ │ ├── climbingStaircase.js │ │ ├── commonCharacterCount2.js │ │ ├── companyBotStrategy.js │ │ ├── containsCloseNums.js │ │ ├── containsDuplicates.js │ │ ├── domainType.js │ │ ├── fancyRide.js │ │ ├── fareEstimator.js │ │ ├── fileNaming.js │ │ ├── findMiddleElement.js │ │ ├── findSubarrayBySum.js │ │ ├── happyNumber.js │ │ ├── isListPalindrome.js │ │ ├── isMAC48Address.js │ │ ├── launchSequenceChecker.js │ │ ├── maximumSum.js │ │ ├── mirrorBits.js │ │ ├── missingNumber.js │ │ ├── nextLarger.js │ │ ├── pairsSum.js │ │ ├── polygonPerimeter.js │ │ ├── rangeBitCount.js │ │ ├── removeArrayPart.js │ │ ├── reverseSentence.js │ │ ├── reverseVowelsOfString.js │ │ ├── rotateImage.js │ │ ├── sortByString.js │ │ ├── sortedSquaredArray.js │ │ └── switchLights.js │ ├── Kotlin/ │ │ └── companyBotStrategy.kt │ ├── Python/ │ │ ├── concatenateArrays.py │ │ └── reverseSentence.py │ └── Ruby/ │ ├── addTwoDigits.rb │ ├── classifyStrings.rb │ ├── containsDuplicates.rb │ ├── excelSheetColumnNumber.rb │ ├── fractionReducing.rb │ ├── giftSafety.rb │ ├── groupsOfAnagrams.rb │ ├── higherVersion2.rb │ ├── isCryptSolution.rb │ ├── kthLargestElement.rb │ ├── newRoadSystem.rb │ ├── nthElementFromTheEnd.rb │ ├── removeDuplicateStrings.rb │ ├── reverseInteger.rb │ ├── rowsRearranging.rb │ ├── shuffledArray.rb │ ├── triangleExistence.rb │ └── twoArraysNthElement.rb ├── InterviewPratice/ │ ├── Java/ │ │ ├── AddTwoHugeNumbers.java │ │ ├── AmendTheSentence.java │ │ ├── ClassifyStrings.java │ │ ├── FirstDuplicate.java │ │ ├── FirstNotRepeatingCharacter.java │ │ ├── GroupingDishes.java │ │ ├── IsCryptSolution.java │ │ ├── IsListPalindrome.java │ │ ├── MergeTwoLinkedLists.java │ │ ├── RearrangeLastN.java │ │ ├── RemoveKFromList.java │ │ ├── ReverseNodeInKGroups.java │ │ ├── RotateImage.java │ │ ├── Strstr.java │ │ └── Sudoku2.java │ ├── Javascript/ │ │ ├── firstDuplicate.js │ │ ├── firstNotRepeatingCharacter.js │ │ ├── groupingDishes.js │ │ ├── isCryptSolution.js │ │ ├── mergeTwoLinkedLists.js │ │ ├── rotateImage.js │ │ └── sudoku2.js │ ├── Ruby/ │ │ ├── firstDuplicate.rb │ │ └── firstNotRepeatingCharacter.rb │ └── runlength_encoding.java ├── LICENSE └── README.md ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ # Created by https://www.toptal.com/developers/gitignore/api/java,kotlin,node,c++,text,images,diskimage,sublimetext # Edit at https://www.toptal.com/developers/gitignore?templates=java,kotlin,node,c++,text,images,diskimage,sublimetext ### C++ ### # Prerequisites *.d # Compiled Object files *.slo *.lo *.o *.obj # Precompiled Headers *.gch *.pch # Linker files *.ilk # Debugger Files *.pdb # Compiled Dynamic libraries *.so *.dylib *.dll # Fortran module files *.mod *.smod # Compiled Static libraries *.lai *.la *.a *.lib # Executables *.exe *.out *.app ### DiskImage ### *.dmg *.iso *.toast *.vcd ### Images ### # JPEG *.jpg *.jpeg *.jpe *.jif *.jfif *.jfi # JPEG 2000 *.jp2 *.j2k *.jpf *.jpx *.jpm *.mj2 # JPEG XR *.jxr *.hdp *.wdp # Graphics Interchange Format *.gif # RAW *.raw # Web P *.webp # Portable Network Graphics *.png # Animated Portable Network Graphics *.apng # Multiple-image Network Graphics *.mng # Tagged Image File Format *.tiff *.tif # Scalable Vector Graphics *.svg *.svgz # Portable Document Format *.pdf # X BitMap *.xbm # BMP *.bmp *.dib # ICO *.ico # 3D Images *.3dm *.max ### Java ### # Compiled class file *.class # Log file *.log # BlueJ files *.ctxt # Mobile Tools for Java (J2ME) .mtj.tmp/ # Package Files # *.jar *.war *.nar *.ear *.zip *.tar.gz *.rar # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* ### Kotlin ### # Compiled class file # Log file # BlueJ files # Mobile Tools for Java (J2ME) # Package Files # # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml ### Node ### # Logs logs npm-debug.log* yarn-debug.log* yarn-error.log* lerna-debug.log* # Diagnostic reports (https://nodejs.org/api/report.html) report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json # Runtime data pids *.pid *.seed *.pid.lock # Directory for instrumented libs generated by jscoverage/JSCover lib-cov # Coverage directory used by tools like istanbul coverage *.lcov # nyc test coverage .nyc_output # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) .grunt # Bower dependency directory (https://bower.io/) bower_components # node-waf configuration .lock-wscript # Compiled binary addons (https://nodejs.org/api/addons.html) build/Release # Dependency directories node_modules/ jspm_packages/ # TypeScript v1 declaration files typings/ # TypeScript cache *.tsbuildinfo # Optional npm cache directory .npm # Optional eslint cache .eslintcache # Optional stylelint cache .stylelintcache # Microbundle cache .rpt2_cache/ .rts2_cache_cjs/ .rts2_cache_es/ .rts2_cache_umd/ # Optional REPL history .node_repl_history # Output of 'npm pack' *.tgz # Yarn Integrity file .yarn-integrity # dotenv environment variables file .env .env.test .env*.local # parcel-bundler cache (https://parceljs.org/) .cache .parcel-cache # Next.js build output .next # Nuxt.js build / generate output .nuxt dist # Storybook build outputs .out .storybook-out storybook-static # rollup.js default build output dist/ # Gatsby files .cache/ # Comment in the public line in if your project uses Gatsby and not Next.js # https://nextjs.org/blog/next-9-1#public-directory-support # public # vuepress build output .vuepress/dist # Serverless directories .serverless/ # FuseBox cache .fusebox/ # DynamoDB Local files .dynamodb/ # TernJS port file .tern-port # Stores VSCode versions used for testing VSCode extensions .vscode-test # Temporary folders tmp/ temp/ ### SublimeText ### # Cache files for Sublime Text *.tmlanguage.cache *.tmPreferences.cache *.stTheme.cache # Workspace files are user-specific *.sublime-workspace # Project files should be checked into the repository, unless a significant # proportion of contributors will probably not be using Sublime Text # *.sublime-project # SFTP configuration file sftp-config.json # Package control specific files Package Control.last-run Package Control.ca-list Package Control.ca-bundle Package Control.system-ca-bundle Package Control.cache/ Package Control.ca-certs/ Package Control.merged-ca-bundle Package Control.user-ca-bundle oscrypto-ca-bundle.crt bh_unicode_properties.cache # Sublime-github package stores a github token in this file # https://packagecontrol.io/packages/sublime-github GitHub.sublime-settings ### Text ### *.doc *.docx *.msg *.pages *.rtf *.txt *.wpd *.wps # End of https://www.toptal.com/developers/gitignore/api/java,kotlin,node,c++,text,images,diskimage,sublimetext ================================================ FILE: Arcade/Databases/alarmClocks.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE alarmClocks() BEGIN SET @currentDate := (SELECT * FROM userInput); SET @endDate = CONCAT(YEAR(@currentDate), "-12-31 ", "23:59:59"); WHILE DATE_ADD(@currentDate, INTERVAL 7 DAY) <= @endDate DO SET @currentDate := DATE_ADD(@currentDate, INTERVAL 7 DAY); INSERT INTO userInput (input_date) VALUES (@currentDate); END WHILE; SELECT input_date AS alarm_date FROM userInput ORDER BY alarm_date ASC; END ================================================ FILE: Arcade/Databases/automaticNotifications.sql ================================================ CREATE PROCEDURE automaticNotifications() SELECT email FROM users WHERE role NOT IN ("admin", "premium") ORDER BY email; ================================================ FILE: Arcade/Databases/battleshipGameResults.sql ================================================ CREATE PROCEDURE battleshipGameResults() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ WITH base AS ( SELECT l.id, ABS( (l.upper_left_x + l.upper_left_y) - (l.bottom_right_x + l.bottom_right_y) ) + 1 AS size, ( SELECT COUNT(*) FROM opponents_shots WHERE ( target_x >= l.upper_left_x AND target_x <= l.bottom_right_x ) AND ( target_y >= l.upper_left_y AND target_y <= l.bottom_right_y ) ) AS damage FROM locations_of_ships AS l ) SELECT DISTINCT b.size, ( SELECT COUNT(*) FROM base WHERE size = b.size AND damage = 0 ) AS undamaged, ( SELECT COUNT(*) FROM base WHERE size = b.size AND damage > 0 AND damage < size ) AS partly_damaged, ( SELECT COUNT(*) FROM base WHERE size = b.size AND damage = size ) AS sunk FROM base AS b ORDER BY size; END ================================================ FILE: Arcade/Databases/booksCatalogs.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE booksCatalogs() BEGIN SELECT DISTINCT SUBSTRING_INDEX(ExtractValue(xml_doc, "//author"), " ", 2) AS author FROM catalogs ORDER BY author; END ================================================ FILE: Arcade/Databases/bugsInComponent.sql ================================================ CREATE PROCEDURE bugsInComponent() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ SELECT b.title AS bug_title, c.title AS component_title, ( SELECT COUNT(*) FROM BugComponent WHERE component_id = c.id ) AS bugs_in_component FROM Bug as b JOIN BugComponent AS bc ON b.num = bc.bug_num JOIN Component AS c ON bc.component_id = c.id WHERE b.num IN ( SELECT bug_num FROM BugComponent GROUP BY bug_num HAVING COUNT(*) > 1 ) ORDER BY bugs_in_component DESC, c.id, b.num; END ================================================ FILE: Arcade/Databases/checkExpenditure.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE checkExpenditure() BEGIN SELECT ae.id AS id, IF(SUM(ep.expenditure_sum) < ae.value, 0, SUM(ep.expenditure_sum) - ae.value) AS loss FROM expenditure_plan AS ep, allowable_expenditure AS ae WHERE WEEK(monday_date) BETWEEN ae.left_bound AND ae.right_bound GROUP BY ae.id; END ================================================ FILE: Arcade/Databases/closestCells.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE closestCells() BEGIN SELECT l.id AS id1, (SELECT id FROM positions r WHERE l.id != r.id ORDER BY ST_Distance(point(l.x, l.y), point(r.x, r.y)) limit 1 ) id2 FROM positions l; END ================================================ FILE: Arcade/Databases/combinationLock.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE combinationLock() BEGIN SELECT ROUND(EXP(SUM(LOG(LENGTH(characters))))) AS combinations FROM discs; END ================================================ FILE: Arcade/Databases/companyEmployees.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE companyEmployees() BEGIN SELECT dep_name, emp_name FROM departments, employees ORDER BY dep_name, emp_name; END ================================================ FILE: Arcade/Databases/consecutiveIds.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE consecutiveIds() BEGIN SET @uid := 0; SELECT id AS oldId, (@uid := @uid + 1) AS newId FROM itemIds ORDER BY oldId; END ================================================ FILE: Arcade/Databases/contestLeaderboard.sql ================================================ CREATE PROCEDURE contestLeaderboard() BEGIN SELECT name FROM leaderboard ORDER BY score DESC LIMIT 3, 5; END ================================================ FILE: Arcade/Databases/correctIPs.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE correctIPs() BEGIN SELECT id, ip FROM ips WHERE ip REGEXP "(\\d{2}\\.\\d+)$|(\\.\\d{2})$" AND IS_IPV4(ip) ORDER BY id; END ================================================ FILE: Arcade/Databases/countriesInfo.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE countriesInfo() BEGIN SELECT COUNT(*) AS number, AVG(population) AS average, SUM(population) AS total FROM countries; END ================================================ FILE: Arcade/Databases/countriesSelection.sql ================================================ CREATE PROCEDURE countriesSelection() BEGIN SELECT * FROM countries WHERE continent = "Africa" ORDER BY name ASC; END ================================================ FILE: Arcade/Databases/coursesDistribution.sql ================================================ CREATE PROCEDURE coursesDistribution() BEGIN ALTER TABLE groupcourses ADD FOREIGN KEY (course_id) REFERENCES courses(id) ON DELETE CASCADE; ALTER TABLE groupexams ADD FOREIGN KEY (course_id) REFERENCES courses(id) ON DELETE CASCADE; DELETE FROM courses WHERE name LIKE '%-toremove'; SELECT group_id, course_id FROM groupcourses UNION SELECT group_id, course_id FROM groupexams ORDER BY group_id, course_id; END ================================================ FILE: Arcade/Databases/currencyCodes.sql ================================================ CREATE PROCEDURE currencyCodes() BEGIN DELETE FROM currencies WHERE LENGTH(code) != 3; SELECT * FROM currencies ORDER BY code; END ================================================ FILE: Arcade/Databases/customerMessages.sql ================================================ DROP FUNCTION IF EXISTS response; CREATE FUNCTION response(name VARCHAR(40)) RETURNS VARCHAR(200) DETERMINISTIC BEGIN RETURN CONCAT("Dear ", CONCAT( REGEXP_REPLACE(LOWER(SUBSTRING_INDEX(name, " ", 1)), ".", UPPER(SUBSTR(SUBSTRING_INDEX(name, " ", 1), 1, 1)), 1, 1), " ", REGEXP_REPLACE(LOWER(SUBSTRING_INDEX(name, " ", -1)), ".", UPPER(SUBSTR(SUBSTRING_INDEX(name, " ", -1), 1, 1)), 1, 1)), "! We received your message and will ", "process it as soon as possible. Thanks for ", "using our service. FooBar On! - FooBarIO team."); END; CREATE PROCEDURE customerMessages() BEGIN SELECT id, name, response(name) AS response FROM customers; END; ================================================ FILE: Arcade/Databases/dancingCompetition.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE dancingCompetition() BEGIN SELECT it.arbiter_id, it.first_criterion, it.second_criterion, it.third_criterion FROM ( SELECT *, IF( first_criterion = (SELECT MAX(first_criterion) FROM scores) OR first_criterion = (SELECT MIN(first_criterion) FROM scores), 1, 0 ) + IF( second_criterion = (SELECT MAX(second_criterion) FROM scores) OR second_criterion = (SELECT MIN(second_criterion) FROM scores), 1, 0 ) + IF( third_criterion = (SELECT MAX(third_criterion) FROM scores) OR third_criterion = (SELECT MIN(third_criterion) FROM scores), 1, 0 ) AS filter FROM scores GROUP BY arbiter_id ) AS it WHERE it.filter <= 1; END ================================================ FILE: Arcade/Databases/dateFormatting.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE dateFormatting() BEGIN SELECT DATE_FORMAT(date_str, "%Y-%m-%d") AS date_iso FROM documents ORDER BY id; END ================================================ FILE: Arcade/Databases/driversInfo.sql ================================================ CREATE PROCEDURE driversInfo() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ DROP TABLE IF EXISTS names; CREATE TABLE names ( id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(100) ); DROP TABLE IF EXISTS summary; CREATE TABLE summary ( value VARCHAR(255) ); INSERT INTO names (name) SELECT DISTINCT driver_name FROM inspections ORDER BY driver_name; INSERT INTO summary (value) SELECT CONCAT( ' Total miles driven by all drivers combined: ', SUM(miles_logged)) FROM inspections; SET @id := 1; WHILE (SELECT COUNT(*) FROM names WHERE id = @id) = 1 DO INSERT INTO summary (value) SELECT CONCAT( ' Name: ', driver_name, '; number of inspections: ', COUNT(driver_name), '; miles driven: ', SUM(miles_logged) ) FROM inspections WHERE driver_name = (SELECT name FROM names WHERE id = @id); INSERT INTO summary (value) SELECT CONCAT( ' date: ', date, '; miles covered: ', miles_logged ) FROM inspections WHERE driver_name = (SELECT name FROM names WHERE id = @id) ORDER BY date; SET @id := @id + 1; END WHILE; SELECT value AS summary FROM summary; END ================================================ FILE: Arcade/Databases/emptyDepartments.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE emptyDepartments() BEGIN SELECT d.dep_name FROM departments AS d WHERE NOT EXISTS ( SELECT * FROM employees AS e WHERE d.id = e.department ); END ================================================ FILE: Arcade/Databases/expressionsVerification.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE expressionsVerification() BEGIN SELECT * FROM expressions WHERE CASE operation WHEN "+" THEN a + b = c WHEN "-" THEN a - b = c WHEN "/" THEN a / b = c WHEN "*" THEN a * b = c END; END ================================================ FILE: Arcade/Databases/filmLibrary.sql ================================================ CREATE PROCEDURE filmLibrary() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ SET @fav_genre = (SELECT genre FROM movies GROUP BY genre ORDER BY COUNT(*) DESC LIMIT 1); SELECT s.actor, a.age FROM starring_actors AS s INNER JOIN actor_ages AS a ON s.actor = a.actor WHERE movie_name IN (SELECT movie FROM movies WHERE genre = @fav_genre) ORDER BY a.age DESC, s.actor; END ================================================ FILE: Arcade/Databases/findTable.sql ================================================ CREATE PROCEDURE findTable() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ SELECT TABLE_NAME AS tab_name, COLUMN_NAME AS col_name, DATA_TYPE AS data_type FROM information_schema.columns WHERE table_schema = 'ri_db' AND table_name LIKE "e%s" ORDER BY TABLE_NAME, COLUMN_NAME; END ================================================ FILE: Arcade/Databases/freeSeats.sql ================================================ CREATE PROCEDURE freeSeats() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ SELECT f.flight_id, IFNULL( ( SELECT (p.number_of_seats - c.value) FROM ( SELECT flight_id, COUNT(flight_id) AS value FROM purchases GROUP BY flight_id ) AS c WHERE c.flight_id = f.flight_id ), p.number_of_seats) AS free_seats FROM flights AS f INNER JOIN planes AS p ON f.plane_id = p.plane_id ORDER BY flight_id; END ================================================ FILE: Arcade/Databases/giftPackaging.sql ================================================ CREATE PROCEDURE giftPackaging() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ SELECT ( SELECT package_type FROM packages WHERE g.length <= length AND g.width <= width AND g.height <= height ORDER BY (length * width * height) LIMIT 1 ) AS package_type, COUNT(*) AS number FROM gifts AS g GROUP BY package_type ORDER BY package_type; END ================================================ FILE: Arcade/Databases/gradeDistribution.sql ================================================ CREATE PROCEDURE gradeDistribution() BEGIN SELECT Name, ID FROM Grades WHERE Final > (Midterm1+Midterm2) / 2 ORDER BY LEFT(Name, 3); END ================================================ FILE: Arcade/Databases/habitatArea.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE habitatArea() BEGIN SELECT ST_Area(ST_ConvexHull(ST_GeomFromText(CONCAT("MultiPoint(", GROUP_CONCAT(x, " ", y), ")")))) AS area FROM places; END ================================================ FILE: Arcade/Databases/holidayEvent.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE holidayEvent() BEGIN SET @counter := 0; SELECT DISTINCT buyer_name AS winners FROM ( SELECT buyer_name, (@counter := @counter + 1) AS counter FROM purchases ) AS t WHERE counter MOD 4 = 0 ORDER BY winners ASC; END ================================================ FILE: Arcade/Databases/hostnamesOrdering.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE hostnamesOrdering() BEGIN SELECT id, hostname FROM hostnames ORDER BY REVERSE(SUBSTR(CONCAT_WS(".", SUBSTRING_INDEX(REVERSE(SUBSTRING_INDEX(hostname, ".", 1)), ".", 1), SUBSTRING_INDEX(REVERSE(SUBSTRING_INDEX(hostname, ".", 2)), ".", 1), SUBSTRING_INDEX(REVERSE(SUBSTRING_INDEX(hostname, ".", 3)), ".", 1)), 1, CHAR_LENGTH(hostname))) ASC; END ================================================ FILE: Arcade/Databases/importantEvents.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE importantEvents() BEGIN SELECT id, name, event_date, participants FROM events ORDER BY WEEKDAY(event_date) ASC, participants DESC; END ================================================ FILE: Arcade/Databases/interestClub.sql ================================================ CREATE PROCEDURE interestClub() SELECT name FROM people_interests WHERE interests & (FIND_IN_SET('reading', interests) > 0) AND interests & (FIND_IN_SET('drawing', interests) > 0) ORDER BY name ================================================ FILE: Arcade/Databases/itemCounts.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE itemCounts() BEGIN SELECT item_name, item_type, COUNT(item_name) AS item_count FROM availableItems GROUP BY item_type, item_name ORDER BY item_type ASC; END ================================================ FILE: Arcade/Databases/legsCount.sql ================================================ DROP PROCEDURE IF EXISTS legsCount; CREATE PROCEDURE legsCount() SELECT SUM(IF(type = "human", 2, 4)) as summary_legs FROM creatures ORDER BY id; ================================================ FILE: Arcade/Databases/localCalendar.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE localCalendar() BEGIN SELECT e.event_id AS event_id, IF( s.hours = 24, DATE_FORMAT( DATE_ADD(e.date, INTERVAL s.timeshift MINUTE), "%Y-%m-%d %H:%i" ), DATE_FORMAT( DATE_ADD(e.date, INTERVAL s.timeshift MINUTE), "%Y-%m-%d %h:%i %p" ) ) AS formatted_date FROM events AS e INNER JOIN settings AS s ON e.user_id = s.user_id ORDER BY event_id ASC; END ================================================ FILE: Arcade/Databases/marketReport.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE marketReport() BEGIN WITH cte AS ( SELECT country, COUNT(country) AS competitors FROM foreignCompetitors GROUP BY country ORDER BY country ASC ) SELECT * FROM cte UNION ALL SELECT "Total:" AS country, COUNT(country) AS competitors FROM foreignCompetitors; END ================================================ FILE: Arcade/Databases/mischievousNephews.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE mischievousNephews() BEGIN SELECT WEEKDAY(mischief_date) AS weekday, mischief_date, author, title FROM mischief WHERE (author = "Huey") OR (author = "Dewey") OR (author = "Louie") ORDER BY weekday, Field(author, 'Huey', 'Dewey' ,'Louie'), mischief_date, title; END ================================================ FILE: Arcade/Databases/monthlyScholarships.sql ================================================ CREATE PROCEDURE monthlyScholarships() BEGIN SELECT id, scholarship / 12 AS scholarship FROM scholarships ORDER BY id; END ================================================ FILE: Arcade/Databases/mostExpensive.sql ================================================ CREATE PROCEDURE mostExpensive() BEGIN SELECT name FROM Products ORDER BY price * quantity DESC, name ASC LIMIT 1; END ================================================ FILE: Arcade/Databases/movieDirectors.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE movieDirectors() BEGIN SELECT director FROM moviesInfo WHERE year > 2000 GROUP BY director HAVING SUM(oscars) > 2 ORDER BY director ASC; END ================================================ FILE: Arcade/Databases/netIncome.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE netIncome() BEGIN SELECT YEAR(date) AS year, QUARTER(date) AS quarter, (SUM(profit) - SUM(loss)) AS net_profit FROM accounting GROUP BY quarter, year ORDER BY year ASC, quarter ASC; END ================================================ FILE: Arcade/Databases/newsSubscribers.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE newsSubscribers() BEGIN SELECT subscriber FROM half_year WHERE newspaper LIKE "%Daily%" UNION SELECT subscriber FROM full_year WHERE newspaper LIKE "%Daily%" ORDER BY subscriber ASC; END ================================================ FILE: Arcade/Databases/nicknames.sql ================================================ CREATE PROCEDURE nicknames() BEGIN UPDATE reservedNicknames SET nickname = CONCAT("rename - ", nickname), id = CONCAT("rename - ", id) WHERE LENGTH(nickname) <> 8; SELECT * FROM reservedNicknames ORDER BY id; END ================================================ FILE: Arcade/Databases/nullIntern.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE nullIntern() BEGIN SELECT COUNT(id) AS number_of_nulls FROM departments WHERE description IS NULL OR TRIM(description) IN ("null", "nil", "-"); END ================================================ FILE: Arcade/Databases/officeBranches.sql ================================================ CREATE PROCEDURE officeBranches() BEGIN ALTER TABLE branches ADD FOREIGN KEY (branchtype_id) REFERENCES branch_types (id) ON DELETE SET NULL; DELETE FROM branch_types WHERE name LIKE '%-outdated'; SELECT * FROM branches ORDER BY branch_id; END ================================================ FILE: Arcade/Databases/orderAnalytics.sql ================================================ DROP PROCEDURE IF EXISTS orderAnalytics; CREATE PROCEDURE orderAnalytics() BEGIN WITH order_analytics AS ( SELECT id, YEAR(order_date) AS year, QUARTER(order_date) AS quarter, type, (quantity * price) AS total_price FROM orders ) SELECT * FROM order_analytics ORDER by id; END; ================================================ FILE: Arcade/Databases/orderOfSuccession.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE orderOfSuccession() BEGIN SELECT CONCAT(IF(gender = "M", "King", "Queen"), " ", name) AS name FROM Successors ORDER BY birthday; END ================================================ FILE: Arcade/Databases/orderPrices.sql ================================================ DROP FUNCTION IF EXISTS get_total; CREATE FUNCTION get_total(items VARCHAR(45)) RETURNS INT DETERMINISTIC BEGIN SET @out := 0, @i := 1; WHILE REGEXP_SUBSTR(items, "\\d++", 1, @i) IS NOT NULL DO SET @out := @out + (SELECT price FROM item_prices WHERE id = REGEXP_SUBSTR(items, "\\d++", 1, @i) + 0); SET @i := @i + 1; END WHILE; RETURN @out; END; CREATE PROCEDURE orderPrices() BEGIN SELECT id, buyer, get_total(items) AS total_price FROM orders ORDER BY id; END; ================================================ FILE: Arcade/Databases/orderingEmails.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE orderingEmails() BEGIN SELECT id, email_title, CONCAT(FLOOR( IF(size < POW(2, 20),(size / POW(2, 10)), (size / POW(2, 20))) ), " ", IF(size < POW(2, 20), "Kb", "Mb")) AS short_size FROM emails ORDER BY size DESC; END ================================================ FILE: Arcade/Databases/pastEvents.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE pastEvents() BEGIN SELECT name, event_date FROM Events WHERE event_date BETWEEN DATE_SUB( (SELECT MAX(event_date) FROM Events), INTERVAL 7 DAY ) AND DATE_SUB( (SELECT MAX(event_date) FROM Events), INTERVAL 1 DAY ) ORDER BY event_date DESC; END ================================================ FILE: Arcade/Databases/personalHobbies.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE personalHobbies() BEGIN SELECT name FROM people_hobbies WHERE hobbies LIKE "%reading%" AND hobbies LIKE "%sports%"; END ================================================ FILE: Arcade/Databases/placesOfInterest.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE placesOfInterest() BEGIN SELECT country, SUM( IF(leisure_activity_type = "Adventure park", number_of_places, 0) ) AS adventure_park, SUM( IF(leisure_activity_type = "Golf", number_of_places, 0) ) AS golf, SUM( IF(leisure_activity_type = "River cruise", number_of_places, 0) ) AS river_cruise, SUM( IF(leisure_activity_type = "Kart racing", number_of_places, 0) ) AS kart_racing FROM countryActivities GROUP BY country ORDER BY country; END ================================================ FILE: Arcade/Databases/placesOfInterestPairs.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE placesOfInterestPairs() BEGIN SELECT s1.name AS place1, s2.name AS place2 FROM sights AS s1, sights AS s2 WHERE ST_Distance(Point(s1.x, s1.y), Point(s2.x, s2.y)) < 5 AND s1.name < s2.name ORDER BY place1 ASC, place2 ASC; END ================================================ FILE: Arcade/Databases/projectList.sql ================================================ CREATE PROCEDURE projectList() BEGIN SELECT project_name, team_lead, income FROM Projects ORDER BY internal_id ASC; END ================================================ FILE: Arcade/Databases/projectsTeam.sql ================================================ CREATE PROCEDURE projectsTeam() BEGIN SELECT DISTINCT name FROM projectLog ORDER BY (name) ASC; END ================================================ FILE: Arcade/Databases/queriesExecution.sql ================================================ CREATE PROCEDURE queriesExecution() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ DECLARE done BOOL DEFAULT FALSE; DECLARE s_code VARCHAR(2048) DEFAULT ""; DECLARE q_cursor CURSOR FOR SELECT code FROM my_queries; DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE; SET @i = 0; DROP TABLE IF EXISTS my_queries; CREATE TABLE my_queries ( id INT AUTO_INCREMENT PRIMARY KEY, query_name VARCHAR(2048), code VARCHAR(2048) ); DROP TABLE IF EXISTS output; CREATE TABLE output ( query_name VARCHAR(255), val VARCHAR(255) ); INSERT INTO my_queries (query_name, code) SELECT query_name, code FROM queries; UPDATE my_queries SET code = REGEXP_REPLACE( code, "FROM", CONCAT("AS val FROM") ); UPDATE my_queries SET code = REGEXP_REPLACE( code, "SELECT", CONCAT( "INSERT INTO output SELECT ", "(SELECT query_name FROM my_queries WHERE id = ", (@i := @i + 1), ") ", "AS query_name," ) ); OPEN q_cursor; my_loop: LOOP FETCH q_cursor INTO s_code; IF done THEN LEAVE my_loop; END IF; SET @sql := s_code; PREPARE q FROM @sql; EXECUTE q; DEALLOCATE PREPARE q; END LOOP; CLOSE q_cursor; SELECT * FROM output; END ================================================ FILE: Arcade/Databases/recentHires.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE recentHires() BEGIN SET @let := 0; WITH cte1 AS ( SELECT name, (@let := @let + 1) AS filter FROM ( SELECT name FROM pr_department ORDER BY date_joined DESC LIMIT 5 ) AS x ORDER BY name ), cte2 AS ( SELECT name, (@let := @let + 1) AS filter FROM ( SELECT name FROM it_department ORDER BY date_joined DESC LIMIT 5 ) AS y ORDER BY name ), cte3 AS ( SELECT name, (@let := @let + 1) AS filter FROM ( SELECT name FROM sales_department ORDER BY date_joined DESC LIMIT 5 ) AS z ORDER BY name ) SELECT names FROM ( SELECT name AS names, filter FROM cte1 UNION ALL SELECT name AS names, filter FROM cte2 UNION ALL SELECT name AS names, filter FROM cte3 ORDER BY filter ASC ) AS n; END ================================================ FILE: Arcade/Databases/restaurantInfo.sql ================================================ CREATE PROCEDURE restaurantInfo() BEGIN ALTER TABLE restaurants ADD COLUMN description VARCHAR(100) DEFAULT("TBD"); ALTER TABLE restaurants ADD COLUMN active INT DEFAULT(1); SELECT * FROM restaurants ORDER BY id; END ================================================ FILE: Arcade/Databases/routeLength.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE routeLength() BEGIN SELECT ROUND( SUM( ST_Distance(Point(c1.x, c1.y), Point(c2.x, c2.y)) ), 9 ) AS total FROM cities AS c1, cities AS c2 WHERE c2.id = c1.id + 1; END ================================================ FILE: Arcade/Databases/salaryDifference.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE salaryDifference() BEGIN SELECT COALESCE(((SELECT MAX(salary) FROM employees) * ( SELECT COUNT(salary) FROM employees WHERE salary = (SELECT MAX(salary) FROM employees) )) - (SELECT MIN(salary) FROM employees) * ( SELECT COUNT(salary) FROM employees WHERE salary = (SELECT MIN(salary) FROM employees) ), 0) AS difference; END ================================================ FILE: Arcade/Databases/scholarshipsDistribution.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE scholarshipsDistribution() BEGIN SELECT candidate_id AS student_id FROM candidates WHERE candidate_id NOT IN ( SELECT student_id FROM detentions ); END ================================================ FILE: Arcade/Databases/securityBreach.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE securityBreach() BEGIN SELECT first_name, second_name, attribute FROM users WHERE REGEXP_LIKE(attribute, CONCAT("\\w+%", first_name, "_", second_name, "%", "\\w*"), "c") ORDER BY attribute; END ================================================ FILE: Arcade/Databases/soccerGamesSeries.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE soccerGameSeries() BEGIN SELECT IF( wins > 0, 1, IF( wins < 0, 2, IF( diff > 0, 1, IF( diff < 0, 2, IF( host > 0, 1, IF( host < 0, 2, 0 ) ) ) ) ) ) winner FROM ( SELECT SUM(IF(s1 > s2, 1, -1)) wins, SUM(s1 - s2) diff, SUM(IF(h = 2, s1, -s2)) host FROM ( SELECT first_team_score s1, second_team_score s2, match_host h FROM scores ) x ) y; END ================================================ FILE: Arcade/Databases/soccerPlayers.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE soccerPlayers() BEGIN SELECT GROUP_CONCAT( first_name, " ", surname, " #", player_number ORDER BY player_number ASC SEPARATOR "; " ) AS players FROM soccer_team; END ================================================ FILE: Arcade/Databases/sortBook.sql ================================================ CREATE PROCEDURE sortBookChapters() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ SELECT chapter_name FROM book_chapters ORDER BY romanConverter(chapter_number); END; CREATE FUNCTION romanConverter (value VARCHAR(25)) RETURNS INT BEGIN SET @accumulator := 0; SET @previous := 0; SET @i := LENGTH(value); WHILE @i >= 1 DO SET @v := findSymbol(SUBSTRING(value, @i, 1)); SET @m := 0; IF @v < @previous THEN SET @m := -1; ELSE SET @m := 1; END IF; SET @accumulator := @accumulator + @v * @m; SET @previous := @v; SET @i = @i - 1; END WHILE; RETURN @accumulator; END; CREATE FUNCTION findSymbol (value CHAR(1)) RETURNS INT BEGIN CASE value WHEN 'I' THEN RETURN 1; WHEN 'V' THEN RETURN 5; WHEN 'X' THEN RETURN 10; WHEN 'L' THEN RETURN 50; WHEN 'C' THEN RETURN 100; WHEN 'D' THEN RETURN 500; WHEN 'M' THEN RETURN 1000; END CASE; END; ================================================ FILE: Arcade/Databases/storageOptimization.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE storageOptimization() BEGIN SELECT id, 'name' AS column_name, name AS value FROM workers_info WHERE name IS NOT NULL UNION SELECT id, 'date_of_birth', date_of_birth FROM workers_info WHERE date_of_birth IS NOT NULL UNION SELECT id, 'salary', salary FROM workers_info WHERE salary IS NOT NULL ORDER BY id, FIELD(column_name, 'name', 'date_of_birth', 'salary'); END ================================================ FILE: Arcade/Databases/stringsStatistics.sql ================================================ CREATE PROCEDURE stringsStatistics() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ DROP TABLE IF EXISTS letter; CREATE TABLE letter ( id SMALLINT PRIMARY KEY AUTO_INCREMENT, value CHAR(1) ); DROP TABLE IF EXISTS total; CREATE TABLE total ( id SMALLINT PRIMARY KEY AUTO_INCREMENT, value SMALLINT ); DROP TABLE IF EXISTS occurrence; CREATE TABLE occurrence ( id SMALLINT PRIMARY KEY AUTO_INCREMENT, value SMALLINT ); DROP TABLE IF EXISTS max_occurrence; CREATE TABLE max_occurrence ( id SMALLINT PRIMARY KEY AUTO_INCREMENT, value SMALLINT ); DROP TABLE IF EXISTS max_occurrence_reached; CREATE TABLE max_occurrence_reached ( id SMALLINT PRIMARY KEY AUTO_INCREMENT, value SMALLINT ); DROP TABLE IF EXISTS chars; CREATE TABLE chars ( id SMALLINT PRIMARY KEY AUTO_INCREMENT, value CHAR(1) ); SET @line := (SELECT GROUP_CONCAT(str SEPARATOR '') FROM strs); SET @i := 1; WHILE @i <= LENGTH(@line) DO INSERT INTO chars (value) SELECT (SELECT SUBSTRING(@line, @i, 1)); SET @i = @i + 1; END WHILE; /*For letter*/ INSERT INTO letter (value) SELECT value FROM chars GROUP BY value; /* For total */ INSERT INTO total (value) SELECT COUNT(*) FROM chars GROUP BY value; /* For occurrence*/ INSERT INTO occurrence (value) SELECT ( SELECT COUNT(*) FROM strs WHERE str LIKE CONCAT( '%', l.value, '%' ) ) FROM letter AS l; /* For max_occurrence*/ INSERT INTO max_occurrence (value) SELECT (SELECT MAX(LENGTH(REGEXP_REPLACE( str, CONCAT("[^", l.value, "]"), "" ))) FROM strs ) AS 'max' FROM letter AS l; /* For max_occurrence_reached*/ INSERT INTO max_occurrence_reached (value) SELECT ( SELECT COUNT(*) FROM strs WHERE LENGTH(REGEXP_REPLACE( str, CONCAT("[^", l.value, "]"), "" )) = ( SELECT MAX(LENGTH(REGEXP_REPLACE( str, CONCAT("[^", l.value, "]"), "" ))) AS m FROM strs ) ) FROM letter AS l; SELECT l.value AS letter, t.value AS total, o.value AS occurrence, mo.value AS max_occurrence, mor.value AS max_occurrence_reached FROM letter AS l, total AS t, occurrence AS o, max_occurrence AS mo, max_occurrence_reached AS mor WHERE l.id = t.id && t.id = o.id && o.id = mo.id && mo.id = mor.id ORDER BY letter; END ================================================ FILE: Arcade/Databases/studentsInClubs.sql ================================================ CREATE PROCEDURE studentsInClubs() SELECT * FROM students WHERE EXISTS ( SELECT * FROM clubs AS c WHERE c.id = students.club_id ) ORDER BY students.id; ================================================ FILE: Arcade/Databases/sunnyHolidays.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE sunnyHolidays() BEGIN SELECT h.holiday_date AS ski_date FROM holidays AS h INNER JOIN weather AS w ON h.holiday_date = w.sunny_date ORDER BY ski_date; END ================================================ FILE: Arcade/Databases/suspectsInvestigation.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE suspectsInvestigation() BEGIN SELECT id, name, surname FROM Suspect AS s WHERE s.height <= 170 AND name LIKE "b%" AND surname LIKE "gre_n"; END ================================================ FILE: Arcade/Databases/suspectsInvestigation2.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE suspectsInvestigation2() BEGIN SELECT id, name, surname FROM Suspect AS s WHERE s.height <= 170 OR surname NOT LIKE "gre_n" OR name NOT LIKE "B%"; END ================================================ FILE: Arcade/Databases/tableSecurity.sql ================================================ CREATE PROCEDURE tableSecurity() BEGIN CREATE OR REPLACE VIEW emp AS SELECT id, name, YEAR(date_joined) AS date_joined, "-" AS salary FROM employees; SELECT id, name, date_joined, salary FROM emp ORDER BY id; END ================================================ FILE: Arcade/Databases/testCheck.sql ================================================ CREATE PROCEDURE testCheck() SELECT id, IF ( correct_answer = given_answer, "correct", IF(given_answer IS NULL, "no answer", "incorrect")) AS checks FROM answers ORDER BY id; ================================================ FILE: Arcade/Databases/tictactoeTournament.sql ================================================ CREATE PROCEDURE tictactoeTournament() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ SET @regx := "^((xxx.{6}|...xxx...|.{6}xxx)|((x..){3}|(.x.){3}|(..x){3})|((x...){2}x|.(.x){3}..))$"; SET @rego := "^((ooo.{6}|...ooo...|.{6}ooo)|((o..){3}|(.o.){3}|(..o){3})|((o...){2}o|.(.o){3}..))$"; WITH names AS ( SELECT name_naughts AS name FROM results UNION SELECT name_crosses AS name FROM results ), base AS ( SELECT n.name, ( SELECT COUNT(board) FROM results WHERE name_naughts = n.name OR name_crosses = n.name ) AS played, ( SELECT COUNT(board) FROM results WHERE ( name_naughts = n.name AND REGEXP_LIKE(board, @rego, "i") = 1 ) OR ( name_crosses = n.name AND REGEXP_LIKE(board, @regx, "i") = 1 ) ) AS won, ( SELECT COUNT(board) FROM results WHERE ( name_naughts = n.name OR name_crosses = n.name ) AND ( REGEXP_LIKE(board, @rego, "i") = 0 AND REGEXP_LIKE(board, @regx, "i") = 0 ) ) AS draw, ( SELECT COUNT(board) FROM results WHERE ( name_naughts = n.name AND REGEXP_LIKE(board, @regx, "i") = 1 ) OR ( name_crosses = n.name AND REGEXP_LIKE(board, @rego, "i") = 1 ) ) AS lost FROM names AS n ) SELECT name, ( SELECT won * 2 + draw FROM base WHERE name = b.name ) AS points, played, won, draw, lost FROM base AS b ORDER BY points DESC, played, won DESC, name; END; ================================================ FILE: Arcade/Databases/top5AverageGrade.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE top5AverageGrade() BEGIN SELECT ROUND(AVG(s1.grade), 2) AS average_grade FROM ( SELECT grade FROM students ORDER BY grade DESC LIMIT 5 ) AS s1; END ================================================ FILE: Arcade/Databases/trackingSystem.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE trackingSystem() BEGIN WITH cte_id AS ( SELECT DISTINCT anonymous_id AS id FROM tracks ORDER BY anonymous_id ASC ), cte_l AS ( SELECT id, ( SELECT event_name FROM tracks WHERE anonymous_id = a.id AND user_id IS NOT NULL ORDER BY received_at ASC LIMIT 1 ) AS event_name FROM cte_id AS a ), cte_f AS ( SELECT id, ( SELECT event_name FROM tracks WHERE anonymous_id = a.id AND user_id IS NULL ORDER BY received_at DESC LIMIT 1 ) AS event_name FROM cte_id AS a ) SELECT a.id AS anonym_id, a.event_name AS last_null, b.event_name AS first_notnull FROM cte_f AS a, cte_l AS b WHERE a.id = b.id; END ================================================ FILE: Arcade/Databases/travelDiary.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE travelDiary() BEGIN SELECT GROUP_CONCAT( DISTINCT country ORDER BY country ASC SEPARATOR ";" ) AS countries FROM diary; END ================================================ FILE: Arcade/Databases/typeInheritance.sql ================================================ CREATE FUNCTION isNumber(class VARCHAR(45)) RETURNS BOOLEAN BEGIN DECLARE basec VARCHAR(45) DEFAULT ''; DECLARE next VARCHAR(45) DEFAULT NULL; DECLARE ret BOOLEAN DEFAULT FALSE; DECLARE i INT DEFAULT 0; SET next = class; SET ret = FALSE; SET i = 0; WHILE i < 200 AND (NOT ret) AND (SELECT COUNT(base) FROM inheritance WHERE derived = next LIMIT 1) DO SELECT base INTO basec FROM inheritance WHERE derived = next LIMIT 1; SET ret = IF(IFNULL(basec,'') = 'Number', TRUE, FALSE); SET next = basec; SET i = i+1; END WHILE; RETURN ret OR i > 100; END; CREATE PROCEDURE typeInheritance() BEGIN SELECT var_name, type as var_type FROM variables WHERE isNumber(type) ORDER BY var_name; END ================================================ FILE: Arcade/Databases/unluckyEmployees.sql ================================================ CREATE PROCEDURE unluckyEmployees() BEGIN /* Write your SQL here. Terminate each statement with a semicolon. */ SET @id := 0; WITH cte AS ( SELECT (@id := @id + 1) AS id, x.* FROM ( SELECT d.name AS dep_name, COUNT(full_name) AS emp_number, IFNULL(SUM(e.salary), 0) AS total_salary FROM Department AS d LEFT JOIN Employee AS e ON d.id = e.department GROUP BY dep_name HAVING emp_number < 6 ORDER BY total_salary DESC, emp_number DESC, d.id ) AS x ) SELECT dep_name, emp_number, total_salary FROM cte WHERE id % 2 > 0; END ================================================ FILE: Arcade/Databases/userCountries.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE userCountries() BEGIN SELECT u.id, IFNULL(c.country, "unknown") AS country FROM users AS u LEFT JOIN cities AS c ON u.city = c.city ORDER BY u.id ASC; END ================================================ FILE: Arcade/Databases/usersByContinent.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE usersByContinent() BEGIN SELECT continent, SUM(users) AS users FROM countries GROUP BY continent ORDER BY users DESC; END ================================================ FILE: Arcade/Databases/validPhoneNumbers.sql ================================================ /*Please add ; after each select statement*/ CREATE PROCEDURE validPhoneNumbers() BEGIN SELECT name, surname, phone_number FROM phone_numbers WHERE phone_number REGEXP "^(?>\\(1\\)|1-)\\d{3}-\\d{3}-\\d{4}$" ORDER BY surname; END ================================================ FILE: Arcade/Databases/volleyballResults.sql ================================================ CREATE PROCEDURE volleyballResults() BEGIN SELECT * FROM results ORDER BY wins; END ================================================ FILE: Arcade/Databases/websiteHacking.sql ================================================ CREATE PROCEDURE websiteHacking() SELECT id,login,name FROM users WHERE type='user' OR type LIKE "%" ORDER BY id ================================================ FILE: Arcade/Intro/Java/AbsoluteValuesSumMinimization.java ================================================ import java.util.Arrays; import java.util.stream.IntStream; final class AbsoluteValuesSumMinimization { int absoluteValuesSumMinimization(int[] a) { int[] sums = Arrays.stream(a).map(n -> Arrays.stream(a) .map(e -> Math.abs(n - e)).sum()).toArray(); int min = Arrays.stream(sums).min().getAsInt(); return a[IntStream.range(0, sums.length) .filter(i -> sums[i] == min).toArray()[0]]; } } ================================================ FILE: Arcade/Intro/Java/Add.java ================================================ public class Add { int add(int param1, int param2) { return param1 + param2; } } ================================================ FILE: Arcade/Intro/Java/AddBorder.java ================================================ final class AddBorder { String[] addBorder(String[] picture) { int len = picture.length + 2; String[] o = new String[len]; for(int i = 0; i < len - 2; i++) { o[i + 1] = "*"+picture[i]+"*"; } o[0] = o[len - 1] = "*".repeat(picture[0].length() + 2); return o; } } ================================================ FILE: Arcade/Intro/Java/AdjacentElementsProduct.java ================================================ import java.util.stream.IntStream; final class AdjacentElementsProduct { int adjacentElementsProduct(int[] inputArray) { return IntStream.range(1, inputArray.length) .map(n -> inputArray[n] * inputArray[n - 1]) .max() .getAsInt(); } } ================================================ FILE: Arcade/Intro/Java/AllLongestStrings.java ================================================ import java.util.Arrays; public class AllLongestStrings { String[] allLongestStrings(String[] inputArray) { int max = Stream.of(inputArray) .mapToInt(n -> n.length()) .max() .getAsInt(); return Stream.of(inputArray) .filter(e -> e.length() == max) .toArray(String[]::new); } } ================================================ FILE: Arcade/Intro/Java/AlmostIncreasingSequence.java ================================================ final class AlmostIncreasingSequence { boolean almostIncreasingSequence(int[] sequence) { int last = -0x186a0, lastPrev = -0x186a0, c = 0; for(int n : sequence) { if(n <= last) { c++; if(n > lastPrev) last = n; continue; } lastPrev = last; last = n; } return c <= 1; } } ================================================ FILE: Arcade/Intro/Java/AlphabeticShift.java ================================================ import java.util.stream.Collectors; final class AlphabeticShift { String alphabeticShift(String inputString) { return inputString.chars().boxed() .map(c -> c == 122 ? 'a' : (char)(c + 1)) .map(Object::toString) .collect(Collectors.joining()); } } ================================================ FILE: Arcade/Intro/Java/AlternatingSums.java ================================================ final class AlternatingSums { int[] alternatingSums(int[] a) { int[] o = new int[2]; for(int i = 0; i < a.length; i++) { o[(i + 1) % 2 == 0 ? 1 : 0] += a[i]; } return o; } } ================================================ FILE: Arcade/Intro/Java/AreEquallyStrong.java ================================================ public final class AreEquallyStrong { boolean areEquallyStrong(int yourLeft, int yourRight, int friendsLeft, int friendsRight) { int yl = yourLeft, yr = yourRight, fl = friendsLeft, fr = friendsRight; return (yl == fl && yr == fr || yr == fl && yl == fr); } } ================================================ FILE: Arcade/Intro/Java/AreSimilar.java ================================================ import java.util.Arrays; final class AreSimilar { void swap(int[] a, int p, int q) { int tmp = a[p]; a[p] = a[q]; a[q] = tmp; } boolean areSimilar(int[] a, int[] b) { if(Arrays.equals(a, b)) return true; int p = 0, q = 0; for(int i = 0, k = 2; i < b.length; i++) { if(a[i] != b[i]) { if(k == 2) { p = i; k--; continue; } q = i; k--; } if(k == 0) { swap(b, p, q); return Arrays.equals(a, b); } } return false; } } ================================================ FILE: Arcade/Intro/Java/ArrayChange.java ================================================ final class ArrayChange { int arrayChange(int[] inputArray) { int c = 0; for(int i = 0; i < inputArray.length - 1; i++) { while(inputArray[i + 1] <= inputArray[i]) { inputArray[i + 1]++; c++; } } return c; } } ================================================ FILE: Arcade/Intro/Java/ArrayMaxConsecutiveSum.java ================================================ final class ArrayMaxConsecutiveSum { int arrayMaxConsecutiveSum(int[] inputArray, int k) { int max = 0, t = 0; for(int i = 0; i <= inputArray.length - k; i++, t = 0) { for(int j = i; j < i + k; j++) t += inputArray[j]; if(t > max) max = t; } return max; } } ================================================ FILE: Arcade/Intro/Java/ArrayMaximalAdjacentDifference.java ================================================ import java.util.stream.IntStream; final class ArrayMaximalAdjacentDifference { int arrayMaximalAdjacentDifference(int[] inputArray) { return IntStream.range(0, inputArray.length - 1) .map(i -> Math.abs(inputArray[i] - inputArray[i + 1])).max().getAsInt(); } } ================================================ FILE: Arcade/Intro/Java/ArrayReplace.java ================================================ import java.util.Arrays; final class ArrayReplace { int[] arrayReplace(int[] inputArray, int elemToReplace, int substitutionElem) { return Arrays.stream(inputArray) .map(n -> n == elemToReplace ? substitutionElem : n).toArray(); } } ================================================ FILE: Arcade/Intro/Java/AvoidObstacles.java ================================================ final class AvoidObstacles { int avoidObstacles(int[] inputArray) { boolean k = true; for(int i = 2; ; i++) { for(int j : inputArray) { if(j % i == 0) { k = !k; break; } } if(k) return i; k = true; } } } ================================================ FILE: Arcade/Intro/Java/BishopAndPawn.java ================================================ final class BishopAndPawn { boolean bishopAndPawn(String bishop, String pawn) { return Math.abs(bishop.charAt(0) - pawn.charAt(0)) == Math.abs(bishop.charAt(1) - pawn.charAt(1)); } } ================================================ FILE: Arcade/Intro/Java/BoxBlur.java ================================================ import java.util.Arrays; final class BoxBlur { int[][] boxBlur(int[][] image) { int h = image.length - 2; int w = image[0].length - 2; int[][] sum = new int[h][w]; for(int i = 0; i < h; i++) { for(int j = 0; j < w; j++) { for(int y = i; y < i + 3; y++) for(int x = j; x < j + 3; x++) sum[i][j] += image[y][x]; sum[i][j] /= 9; } } return sum; } } ================================================ FILE: Arcade/Intro/Java/BuildPalindrome.java ================================================ final class BuildPalindrome { String reverseString(String str) { return new StringBuilder(str).reverse().toString(); } String buildPalindrome(String st) { if(reverseString(st).equals(st)) return st; String sg = "", out = ""; for(char c : st.toCharArray()) { out = st+reverseString(sg += c+""); if(out.equals(reverseString(out))) break; } return out; } } ================================================ FILE: Arcade/Intro/Java/CenturyFromYear.java ================================================ public class CenturyFromYear { int centuryFromYear(int year) { return 1 + (year - 1) / 100; } } ================================================ FILE: Arcade/Intro/Java/CheckPalindrome.java ================================================ public class CheckPalindrome { boolean checkPalindrome(String inputString) { return new StringBuilder(str).reverse().toString().equals(str); } } ================================================ FILE: Arcade/Intro/Java/ChessBoardCellColor.java ================================================ final class ChessBoardCellColor { boolean chessBoardCellColor(String cell1, String cell2) { int x1 = cell1.charAt(0) - 'A'; int y1 = new Integer(cell1.charAt(1)+""); int x2 = cell2.charAt(0) - 'A'; int y2 = new Integer(cell2.charAt(1)+""); return (x1 + x2) % 2 == (y1 + y2) % 2; } } ================================================ FILE: Arcade/Intro/Java/ChessKnight.java ================================================ final class ChessKnight { boolean isSafe(int x, int y) { return x >= 0 && x < 8 && y >= 0 && y < 8; } int chessKnight(String cell) { int x = cell.charAt(0) - 'a', y = new Integer(cell.charAt(1)+"") - 1, out = 0; if(isSafe(x + 2, y + 1)) out++; if(isSafe(x + 2, y - 1)) out++; if(isSafe(x - 2, y + 1)) out++; if(isSafe(x - 2, y - 1)) out++; if(isSafe(x + 1, y + 2)) out++; if(isSafe(x - 1, y + 2)) out++; if(isSafe(x + 1, y - 2)) out++; if(isSafe(x - 1, y - 2)) out++; return out; } } ================================================ FILE: Arcade/Intro/Java/CircleOfNumbers.java ================================================ final class CircleOfNumbers { int circleOfNumbers(int n, int firstNumber) { return (n / 2 + firstNumber) % n; } } ================================================ FILE: Arcade/Intro/Java/CommonCharacterCount.java ================================================ import java.util.stream.IntStream; import java.util.stream.Collectors; final class CommonCharacterCount { int commonCharacterCount(String s1, String s2) { int o = 0; String common = IntStream .range(0x61, 0x7b) .filter(n -> s1.contains((char)n+"") && s2.contains((char)n+"")) .boxed().map(c -> (char)c.intValue()+"").collect(Collectors.joining()); for(char c : common.toCharArray()) { o += Math.min( s1.chars().map(n -> c == (char)n ? 1 : 0).sum(), s2.chars().map(n -> c == (char)n ? 1 : 0).sum()); } return o; } } ================================================ FILE: Arcade/Intro/Java/DeleteDigit.java ================================================ final class DeleteDigit { int deleteDigit(int n) { int max = 0, len = (n+"").length(); for(int i = 0; i < len; i++) { String tmp = ""; for(int j = 0; j < len; j++) if(j != i) tmp += (n+"").charAt(j); int v = new Integer(tmp); if(v > max) max = v; } return max; } } ================================================ FILE: Arcade/Intro/Java/DepositProfit.java ================================================ final class DepositProfit { int depositProfit(int deposit, int rate, int threshold) { float d = deposit; for(int y = 1;; y++) if((d += rate / 100f * d) >= threshold) return y; } } ================================================ FILE: Arcade/Intro/Java/DifferentSquares.java ================================================ import java.util.Set; import java.util.HashSet; final class DifferentSquares { int differentSquares(int[][] matrix) { Set set = new HashSet<>(); for(int x = 0; x < matrix.length - 1; x++) { for(int y = 0; y < matrix[0].length - 1; y++) { String aux = ""; for(int i = x; i < x + 2; i++) for(int j = y; j < y + 2; j++) aux += matrix[i][j]; set.add(aux); } } return set.size(); } } ================================================ FILE: Arcade/Intro/Java/DifferentSymbolsNaive.java ================================================ final class DifferentSymbolsNaive { int differentSymbolsNaive(String s) { return s.chars().distinct().toArray().length; } } ================================================ FILE: Arcade/Intro/Java/DigitDegree.java ================================================ final class DigitDegree { int digitDegree(int n) { int counter = 0; for(; (n+"").length() > 1; counter++) n = (n+"").chars().map(e -> new Integer((char)e+"")).sum(); return counter; } } ================================================ FILE: Arcade/Intro/Java/DigitsProduct.java ================================================ final class DigitsProduct { int digitsProduct(int product) { if(product == 0) return 10; if(product < 10) return product; String s = ""; for(int d = 9; d > 1; d--) for(; product % d == 0; product /= d) s = d+s; return product == 1 ? Integer.parseInt(s) : -1; } } ================================================ FILE: Arcade/Intro/Java/ElectionsWinners.java ================================================ import java.util.Arrays; final class ElectionsWinners { int electionsWinners(int[] votes, int k) { int winners = 0; for(int i = 0; i < votes.length; i++) { int v = votes[i]; votes[i] = 0; if(Arrays.stream(votes).allMatch(e -> v + k > e)) winners++; votes[i] = v; } return winners; } } ================================================ FILE: Arcade/Intro/Java/EvenDigitsOnly.java ================================================ final class EvenDigitsOnly { boolean evenDigitsOnly(int n) { return (n+"").chars().allMatch(e -> new Integer(e+"") % 2 == 0); } } ================================================ FILE: Arcade/Intro/Java/ExtractEachKth.java ================================================ import java.util.stream.IntStream; public final class ExtractEachKth { int[] extractEachKth(int[] inputArray, int k) { return IntStream.range(0, inputArray.length) .filter(i -> (i + 1) % k != 0).map(i -> inputArray[i]).toArray(); } } ================================================ FILE: Arcade/Intro/Java/FileNaming.java ================================================ import java.util.Vector; final class FileNaming { String[] fileNaming(String[] names) { Vector vector = new Vector<>(); for(int i = 0; i < names.length; i++) { String aux = names[i]; for(int k = 1; vector.contains(aux); k++) aux = names[i]+"("+k+")"; vector.add(aux); names[i] = aux; } return names; } } ================================================ FILE: Arcade/Intro/Java/FindEmailDomain.java ================================================ final class FindEmailDomain { String findEmailDomain(String address) { String[] pieces = address.split("@"); return pieces[pieces.length - 1]; } } ================================================ FILE: Arcade/Intro/Java/FirstDigit.java ================================================ final class FirstDigit { char firstDigit(String inputString) { return (char) inputString.chars() .filter(e -> ((char)e+"").matches("\\d")).toArray()[0]; } } ================================================ FILE: Arcade/Intro/Java/GrowingPlant.java ================================================ public final class GrowingPlant { int growingPlant(int upSpeed, int downSpeed, int desiredHeight) { int count = 0, height = 0; while(true) { height += upSpeed; count++; if(height >= desiredHeight) { break; } height -= downSpeed; } return count; } } ================================================ FILE: Arcade/Intro/Java/IsBeautifulString.java ================================================ final class IsBeautifulString { boolean isBeautifulString(String inputString) { byte[] abc = new byte[26]; for(char c : inputString.toCharArray()) abc[c - 'a']++; for(byte i = 0; i < 25; i++) if(abc[i + 1] > abc[i]) return false; return true; } } ================================================ FILE: Arcade/Intro/Java/IsDigit.java ================================================ final class IsDigit { boolean isDigit(char symbol) { return (symbol+"").matches("\\d"); } } ================================================ FILE: Arcade/Intro/Java/IsIPv4Address.java ================================================ final class IsIPv4Address { boolean isIPv4Address(String inputString) { String[] split = inputString.split("\\."); if(split.length != 4) return false; for(String s : split) { if(s.matches("\\d*[a-z]+\\d*") || s.length() == 0) return false; if(s.length() > 1 && (s.charAt(0) == '0' || new Long(s) > 255)) { return false; } } return true; } } ================================================ FILE: Arcade/Intro/Java/IsLucky.java ================================================ final class IsLucky { boolean isLucky(int n) { String ticket = n+""; return ticket .substring(0, ticket.length() / 2) .chars().map(q -> new Integer((char)q+"")).sum() == ticket .substring(ticket.length() / 2, ticket.length()) .chars().map(q -> new Integer((char)q+"")).sum(); } } ================================================ FILE: Arcade/Intro/Java/IsMAC48Adress.java ================================================ final class IsMAC48Adress { boolean isMAC48Address(String inputString) { return inputString.matches("[0-9A-F]{2}(-[0-9A-F]{2}){5}"); } } ================================================ FILE: Arcade/Intro/Java/KnapsackLight.java ================================================ final class KnapsackLight { int knapsackLight(int value1, int weight1, int value2, int weight2, int maxW) { if(maxW >= weight1 + weight2) return (value1 + value2); else if(value2 > value1 && maxW >= weight2) return value2; else if(value1 > value2 && maxW >= weight1) return value1; else if(maxW >= weight1) return value1; else if(maxW >= weight2) return value2; return 0; } } ================================================ FILE: Arcade/Intro/Java/LineEnconding.java ================================================ import java.util.List; import java.util.ArrayList; final class LineEnconding { String lineEncoding(String s) { List subs = new ArrayList<>(); String aux = "", out = ""; char prev = s.charAt(0); for(int i = 0; i < s.length(); i++) { char curr = s.charAt(i); if(curr != prev) { subs.add(aux); aux = (prev = curr)+""; continue; } aux += prev = curr; } subs.add(aux); for(String v : subs) out += ""+(v.length() > 1 ? v.length() : "")+v.charAt(0); return out; } } ================================================ FILE: Arcade/Intro/Java/LongestDigitsPrefix.java ================================================ final class LongestDigitsPrefix { String longestDigitsPrefix(String inputString) { String output = ""; for(char ch : inputString.toCharArray()) { if((ch+"").matches("\\d")) output += ch; else break; } return output; } } ================================================ FILE: Arcade/Intro/Java/LongestWord.java ================================================ import java.util.Arrays; final class LongestWord { String longestWord(String text) { return Arrays.stream(text.replaceAll("\\p{Punct}", " ").split(" ")) .reduce((v, c) -> c = v.length() > c.length() ? v : c).get(); } } ================================================ FILE: Arcade/Intro/Java/MakeArrayConsecutive2.java ================================================ import java.util.Arrays; import java.util.stream.IntStream; final class MakeArrayConsecutive2 { int makeArrayConsecutive2(int[] statues) { Arrays.sort(statues); return IntStream.rangeClosed(statues[0], statues[statues.length - 1]) .toArray().length - statues.length; } } ================================================ FILE: Arcade/Intro/Java/MatrixElementsSum.java ================================================ public class MatrixElementsSum { int matrixElementsSum(int[][] matrix) { int sum = 0; for(int i = 0; i < matrix[0].length; i++) { for(int j = 0; j < matrix.length; j++) { if(matrix[j][i] == 0) break; sum += matrix[j][i]; } } return sum; } } ================================================ FILE: Arcade/Intro/Java/MessageFromBinaryCode.java ================================================ import java.util.stream.Collectors; import java.util.Arrays; final class MessageFromBinaryCode { String messageFromBinaryCode(String code) { return Arrays.stream(code.split("(?<=\\G.{8})")) .map(v -> (char)Integer.parseInt(v, 2)+"").collect(Collectors.joining()); } } ================================================ FILE: Arcade/Intro/Java/Minesweeper.java ================================================ final class Minesweeper { int[][] minesweeper(boolean[][] matrix) { int w = matrix[0].length, h = matrix.length; int[][] board = new int[h][w]; for(int i = 0; i < h; i++) { for(int j = 0; j < w; j++) { if(matrix[i][j]) { if(i + 1 < h) board[i + 1][j]++; if(i + 1 < h && j - 1 >= 0) board[i + 1][j - 1]++; if(j - 1 >= 0) board[i][j - 1]++; if(i - 1 >= 0 && j + 1 < w) board[i - 1][j + 1]++; if(i - 1 >= 0) board[i - 1][j]++; if(i - 1 >= 0 && j - 1 >= 0) board[i - 1][j - 1]++; if(j + 1 < w) board[i][j + 1]++; if(i + 1 < h && j + 1 < w) board[i + 1][j + 1]++; } } } return board; } } ================================================ FILE: Arcade/Intro/Java/PalindromeRearranging.java ================================================ import java.util.Arrays; final class PalindromeRearranging { boolean palindromeRearranging(String inputString) { int[] abc = new int[26]; for(int i = 0; i < inputString.length(); i++) { abc[inputString.charAt(i) - 'a']++; } return inputString.length() % 2 == Arrays.stream(abc).map(n -> n % 2 == 1 ? 1 : 0).sum(); } } ================================================ FILE: Arcade/Intro/Java/RemoveKFromList.java ================================================ final class RemoveKFromList { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // ListNode removeKFromList(ListNode l, int k) { ListNode out = new ListNode<>(null), ref = out; for(; l != null; l = l.next) { if(l.value != k) { ref.next = new ListNode<>(l.value); ref = ref.next; } } return out.next; } } ================================================ FILE: Arcade/Intro/Java/ReverseInParentheses.java ================================================ import java.util.regex.Matcher; import java.util.regex.Pattern; final class ReverseInParentheses { String reverseInParentheses(String inputString) { Matcher mt = Pattern.compile("\\(\\w*\\)").matcher(inputString); if(!mt.find()) return inputString; String str = mt.group(), revStr = str.replace(")", "").replace("(", ""); return reverseInParentheses(inputString.replace(str, new StringBuilder(revStr).reverse().toString())); } } ================================================ FILE: Arcade/Intro/Java/ShapeArea.java ================================================ public class ShapeArea { int shapeArea(int n) { return IntStream.range(0, n).map(p -> (p - n) * -1) .map(q -> (q - 1) * 4).sum() + 1; } } ================================================ FILE: Arcade/Intro/Java/SortByHeight.java ================================================ import java.util.ArrayList; import java.util.Arrays; public class SortByHeight { int[] sortByHeight(int[] a) { for(int i = 0; i < a.length; i++) { for(int j = i + 1; j < a.length; j++) { if(a[i] != -1 && a[j] != -1) { if(a[i] > a[j]) { int tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } } } return a; } } ================================================ FILE: Arcade/Intro/Java/SpiralNumbers.java ================================================ final class SpiralNumbers { int[][] spiralNumbers(int n) { int[][] spiral = new int[n][n]; int left = 0, right = n - 1, top = 0, down = n - 1; for(int adder = 1; adder <= n * n; ) { for(int x = left; x <= right; x++) spiral[top][x] = adder++; top++; for(int y = top; y <= down; y++) spiral[y][right] = adder++; right--; for(int x = right; x >= left; x--) spiral[down][x] = adder++; down--; for(int y = down; y >= top; y--) spiral[y][left] = adder++; left++; } return spiral; } } ================================================ FILE: Arcade/Intro/Java/StringsRearrangement.java ================================================ import java.util.Arrays; import java.util.ArrayList; final class StringsRearrangement { boolean flag; boolean check(String s1, String s2) { int counter = 0; for(int i = 0; i < s1.length(); i++) if(s1.charAt(i) != s2.charAt(i)) counter++; return counter == 1; } void permute(String[] arr, int l, int h) { if(l == h) { flag = true; for(int i = 0; i < arr.length - 1; i++) if(!check(arr[i], arr[i + 1])) { flag = false; break; } } else { for(int i = l; i <= h && !flag; i++) { swap(arr, l, i); permute(arr, l + 1, h); swap(arr, l, i); } } } void swap(String[] arr, int i, int j) { String tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; } boolean stringsRearrangement(String[] inputArray) { permute(inputArray, 0, inputArray.length - 1); return flag; } } ================================================ FILE: Arcade/Intro/Java/Sudoku.java ================================================ import java.util.Arrays; final class Sudoku { boolean sudoku(int[][] grid) { int n = grid.length, sqrt = (int) Math.sqrt(n); int[] row = new int[n], col = new int[n], box = new int[n]; for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { row[grid[i][j] - 1]++; col[grid[j][i] - 1]++; } int sq = i - i % sqrt; for(int y = sq; y < sq + sqrt; y++) { for(int x = sq; x < sq + sqrt; x++) box[grid[y][x] - 1]++; } for(int j = 0; j < n; j++) if(row[j] == 0 || col[j] == 0 || box[j] == 0) return false; Arrays.fill(box, 0); Arrays.fill(row, 0); Arrays.fill(col, 0); } return true; } } ================================================ FILE: Arcade/Intro/Java/SumUpNumbers.java ================================================ final class SumUpNumbers { int sumUpNumbers(String inputString) { return Arrays.stream(inputString.replaceAll("[^\\d]", " ").split(" ")) .mapToInt(e -> !e.isEmpty() ? Integer.parseInt(e) : 0).sum(); } } ================================================ FILE: Arcade/Intro/Java/ValidTime.java ================================================ final class ValidTime { boolean validTime(String time) { String[] dig = time.split(":"); return new Integer(dig[0]) < 24 && new Integer(dig[1]) < 60; } } ================================================ FILE: Arcade/Intro/Java/VariableName.java ================================================ final class VariableName { boolean variableName(String name) { return name.matches("^[a-zA-Z_]\\w*"); } } ================================================ FILE: Arcade/Intro/Python/stringsRearrangement.py ================================================ import itertools def isDifferByOneChar(str1, str2): count = 0 for i in range(len(str1)): if str1[i] != str2[i]: count += 1 return count == 1 def stringsRearrangement(inputArray): possiblePermutations = itertools.permutations(inputArray) for per in possiblePermutations: allMatch = True for i in range(len(per) - 1): if not isDifferByOneChar(per[i], per[i + 1]): allMatch = False break if allMatch: return True return False ================================================ FILE: Arcade/Intro/Ruby/absoluteValuesSumMinimization.rb ================================================ def absoluteValuesSumMinimization(a) return a[(a.size - 1) / 2] end ================================================ FILE: Arcade/Intro/Ruby/add.rb ================================================ def add(param1, param2) return param1 + param2 end ================================================ FILE: Arcade/Intro/Ruby/addBorder.rb ================================================ def addBorder(picture) border = "*" * (picture[0].size + 2) return picture.map{|e| "*"+e+"*"}.insert(0, border).push border end ================================================ FILE: Arcade/Intro/Ruby/adjacentElementsProduct.rb ================================================ def adjacentElementsProduct(inputArray) max = inputArray[0] * inputArray[1] (inputArray.size - 1).times do |i| q = inputArray[i] * inputArray[i + 1] max = q if q > max end return max end ================================================ FILE: Arcade/Intro/Ruby/allLongestStrings.rb ================================================ def allLongestStrings(a) return a.filter{|e| e.size == a.map{|e| e.size}.max} end ================================================ FILE: Arcade/Intro/Ruby/almostIncreasingSequence.rb ================================================ def almostIncreasingSequence(sequence) l, lp, c = -100000, l, c = 0 sequence.each do |e| if e <= l c += 1 l = e if e > lp next end lp = l; l = e; end return c <= 1; end ================================================ FILE: Arcade/Intro/Ruby/alphabeticShift.rb ================================================ def alphabeticShift(inputString) return inputString.chars .map{|c| c == 'z' ? 'a' : (c.ord + 1).chr}.join end ================================================ FILE: Arcade/Intro/Ruby/alternatingSums.rb ================================================ def alternatingSums(a) def alternatingSums(a) o = [0, 0] a.size.times{|i| o[(i + 1) % 2 == 0 ? 1 : 0] += a[i]} return o end end ================================================ FILE: Arcade/Intro/Ruby/areEquallyStrong.rb ================================================ def areEquallyStrong(yourLeft, yourRight, friendsLeft, friendsRight) yl, yr, fl, fr = yourLeft, yourRight, friendsLeft, friendsRight return ((yl == fl and yr == fr) or (yr == fl and yl == fr)) end ================================================ FILE: Arcade/Intro/Ruby/areSimilar.rb ================================================ def areSimilar(a, b) c = 0 a.size.times {|i| c += 1 if a[i] != b[i]} return a.sort == b.sort && c < 3 end ================================================ FILE: Arcade/Intro/Ruby/arrayChange.rb ================================================ def arrayChange(inputArray) c = 0 (inputArray.size - 1).times do |i| while inputArray[i + 1] <= inputArray[i] do inputArray[i +1] += 1 c += 1 end end return c end ================================================ FILE: Arcade/Intro/Ruby/arrayMaxConsecutiveSum.rb ================================================ def arrayMaximalAdjacentDifference(inputArray) return (0..(inputArray.size - 2)).to_a .map{|i| (inputArray[i + 1] - inputArray[i]).abs}.max end ================================================ FILE: Arcade/Intro/Ruby/arrayMaximalAdjacentDifference.rb ================================================ def arrayMaxConsecutiveSum(inputArray, k) max = t = 0 (0..(inputArray.size - k)).each do |i| t = (i...(i + k)).to_a.map{|j| inputArray[j]}.sum max = t if t > max end return max end ================================================ FILE: Arcade/Intro/Ruby/arrayReplace.rb ================================================ def arrayReplace(inputArray, elemToReplace, substitutionElem) return inputArray.map{|e| e == elemToReplace ? substitutionElem : e} end ================================================ FILE: Arcade/Intro/Ruby/avoidObstacles.rb ================================================ def avoidObstacles(inputArray) k, i = true, 2 loop do inputArray.each do |e| if e % i == 0 k = !k break end end return i if k k, i = true, i + 1 end end ================================================ FILE: Arcade/Intro/Ruby/bishopAndPawn.rb ================================================ def bishopAndPawn(bishop, pawn) return (bishop[0].ord - pawn[0].ord).abs a== (bishop[1].ord - pawn[1].ord).abs end ================================================ FILE: Arcade/Intro/Ruby/boxBlur.rb ================================================ def boxBlur(image) h, w = image.size - 2, image[0].size - 2 sum = Array.new(h) {Array.new(w,[])} (1..h).each do |i| (1..w).each do |j| c = image[i-1][j-1]+image[i-1][j]+image[i-1][j+1]+ image[i][j-1]+image[i][j]+image[i][j+1]+ image[i+1][j-1]+image[i+1][j]+image[i+1][j+1] sum[i-1][j-1] = c / 9 end end return sum end ================================================ FILE: Arcade/Intro/Ruby/buildPalindrome.rb ================================================ def buildPalindrome(st) return st if st.reverse.eql? st out = sg = "" st.each_char{|ch| return out if (out = st+(sg += ch.to_s).reverse).reverse.eql? out} end ================================================ FILE: Arcade/Intro/Ruby/centuryFromYear.rb ================================================ def centuryFromYear(year) return year / 100 + 1 if(year / 100 * 100 < year) return year / 100 end ================================================ FILE: Arcade/Intro/Ruby/checkPalindrome.rb ================================================ def checkPalindrome(inputString) return inputString.reverse == inputString; end ================================================ FILE: Arcade/Intro/Ruby/chessBoardCellColor.rb ================================================ def chessBoardCellColor(cell1, cell2) x1, x2 = cell1[0].ord, cell1[1].ord y1, y2 = cell2[0].ord, cell2[1].ord return ((x1 + x2) % 2 == (y1 + y2) % 2) end ================================================ FILE: Arcade/Intro/Ruby/chessKnight.rb ================================================ def isSafe(x, y) return (x >= 0 and x < 8 and y >= 0 and y < 8); end def chessKnight(cell) x, y, out = cell[0].ord - 97, cell[1].to_i - 1, 0 out += 1 if isSafe(x + 2, y + 1); out += 1 if isSafe(x + 2, y - 1); out += 1 if isSafe(x - 2, y + 1); out += 1 if isSafe(x - 2, y - 1); out += 1 if isSafe(x + 1, y + 2); out += 1 if isSafe(x - 1, y + 2); out += 1 if isSafe(x + 1, y - 2); out += 1 if isSafe(x - 1, y - 2); return out; end ================================================ FILE: Arcade/Intro/Ruby/circleOfNumbers.rb ================================================ def circleOfNumbers(n, firstNumber) return (firstNumber + n / 2) % n end ================================================ FILE: Arcade/Intro/Ruby/commonCharacterCount.rb ================================================ def commonCharacterCount(s1, s2) q = (0x61..0x7b).to_a.filter{|e| s1.include?(e.chr) && s2.include?(e.chr)} .map{|e| e.chr}.join o = 0 q.chars.each do |e| m = s1.chars.filter{|s| s == e}.length n = s2.chars.filter{|s| s == e}.length o += m < n ? m : n end return o end ================================================ FILE: Arcade/Intro/Ruby/deleteDigit.rb ================================================ def deleteDigit(n) max, s = 0, n.to_s s.size.times do |i| v = (0..s.size).to_a.filter{|j| j != i}.map{|j| s[j]}.join.to_i max = v if v > max end return max end ================================================ FILE: Arcade/Intro/Ruby/depositProfit.rb ================================================ def depositProfit(deposit, rate, threshold) y = 1 loop do return y if (deposit += rate / 100.0 * deposit) >= threshold y += 1 end end ================================================ FILE: Arcade/Intro/Ruby/differentSquares.rb ================================================ def differentSquares(matrix) set = [] (matrix.size - 1).times do |x| (matrix[0].size - 1).times do |y| aux = "" (x..x+1).to_a.each{|i| (y..y+1).to_a.each{|j| aux += matrix[i][j].to_s}} set.push aux if !set.include?(aux) end end return set.size end ================================================ FILE: Arcade/Intro/Ruby/differentSymbolsNaive.rb ================================================ def differentSymbolsNaive(s) s.chars.uniq.size end ================================================ FILE: Arcade/Intro/Ruby/digitDegree.rb ================================================ def digitDegree(n) counter = 0 while n.to_s.size > 1 n = n.to_s.chars.map{|e| e.to_i}.sum counter += 1 end return counter end ================================================ FILE: Arcade/Intro/Ruby/digitsProduct.rb ================================================ def digitsProduct(product) return 10 if product == 0 return product if product < 10 s = ""; 9.downto(2).each do |d| while product % d == 0 s = d.to_s+s product /= d end end return product == 1 ? s.to_i : -1; end ================================================ FILE: Arcade/Intro/Ruby/electionsWinners.rb ================================================ def electionsWinners(votes, k) winners = 0 votes.size.times do |i| win = true votes.size.times do |j| if i != j and votes[i] + k <= votes[j] win = !win break end end winners += 1 if win end return winners end ================================================ FILE: Arcade/Intro/Ruby/evenDigitsOnly.rb ================================================ def evenDigitsOnly(n) return n.to_s.chars.all?{|e| e.to_i % 2 == 0} end ================================================ FILE: Arcade/Intro/Ruby/extractEachKth.rb ================================================ def extractEachKth(inputArray, k) return (0...inputArray.size).to_a .filter{|i| (i + 1) % k != 0}.map{|i| inputArray[i]} end ================================================ FILE: Arcade/Intro/Ruby/fileNaming.rb ================================================ def fileNaming(names) set = [] names.size.times do |i| aux, k = names[i], 1 while set.include? aux aux = names[i]+"("+k.to_s+")" k += 1 end set.push aux end return set end ================================================ FILE: Arcade/Intro/Ruby/findEmailDomain.rb ================================================ def findEmailDomain(address) pieces = address.split /@/ return pieces[pieces.size - 1] end ================================================ FILE: Arcade/Intro/Ruby/firstDigit.rb ================================================ def firstDigit(inputString) return inputString.chars.filter{|e| /\d/.match? e}[0] end ================================================ FILE: Arcade/Intro/Ruby/growingPlant.rb ================================================ def growingPlant(upSpeed, downSpeed, desiredHeight) c = h = 0 loop do h += upSpeed c += 1 break if h >= desiredHeight h -= downSpeed end return c end ================================================ FILE: Arcade/Intro/Ruby/isBeautifulString.rb ================================================ def isBeautifulString(inputString) abc = Array.new(26, 0) inputString.each_byte{|b| abc[b - 97] += 1} 25.times{|i| return false if abc[i + 1] > abc[i]} return true end ================================================ FILE: Arcade/Intro/Ruby/isDigit.rb ================================================ def isDigit(symbol) return symbol.match? /\d/ end ================================================ FILE: Arcade/Intro/Ruby/isIPv4Address.rb ================================================ def isIPv4Address(inputString) split = inputString.split /\./ return false if split.size != 4 split.each do |e| return false if /\d*[a-z]+\d*/.match?(e) or e.size == 0 return false if e.size > 1 and (e[0] == '0' || e.to_i > 255) end return true end ================================================ FILE: Arcade/Intro/Ruby/isLuck.rb ================================================ def isLucky(n) str = n.to_s return str[0...str.size / 2].chars.map{|e| e.to_i}.sum == str[(str.size / 2)..str.size].chars.map{|e| e.to_i}.sum end ================================================ FILE: Arcade/Intro/Ruby/isMAC48Address.rb ================================================ def isMAC48Address(inputString) return /[0-9A-F]{2}(-[0-9A-F]{2}){5}/.match(inputString).to_s.eql?(inputString) end ================================================ FILE: Arcade/Intro/Ruby/isPowerOfTwo2.rb ================================================ def isPowerOfTwo2 n return n > 0 && (n & n - 1) == 0; end ================================================ FILE: Arcade/Intro/Ruby/knapsackLight.rb ================================================ def knapsackLight(value1, weight1, value2, weight2, maxW) return value1 + value2 if maxW >= weight1 + weight2 return value2 if value2 > value1 and maxW >= weight2 return value1 if value1 > value2 and maxW >= weight1 return value1 if maxW >= weight1 return value2 if maxW >= weight2 return 0 end ================================================ FILE: Arcade/Intro/Ruby/lineEncoding.rb ================================================ def lineEncoding(s) subs, aux, prev = [], "", s[0] s.size.times do |i| if s[i] != prev subs.push aux aux = prev = s[i] next end aux += prev = s[i] end subs.push aux return subs.map{|v| v.size > 1 ? v.size.to_s+v[0] : v[0]}.join end ================================================ FILE: Arcade/Intro/Ruby/longestDigitsPrefix.rb ================================================ def longestDigitsPrefix(inputString) out = "" inputString.chars.to_a.each do |c| if /\d/.match? c then out += c else break end end return out; end ================================================ FILE: Arcade/Intro/Ruby/longestWord.rb ================================================ def longestWord(text) return text.gsub(/[^a-zA-Z ]/, " ") .split(/ /).sort{|a, b| b.size <=> a.size}[0] end ================================================ FILE: Arcade/Intro/Ruby/makeArrayConsecutive2.rb ================================================ def makeArrayConsecutive2(statues) return (statues.min..statues.max).to_a.size - statues.size end ================================================ FILE: Arcade/Intro/Ruby/matrixElementsSum.rb ================================================ def matrixElementsSum(matrix) sum = 0 matrix[0].size.times do |i| matrix.size.times do |j| break if matrix[j][i] == 0 sum += matrix[j][i] end end return sum end ================================================ FILE: Arcade/Intro/Ruby/messageFromBinaryCode.rb ================================================ def messageFromBinaryCode(code) return code.split(/(?<=\G.{8})/).map{|v| v.to_i(2).chr}.join end ================================================ FILE: Arcade/Intro/Ruby/palindromeRearranging.rb ================================================ def palindromeRearranging(inputString) abc = Array.new(26, 0) inputString.size.times{|i| abc[inputString[i].ord - "a".ord] += 1} return inputString.size % 2 == abc.map{|e| e % 2 == 1 ? 1 : 0}.sum end ================================================ FILE: Arcade/Intro/Ruby/reverseInParentheses.rb ================================================ def reverseInParentheses(inputString) reg = /\(\w*\)/ return inputString unless reg.match? inputString s = reg.match(inputString).to_s return reverseInParentheses inputString.gsub(s, s[1..(s.size - 2)].reverse) end ================================================ FILE: Arcade/Intro/Ruby/shapeArea.rb ================================================ def shapeArea(n) area = 1 n.downto(1){|e| area += (e - 1) * 4} return area end ================================================ FILE: Arcade/Intro/Ruby/sortByHeight.rb ================================================ def sortByHeight(a) a.size.times do |i| (i..(a.size - 1)).each do |j| if a[i] != -1 && a[j] != -1 if a[i] > a[j] tmp = a[i] a[i] = a[j] a[j] = tmp end end end end return a end ================================================ FILE: Arcade/Intro/Ruby/sudoku.rb ================================================ def sudoku(grid) row, col, box = Array.new(9, 0), Array.new(9, 0), Array.new(9, 0) n = grid.size sqrt = Math.sqrt(n).to_i n.times do |i| n.times do |j| row[grid[i][j] - 1] += 1 col[grid[j][i] - 1] += 1 end sq = i - i % sqrt (sq...(sq + sqrt)).each do |y| (sq...(sq + sqrt)).each{|x| box[grid[y][x] - 1] += 1} end n.times do |j| return false if col[j] == 0 or row[j] == 0 or box[j] == 0 end box = box.fill 0 row = row.fill 0 col = col.fill 0 end return true end ================================================ FILE: Arcade/Intro/Ruby/sumUpNumbers.rb ================================================ def sumUpNumbers(inputString) sum, aux = 0, "" inputString.sub!(/[^\d]/, " ") inputString.size.times do |i| if /\D/.match? inputString[i] sum += aux.to_i aux = "" i -= 1 next end aux += inputString[i] end sum += aux.to_i return sum end ================================================ FILE: Arcade/Intro/Ruby/validTime.rb ================================================ def validTime(time) return (time[0..1].to_i < 24 and time[3..4].to_i < 60) end ================================================ FILE: Arcade/Intro/Ruby/variableName.rb ================================================ def variableName(name) return /^[a-zA-Z_]\w*/.match(name).to_s.eql? name end ================================================ FILE: Arcade/Intro/javascript/absoluteValuesSumMinimization.js ================================================ function absoluteValuesSumMinimization(a) { return a[Math.floor((a.length - 1) / 2)]; } ================================================ FILE: Arcade/Intro/javascript/addBorder.js ================================================ function addBorder(picture) { let border = "*".repeat(picture[0].length + 2), o = [border]; for(let e of picture) o.push("*"+e+"*"); o.push(border); return o; } ================================================ FILE: Arcade/Intro/javascript/adjacentElementsProduct.js ================================================ function adjacentElementsProduct(inputArray) { let max = inputArray[0] * inputArray[1]; for(let i = 0; i < inputArray.length - 1; i++) { let p = inputArray[i] * inputArray[i + 1]; if(p > max) max = p; } return max; } ================================================ FILE: Arcade/Intro/javascript/allLongestStrings.js ================================================ function allLongestStrings(inputArray) { let max = inputArray.map( (e) => e.length) .reduce( (t, e) => t = e > t ? e: t); return inputArray.filter( (e) => e.length == max); } ================================================ FILE: Arcade/Intro/javascript/almostIncreasingSequence.js ================================================ function almostIncreasingSequence(sequence) { let l = -0x186a0, lp = -0x186a0, c = 0; for(let e of sequence) { if(e <= l) { c++; if(e > lp) l = e; continue; } lp = l; l = e; } return c <= 1; } ================================================ FILE: Arcade/Intro/javascript/alphabeticShift.js ================================================ function alphabeticShift(inputString) { let chars = []; for(let c of inputString) { chars.push(c === 'z' ? 'a' : String.fromCharCode((c.charCodeAt(0) + 1))); } return chars.join(""); } ================================================ FILE: Arcade/Intro/javascript/alternatingSums.js ================================================ function alternatingSums(a) { let o = [0, 0]; for(let i in a) o[i % 2 == 0 ? 0 : 1] += a[i]; return o; } ================================================ FILE: Arcade/Intro/javascript/areEquallyStrong.js ================================================ function areEquallyStrong(yourLeft, yourRight, friendsLeft, friendsRight) { let yl = yourLeft, yr = yourRight, fl = friendsLeft, fr = friendsRight; return (yl == fl && yr == fr || yr == fl && yl == fr); } ================================================ FILE: Arcade/Intro/javascript/areSimilar.js ================================================ function areSimilar(a, b) { let c = 0; for(let i in a) if(a[i] != b[i]) c++; a.sort(); b.sort(); for(let i in a) if(a[i] != b[i]) return false; return c < 3; } ================================================ FILE: Arcade/Intro/javascript/arrayChange.js ================================================ function arrayChange(inputArray) { let c = 0; for(let i = 0; i < inputArray.length - 1; i++) { while(inputArray[i + 1] <= inputArray[i]) { inputArray[i + 1]++; c++; } } return c; } ================================================ FILE: Arcade/Intro/javascript/arrayMaxConsecutiveSum.js ================================================ function arrayMaxConsecutiveSum(inputArray, k) { let max = 0, t = 0; for(let i = 0; i <= inputArray.length - k; i++, t = 0) { for(let j = i; j < i + k; j++) t += inputArray[j]; if(t > max) max = t; } return max; } ================================================ FILE: Arcade/Intro/javascript/arrayMaximalAdjacentDifference.js ================================================ function arrayMaximalAdjacentDifference(inputArray) { let max = 0; for(let i = 0; i < inputArray.length - 1; i++) { let t = Math.abs(inputArray[i] - inputArray[i + 1]); if(t > max) max = t; } return max; } ================================================ FILE: Arcade/Intro/javascript/arrayReplace.js ================================================ function arrayReplace(inputArray, elemToReplace, substitutionElem) { return inputArray.map(n => n === elemToReplace ? substitutionElem : n); } ================================================ FILE: Arcade/Intro/javascript/avoidObstacles.js ================================================ function avoidObstacles(inputArray) { let k = true; for(let i = 2; ; i++) { for(let o of inputArray) { if(o % i == 0) { k = !k; break; } } if(k) return i; k = true; } } ================================================ FILE: Arcade/Intro/javascript/bishopAndPawn.js ================================================ function bishopAndPawn(bishop, pawn) { return Math.abs(bishop.charCodeAt(0) - pawn.charCodeAt(0)) == Math.abs(bishop.charCodeAt(1) - pawn.charCodeAt(1)); } ================================================ FILE: Arcade/Intro/javascript/boxBlur.js ================================================ function boxBlur(image) { let h = image.length - 2, w = image[0].length - 2; let sumH = []; for(let i = 1; i <= h; i++) { let sumW = []; for(let j = 1; j <= w; j++) { let c = image[i - 1][j - 1] + image[i - 1][j] + image[i - 1][j + 1]+ image[i][j - 1] + image[i][j] + image[i][j + 1]+ image[i + 1][j - 1] + image[i + 1][j] + image[i + 1][j + 1]; sumW.push(Math.floor(c / 9)); } sumH.push(sumW); } return sumH; } ================================================ FILE: Arcade/Intro/javascript/buildPalindrome.js ================================================ function reverse(s) { let out = ""; for(let i = s.length - 1; i >= 0; i--) out += s[i]; return out; } function buildPalindrome(st) { if(reverse(st) === st) return st; let out = "", sg = ""; for(let ch of st) { out = st+reverse(sg += ch); if(reverse(out) === out) break; } return out; } ================================================ FILE: Arcade/Intro/javascript/centuryFromYear.js ================================================ function centuryFromYear(year) { return Math.floor(1 + (year - 1) / 100); } ================================================ FILE: Arcade/Intro/javascript/checkPalindrome.js ================================================ function checkPalindrome(string) { let str = "" for(let i = string.length; i >= 0; i--) str += string.charAt(i); return str === string; } ================================================ FILE: Arcade/Intro/javascript/chessBoardCellColo.js ================================================ function chessBoardCellColor(cell1, cell2) { let x1 = cell1.charCodeAt(0) - 65, y1 = parseInt(cell1.charAt(1)); let x2 = cell2.charCodeAt(0) - 65, y2 = parseInt(cell2.charAt(1)); return (x1 + x2) % 2 == (y1 + y2) % 2; } ================================================ FILE: Arcade/Intro/javascript/chessKnight.js ================================================ function isSafe(x, y) { return x >= 0 && x < 8 && y >= 0 && y < 8; } function chessKnight(cell) { let x = cell.charCodeAt(0) - 97, y = parseInt(cell[1]) - 1, out = 0; if(isSafe(x + 2, y + 1)) out++; if(isSafe(x + 2, y - 1)) out++; if(isSafe(x - 2, y + 1)) out++; if(isSafe(x - 2, y - 1)) out++; if(isSafe(x + 1, y + 2)) out++; if(isSafe(x - 1, y + 2)) out++; if(isSafe(x + 1, y - 2)) out++; if(isSafe(x - 1, y - 2)) out++; return out; } ================================================ FILE: Arcade/Intro/javascript/circleOfNumbers.js ================================================ function circleOfNumbers(n, firstNumber) { return (n / 2 + firstNumber) % n; } ================================================ FILE: Arcade/Intro/javascript/commonCharacterCount.js ================================================ function commonCharacterCount(s1, s2) { let common = [], o = 0; for(let i = 0x61; i < 0x7b; i++) { let s = String.fromCharCode(i); if(s1.includes(s) && s2.includes(s)) common.push(s); } for(let e of common) { let p = 0, q = 0; for(let v of s1) if(v == e) p++; for(let v of s2) if(v == e) q++; o += Math.min(p, q); } return o; } ================================================ FILE: Arcade/Intro/javascript/deleteDigit.js ================================================ function deleteDigit(n) { let max = 0, idx = [], s = (n+""); for(let i = 0; i < s.length; i++) idx.push(i); for(let i = 0; i < s.length; i++) { let v = parseInt(idx.filter(j => j != i).map(j => s[j]).join("")); if(v > max) max = v; } return max; } ================================================ FILE: Arcade/Intro/javascript/depositProfit.js ================================================ function depositProfit(deposit, rate, threshold) { for(let y = 1; ; y++) { if((deposit += rate / 100 * deposit) >= threshold) return y; } } ================================================ FILE: Arcade/Intro/javascript/differentSquares.js ================================================ function differentSquares(matrix) { let set = []; for(let x = 0; x < matrix.length - 1; x++) { for(let y = 0; y < matrix[0].length - 1; y++) { let aux = ""; for(let i = x; i < x + 2; i++) { for(let j = y; j < y + 2; j++) aux += matrix[i][j]; } if(!set.includes(aux)) set.push(aux); } } return set.length } ================================================ FILE: Arcade/Intro/javascript/differentSymbolsNaive.js ================================================ function differentSymbolsNaive(s) { let set = []; for(let c of s) if(!set.includes(c)) set.push(c); return set.length; } ================================================ FILE: Arcade/Intro/javascript/digitDegree.js ================================================ function digitDegree(n) { let counter = 0; for(let sum = 0; (n+"").length > 1; counter++, sum = 0) { for(let e of (n+"")) sum += parseInt(e); n = sum; } return counter; } ================================================ FILE: Arcade/Intro/javascript/digitsProduct.js ================================================ function digitsProduct(product) { if(product == 0) return 10; if(product < 10) return product; let s = ""; for(let d = 9; d > 1; d--) for(; product % d == 0; product /= d) s = d+s; return product == 1 ? parseInt(s) : -1; } ================================================ FILE: Arcade/Intro/javascript/electionsWinners.js ================================================ function electionsWinners(votes, k) { let winners = 0; for(let i = 0; i < votes.length; i++) { let win = true; for(let j = 0; j < votes.length; j++) { if(j != i && votes[i] + k <= votes[j]) { win = false; break; } } if(win) winners++; } return winners; } ================================================ FILE: Arcade/Intro/javascript/evenDigitsOnly.js ================================================ function evenDigitsOnly(n) { let nums = []; for(let o of n+"") nums.push(o); return nums.every(v => v % 2 == 0); } ================================================ FILE: Arcade/Intro/javascript/extractEachKth.js ================================================ function extractEachKth(inputArray, k) { let indexes = []; for(let i = 0; i < inputArray.length; i++) indexes.push(i); return indexes.filter(i => (i + 1) % k != 0).map(i => inputArray[i]); } ================================================ FILE: Arcade/Intro/javascript/fileNaming.js ================================================ function fileNaming(names) { let set = []; for(let i in names) { let aux = names[i]; for(let k = 1; set.includes(aux); k++) aux = names[i]+"("+k+")"; set.push(aux); } return set; } ================================================ FILE: Arcade/Intro/javascript/findEmailDomain.js ================================================ function findEmailDomain(address) { let pieces = address.split("@"); return pieces[pieces.length - 1]; } ================================================ FILE: Arcade/Intro/javascript/firstDigit.js ================================================ function firstDigit(inputString) { let out = ''; for(let e of inputString) { if(/\d/.test(e)) { out = e; break; } } return out; } ================================================ FILE: Arcade/Intro/javascript/isBeautifulString.js ================================================ function isBeautifulString(inputString) { let abc = [] for(let i = 0; i < 26; i++) abc.push(0); for(let c of inputString) abc[c.codePointAt(0) - 97]++; for(let i = 0; i < 25; i++) if(abc[i + 1] > abc[i]) return false; return true; } ================================================ FILE: Arcade/Intro/javascript/isDigit.js ================================================ function isDigit(symbol) { return /\d/.test(symbol) } ================================================ FILE: Arcade/Intro/javascript/isIPv4Address.js ================================================ function isIPv4Address(inputString) { let split = inputString.split("."); if(split.length != 4) return false; for(let o of split) { let e = o.match("\d*[a-z]+\d*"); if(e != null) if(e[0].length > 0) return false; if(o.length == 0) return false; if(o.length > 1 && (o.charAt(0) == '0' || parseInt(o) > 255)) return false; } return true; } ================================================ FILE: Arcade/Intro/javascript/isLucky.js ================================================ function isLucky(n) { let str = n+"", h1 = [], h2 = []; for(let o of str.substr(0, str.length / 2)) h1.push(parseInt(o)); for(let o of str.substr(str.length / 2, str.length)) h2.push(parseInt(o)); return h1.reduce( (t, v) => t += v) == h2.reduce( (t, v) => t += v); } ================================================ FILE: Arcade/Intro/javascript/isMAC48Address.js ================================================ function isMAC48Address(inputString) { let match = /[0-9A-F]{2}(-[0-9A-F]{2}){5}/.exec(inputString) return match != null ? match[0] === inputString : false } ================================================ FILE: Arcade/Intro/javascript/knapsackLight.js ================================================ function knapsackLight(value1, weight1, value2, weight2, maxW) { if(maxW >= weight1 + weight2) return (value1 + value2); else if(value2 > value1 && maxW >= weight2) return value2; else if(value1 > value2 && maxW >= weight1) return value1; else if(maxW >= weight1) return value1; else if(maxW >= weight2) return value2; return 0; } ================================================ FILE: Arcade/Intro/javascript/lineEncoding.js ================================================ function lineEncoding(s) { let subs = [], prev = s[0], aux = ""; for(let i = 0; i < s.length; i++) { if(s[i] != prev) { subs.push(aux); aux = prev = s[i]; continue; } aux += prev = s[i]; } subs.push(aux); return subs.map(v => ""+(v.length > 1 ? v.length : "")+v.charAt(0)).join(""); } ================================================ FILE: Arcade/Intro/javascript/longestDigitsPrefix.js ================================================ function longestDigitsPrefix(inputString) { let output = ""; for(let c of inputString) { if(/\d/.test(c)) output += c; else break; } return output; } ================================================ FILE: Arcade/Intro/javascript/longestWord.js ================================================ function longestWord(text) { return text.replace(/[^a-zA-Z]/g, " ") .split(" ").reduce((v, c) => c = v.length > c.length ? v : c); } ================================================ FILE: Arcade/Intro/javascript/makeArrayConsecutive2.js ================================================ function makeArrayConsecutive2(statues) { let o = 0; statues.sort((a, b) => b - a); for(let i = 0; i < statues.length - 1; i++) { o += statues[i] - statues[i + 1] - 1; } return o; } ================================================ FILE: Arcade/Intro/javascript/matrixElementsSum.js ================================================ function matrixElementsSum(matrix) { let sum = 0; for(let i = 0; i < matrix[0].length; i++) { for(let j = 0; j < matrix.length; j++) { if(matrix[j][i] == 0) break; sum += matrix[j][i]; } } return sum; } ================================================ FILE: Arcade/Intro/javascript/messageFromBinaryCode.js ================================================ function messageFromBinaryCode(code) { return code.match(/.{8}/g) .map(e => String.fromCharCode(parseInt(e, 2))).join(""); } ================================================ FILE: Arcade/Intro/javascript/minesweeper.js ================================================ function minesweeper(matrix) { let w = matrix[0].length, h = matrix.length; let board = []; for(let i = 0; i < h; i++) { let row = new Array(w); row.fill(0); board.push(row); } for(let i = 0; i < h; i++) { for(let j = 0; j < w; j++) { if(matrix[i][j]) { if(i + 1 < h) board[i + 1][j]++; if(i + 1 < h && j - 1 >= 0) board[i + 1][j - 1]++; if(j - 1 >= 0) board[i][j - 1]++; if(i - 1 >= 0 && j + 1 < w) board[i - 1][j + 1]++; if(i - 1 >= 0) board[i - 1][j]++; if(i - 1 >= 0 && j - 1 >= 0) board[i - 1][j - 1]++; if(j + 1 < w) board[i][j + 1]++; if(i + 1 < h && j + 1 < w) board[i + 1][j + 1]++; } } } return board; } ================================================ FILE: Arcade/Intro/javascript/palindromeRearranging.js ================================================ function palindromeRearranging(inputString) { let abc = []; for(let i = 0; i < 26; i++) abc.push(0); for(let i = 0; i < inputString.length; i++) { abc[inputString.charCodeAt(i) - 97]++; } return inputString.length % 2 == abc.map(n => n % 2 == 1 ? 1 : 0).reduce((t, v) => t + v); } ================================================ FILE: Arcade/Intro/javascript/reverseInParentheses.js ================================================ function reverseString(str) { let o = ""; for(let i = str.length - 1; i >= 0; i--) o += str.charAt(i); return o; } function reverseInParentheses(inputString) { let reg = /\(\w*\)/; if(!reg.test(inputString)) return inputString; let str = reg.exec(inputString)[0], revStr = reverseString(str.substr(1, str.length - 2)); return reverseInParentheses(inputString.replace(str, revStr)); } ================================================ FILE: Arcade/Intro/javascript/shapeArea.js ================================================ function shapeArea(n) { let area = 1; for(let i = n; i > 1; i--) area += (i - 1) * 4; return area; } ================================================ FILE: Arcade/Intro/javascript/sortByHeight.js ================================================ function sortByHeight(a) { for(let i = 0; i < a.length; i++) { for(let j = i + 1; j < a.length; j++) { if(a[i] != -1 && a[j] != -1) { if(a[i] > a[j]) { let tmp = a[i]; a[i] = a[j]; a[j] = tmp; } } } } return a; } ================================================ FILE: Arcade/Intro/javascript/spiralNumbers.js ================================================ function spiralNumbers(n) { let spiral = []; let left = 0, right = n - 1, top = 0, down = n - 1; for(let i = 0; i < n; i++) { let aux = []; for(let j = 0; j < n; j++) aux.push(0); spiral.push(aux); } for(let adder = 1; adder <= n * n; ) { for(let x = left; x <= right; x++) spiral[top][x] = adder++; top++; for(let y = top; y <= down; y++) spiral[y][right] = adder++; right--; for(let x = right; x >= left; x--) spiral[down][x] = adder++; down--; for(let y = down; y >= top; y--) spiral[y][left] = adder++; left++; } return spiral; } ================================================ FILE: Arcade/Intro/javascript/sudoku.js ================================================ function sudoku(grid) { let n = grid.length, sqrt = Math.sqrt(n); let row = new Array(9), col = new Array(9), box = new Array(9); for(let i = 0; i < n; i++) { for(let j = 0; j < n; j++) { row[grid[i][j] - 1]++; col[grid[j][i] - 1]++; } let sq = i - i % sqrt; for(let y = sq; y < sq + sqrt; y++) { for(let x = sq; x < sq + sqrt; x++) box[grid[y][x] - 1]++; } for(let j = 0; j < n; j++) if(row[j] == 0 || col[j] == 0 || box[j] == 0) return false; box.fill(0); row.fill(0); col.fill(0); } return true; } ================================================ FILE: Arcade/Intro/javascript/sumUpNumbers.js ================================================ function sumUpNumbers(inputString) { let sum = 0, aux = ""; for(let i in inputString) { if(/\D/.test(inputString[i])) { if(!isNaN(parseInt(aux))) sum += parseInt(aux); aux = ""; i -= 1; continue; } aux += inputString[i]; } if(!isNaN(parseInt(aux))) sum += parseInt(aux); return sum; } ================================================ FILE: Arcade/Intro/javascript/validTime.js ================================================ function validTime(time) { return parseInt(time[0]+time[1]) < 24 && parseInt(time[3]+time[4]) < 60; } ================================================ FILE: Arcade/Intro/javascript/variableName.js ================================================ function variableName(name) { let test = /^[a-zA-Z_]\w*/.exec(name); return test != null && test[0] === name; } ================================================ FILE: Arcade/TheCore/C++/differentRightmostBit.cpp ================================================ int differentRightmostBit(int n, int m) { return (n ^= m) & -n; } ================================================ FILE: Arcade/TheCore/C++/equalPairOfBits.cpp ================================================ int equalPairOfBits(int n, int m) { return ~(n ^ m) & ((n ^ m) + 1); } ================================================ FILE: Arcade/TheCore/C++/killKthBit.cpp ================================================ #include using std::bitset; int killKthBit(int n, int k) { return bitset<32>(n).set(k % 32 - 1, false).to_ullong(); } ================================================ FILE: Arcade/TheCore/C++/secondRightmostZeroBit.cpp ================================================ int secondRightmostZeroBit(int n) { return ~(n | ( n + 1)) & ((n | (n + 1)) + 1); } ================================================ FILE: Arcade/TheCore/C++/swapAdjacentBits.cpp ================================================ int swapAdjacentBits(int n) { return 0xAAAAAAAA & n << 1 | 0x55555555 & n >> 1; } ================================================ FILE: Arcade/TheCore/Java/AddTwoDigits.java ================================================ final class AddTwoDigits { int addTwoDigits(int n) { return (n+"").chars().map(e -> Integer.parseInt((char)e+"")).sum(); } } ================================================ FILE: Arcade/TheCore/Java/AdditionWithoutCarrying.java ================================================ final class AdditionWithoutCarrying { int additionWithoutCarrying(int param1, int param2) { String p1 = param1 + ""; String p2 = param2 + ""; final int len = Math.max(p1.length(), p2.length()); String result = ""; p1 = "0".repeat(len - p1.length()) + p1; p2 = "0".repeat(len - p2.length()) + p2; for (int i = len - 1; i >= 0; i--) { String aux = ( Integer.parseInt(p1.charAt(i)+"") + Integer.parseInt(p2.charAt(i)+"") )+""; result = aux.charAt(aux.length() - 1) + result; } return Integer.parseInt(result); } } ================================================ FILE: Arcade/TheCore/Java/AppleBoxes.java ================================================ final class AppleBoxes { int appleBoxes(int k) { int yellowApples = 0, redApples = 0; for (int n = 0; n <= k; n++) { if (n % 2 == 0) redApples += n * n; else yellowApples += n * n; } return redApples - yellowApples; } } ================================================ FILE: Arcade/TheCore/Java/ArithmeticExpression.java ================================================ final class ArithmeticExpression { boolean arithmeticExpression(int a, int b, int c) { return a + b == c || a - b == c || a * b == c || a / (b * 1.0) == c; } } ================================================ FILE: Arcade/TheCore/Java/ArrayPacking.java ================================================ final class ArrayPacking { int arrayPacking(int[] a) { String bits = ""; for(int i = a.length - 1; i >= 0; i--) { String _bin = Integer.toString(a[i], 2); bits += "0".repeat(8 - _bin.length()) + _bin; } return Integer.parseInt(bits, 2); } } ================================================ FILE: Arcade/TheCore/Java/ArrayReplace.java ================================================ import java.util.stream.IntStream; final class ArrayReplace { int[] arrayReplace(int[] inputArray, int elemToReplace, int substitutionElem) { return IntStream.of(inputArray) .map(i -> i == elemToReplace ? substitutionElem : i) .toArray(); } } ================================================ FILE: Arcade/TheCore/Java/Candies.java ================================================ final class Candies { int candies(int n, int m) { return m / n * n; } } ================================================ FILE: Arcade/TheCore/Java/Candles.java ================================================ final class Candles { int candles(int candlesNumber, int makeNew) { int leftovers = 0, totalCandles = 0; while (candlesNumber >= 1) { candlesNumber--; leftovers++; totalCandles++; if (leftovers == makeNew) { candlesNumber++; leftovers = 0; } } return totalCandles; } } ================================================ FILE: Arcade/TheCore/Java/CircleOfNumbers.java ================================================ final class CircleOfNumbers { int circleOfNumbers(int n, int firstNumber) { return (firstNumber + n / 2) % n; } } ================================================ FILE: Arcade/TheCore/Java/ComfortableNumbers.java ================================================ import java.util.function.ToIntFunction; final class ComfortableNumbers { int comfortableNumbers(int l, int r) { final ToIntFunction s = n -> (n+"").chars().map(i -> Integer.parseInt((((char) i)+""))).sum(); int pairs = 0; for (int i = l; i < r; i++) for (int j = i + 1; j <= r; j++) if (i >= j - s.applyAsInt(j+"") && i <= j + s.applyAsInt(j+"") && j >= i - s.applyAsInt(i+"") && j <= i + s.applyAsInt(i+"")) pairs++; return pairs; } } ================================================ FILE: Arcade/TheCore/Java/ConcatenateArrays.java ================================================ final class ConcatenateArrays { int[] concatenateArrays(int[] a, int[] b) { return IntStream.concat(IntStream.of(a), IntStream.of(b)).toArray(); } } ================================================ FILE: Arcade/TheCore/Java/CountBlackCells.java ================================================ final class CountBlackCells { int gcd(int a, int b) { if (a == 0) return b; if (b == 0) return a; return a > b ? gcd(a % b, b) : gcd(a, b % a); } int countBlackCells(int n, int m) { if (n == m) return n + 2 * (n - 1); if (n == 1 || m == 1) return n * m; return n + m - gcd(n, m) + (gcd(n, m) - 1) * 2; } } ================================================ FILE: Arcade/TheCore/Java/CountSumOfTwoRepresentations2.java ================================================ final class CountSumOfTwoRepresentations2 { int countSumOfTwoRepresentations2(int n, int l, int r) { if (2 * r < n || 2 * l > n) return 0; double min = Math.max(l, n - r); double max = Math.min(r, n - l); return (int)(Math.floor((max + min) / 2) - min) + 1; } } ================================================ FILE: Arcade/TheCore/Java/CreateArray.java ================================================ final class CreateArray { int[] createArray(int size) { return IntStream.range(0, size).map(i -> 1).toArray(); } } ================================================ FILE: Arcade/TheCore/Java/ExtraNumber.java ================================================ final class ExtraNumber { int extraNumber(int a, int b, int c) { return a == b ? c : a == c ? b : a; } } ================================================ FILE: Arcade/TheCore/Java/FirstReverseTry.java ================================================ final class FirstReverseTry { int[] firstReverseTry(int[] arr) { if (arr.length > 0) { int tmp = arr[0]; arr[0] = arr[arr.length - 1]; arr[arr.length - 1] = tmp; } return arr; } } ================================================ FILE: Arcade/TheCore/Java/IncreaseNumberRoundness.java ================================================ final class IncreaseNumberRoundness { boolean increaseNumberRoundness(int n) { return (n+"").matches(".*0[1-9].*"); } } ================================================ FILE: Arcade/TheCore/Java/IsInfiniteProcess.java ================================================ final class IsInfiniteProcess { boolean isInfiniteProcess(int a, int b) { return !((a < b && (int) Math.abs(a - b) % 2 == 0) || a == b); } } ================================================ FILE: Arcade/TheCore/Java/IsPower.java ================================================ final class IsPower { boolean isPower(int n) { if (n == 1) return true; for (int p = 2; p < n; p++) { for (int q = 2; q < n; q++) { if (Math.pow(p, q) > n) break; if (Math.pow(p, q) == n) return true; } } return false; } } ================================================ FILE: Arcade/TheCore/Java/IsSmooth.java ================================================ final class IsSmooth { boolean isSmooth(int[] arr) { int l = arr.length; if (l == 1) return true; int middle = switch (l % 2) { case 0 -> arr[l / 2] + arr[l / 2 - 1]; default -> arr[l / 2]; }; return arr[0] == middle && arr[l - 1] == middle; } } ================================================ FILE: Arcade/TheCore/Java/IsSumOfConsecutive2.java ================================================ final class IsSumOfConsecutive2 { int isSumOfConsecutive2(int n) { int ways = 0; for (int i = 1; i <= n; i++) { int sum = i; for (int j = i + 1; j < n; j++) { if ((sum += j) > n) break; else if (sum == n) ways++; } } return ways; } } ================================================ FILE: Arcade/TheCore/Java/KnapsackLight.java ================================================ final class KnapsackLight { int knapsackLight(int value1, int weight1, int value2, int weight2, int maxW) { if(maxW >= weight1 + weight2) return (value1 + value2); else if(value2 > value1 && maxW >= weight2) return value2; else if(value1 > value2 && maxW >= weight1) return value1; else if(maxW >= weight1) return value1; else if(maxW >= weight2) return value2; return 0; } } ================================================ FILE: Arcade/TheCore/Java/LargestNumber.java ================================================ final class LargestNumber { int largestNumber(int n) { return Integer.parseInt("9".repeat(n)); } } ================================================ FILE: Arcade/TheCore/Java/LateRide.java ================================================ final class LateRide { int lateRide(int n) { return ((n / 60)+""+(n % 60)).chars() .map(e -> Integer.parseInt((char)e+"")).sum(); } } ================================================ FILE: Arcade/TheCore/Java/LeastFactorial.java ================================================ final class LeastFactorial { int fact(int n) { return n == 1 ? n : n * fact(n - 1); } int leastFactorial(int n) { for (int i = 1; true; i++) { int f = fact(i); if (f >= n) return f; } } } ================================================ FILE: Arcade/TheCore/Java/LineUp.java ================================================ final class LineUp { int lineUp(String commands) { int count = 0; int smartStudent = 0; int dumbStudent = 0; for (char c : commands.toCharArray()) { switch (c) { case 'L', 'R' -> { smartStudent++; dumbStudent--; } case 'A' -> { smartStudent = smartStudent + 2; dumbStudent = dumbStudent + 2; } } smartStudent = smartStudent < 0 ? smartStudent + 4 : smartStudent % 4; dumbStudent = dumbStudent < 0 ? dumbStudent + 4 : dumbStudent % 4; if (smartStudent == dumbStudent) count++; } return count; } } ================================================ FILE: Arcade/TheCore/Java/MagicalWell.java ================================================ final class MagicalWell { int magicalWell(int a, int b, int n) { int dolar = 0; for (int i = 0; i < n; i++) dolar += a++ * b++; return dolar; } } ================================================ FILE: Arcade/TheCore/Java/MakeArrayConsecutive2.java ================================================ final class MakeArrayConsecutive2 { int makeArrayConsecutive2(int[] statues) { Arrays.sort(statues); final int max = statues[statues.length - 1]; final int min = statues[0]; int additionalStatues = 0; for (int statue = min; statue <= max; statue++) if (Arrays.binarySearch(statues, statue) < 0) additionalStatues++; return additionalStatues; } } ================================================ FILE: Arcade/TheCore/Java/MaxMultiple.java ================================================ final class MaxMultiple { // recursive int maxMultiple(int divisor, int bound) { if(bound % divisor == 0) return bound; return maxMultiple(divisor, bound -= 1); } } ================================================ FILE: Arcade/TheCore/Java/MetroCard.java ================================================ final class MetroCard { int[] metroCard(int lastNumberOfDays) { return lastNumberOfDays == 31 ? new int[]{28, 30, 31} : new int[]{31}; } } ================================================ FILE: Arcade/TheCore/Java/MirrorBits.java ================================================ final class MirrorBits { int mirrorBits(int a) { return Integer.parseInt( new StringBuilder(Integer.toString(a, 2)).reverse()+"", 2 ); } } ================================================ FILE: Arcade/TheCore/Java/PagesNumberingWithInk.java ================================================ final class PagesNumberingWithInk { int pagesNumberingWithInk(int current, int numberOfDigits) { while(numberOfDigits >= (current+"").length()) numberOfDigits -= ((current++)+"").length(); return current - 1; } } ================================================ FILE: Arcade/TheCore/Java/PhoneCall.java ================================================ final class PhoneCall { int phoneCall(int min1, int min2_10, int min11, int s) { int min = 0, q = 9; if(s >= min1) { s -= min1; min++; } for(int i = 0; i < 9; i++) { if(s >= min2_10) { s -= min2_10; min++; q--; } } if(q == 0) { while(s >= min11) { s -= min11; min++; } } return min; } } ================================================ FILE: Arcade/TheCore/Java/RangeBitCount.java ================================================ import java.util.stream.IntStream; final class RangeBitCount { int rangeBitCount(int a, int b) { return IntStream.range(a, b + 1) .reduce( 0, (t, i) -> t + Integer.toString(i, 2) .replaceAll("0", "").length() ); } } ================================================ FILE: Arcade/TheCore/Java/ReachNextLevel.java ================================================ final class ReachNextLevel { boolean reachNextLevel(int experience, int threshold, int reward) { return reward + experience >= threshold; } } ================================================ FILE: Arcade/TheCore/Java/RectangleRotation.java ================================================ final class RectangleRotation { int solution(int a, int b) { double aBisect = a / Math.sqrt(2) / 2; double bBisect = b / Math.sqrt(2) / 2; int[] rect1 = new int[] { ((int) Math.floor(aBisect)) * 2 + 1, ((int) Math.floor(bBisect)) * 2 + 1 }; int[] rect2 = new int[] { aBisect - Math.floor(aBisect) < 0.5 ? rect1[0] - 1 : rect1[0] + 1, bBisect - Math.floor(bBisect) < 0.5 ? rect1[1] - 1 : rect1[1] + 1 }; return rect1[0] * rect1[1] + rect2[0] * rect2[1]; } } ================================================ FILE: Arcade/TheCore/Java/RemoveArrayPart.java ================================================ final class RemoveArrayPart { int[] removeArrayPart(int[] inputArray, int l, int r) { return IntStream.range(0, inputArray.length) .filter(i -> i < l || i > r) .map(i -> inputArray[i]).toArray(); } } ================================================ FILE: Arcade/TheCore/Java/ReplaceMiddle.java ================================================ final class ReplaceMiddle { int[] replaceMiddle(int[] arr) { if (arr.length % 2 > 0) return arr; int sum = arr[arr.length / 2 - 1] + arr[arr.length / 2]; arr[arr.length / 2 - 1] = sum; return IntStream.range(0, arr.length) .filter(i -> i != arr.length / 2) .map(i -> arr[i]).toArray(); } } ================================================ FILE: Arcade/TheCore/Java/Rounders.java ================================================ final class Rounders { int rounders(int n) { int[] digits = (n+"").chars() .map(c -> Integer.parseInt(((char) c)+"")).toArray(); for (int i = digits.length - 1; i >= 1; i--) { if (digits[i] >= 5) digits[i - 1]++; digits[i] = 0; } return Integer.parseInt(Arrays.toString(digits).replaceAll("\\D", "")); } } ================================================ FILE: Arcade/TheCore/Java/SeatsInTheater.java ================================================ final class SeatsInTheater { int seatsInTheater(int nCols, int nRows, int col, int row) { return (nCols - col + 1) * (nRows - row); } } ================================================ FILE: Arcade/TheCore/Java/SquareDigitsSequence.java ================================================ import java.util.Set; import java.util.HashSet; import java.util.stream.Stream; final class SquareDigitsSequence { int squareDigitsSequence(int a0) { final Set set = new HashSet<>(); for (int elem = a0; set.add(elem); ) { final int sum = Stream.of((elem+"").split("")) .mapToInt(Integer::parseInt) .map(n -> n * n).sum(); elem = sum; } return set.size() + 1; } } ================================================ FILE: Arcade/TheCore/Java/TennisSet.java ================================================ final class TennisSet { boolean tennisSet(int score1, int score2) { return (score1 > score2) ? (score1 == 7 && (score2 == 5 || score2 == 6)) || (score1 == 6 && (score2 < 5 && score2 >= 0)) : (score2 == 7 && (score1 == 5 || score1 == 6)) || (score2 == 6 && (score1 < 5 && score1 >= 0)); } } ================================================ FILE: Arcade/TheCore/Java/WeakNumbers.java ================================================ import java.util.stream.IntStream; import java.util.function.IntUnaryOperator; final class WeakNumbers { int[] weakNumbers(int n) { final IntUnaryOperator divisors = x -> (int) IntStream.rangeClosed(1, x).filter(i -> x % i == 0).count(); final int[] weaknessSet = IntStream.rangeClosed(1, n).map(x -> { final int d = divisors.applyAsInt(x); return (int) IntStream.rangeClosed(1, x - 1) .filter(i -> divisors.applyAsInt(i) > d).count(); }).toArray(); final int weakestNumber = IntStream.of(weaknessSet).max().getAsInt(); return new int[] { weakestNumber, (int) IntStream.of(weaknessSet) .filter(it -> it == weakestNumber).count() }; } } ================================================ FILE: Arcade/TheCore/Java/WillYou.java ================================================ final class WillYou { boolean willYou(boolean young, boolean beautiful, boolean loved) { return (young && beautiful && !loved) || (loved && (!young || !beautiful)); } } ================================================ FILE: Arcade/TheCore/Javascript/addTwoDigits.js ================================================ function addTwoDigits(n) { let out = 0; for(let d of (n+"")) out += parseInt(d); return out; } ================================================ FILE: Arcade/TheCore/Javascript/additionWithoutCarrying.js ================================================ function additionWithoutCarrying(param1, param2) { let p1 = param1+""; let p2 = param2+""; let result = ""; const len = Math.max(p1.length, p2.length) p1 = "0".repeat(len - p1.length) + p1; p2 = "0".repeat(len - p2.length) + p2; for (let i = len - 1; i >= 0; i--) { const aux = (parseInt(p1[i]) + parseInt(p2[i]))+""; result = aux[aux.length - 1] + result; } return parseInt(result); } ================================================ FILE: Arcade/TheCore/Javascript/appleBoxes.js ================================================ function appleBoxes(k) { let yellowApples = 0; let redApples = 0; for (let n = 1; n <= k; n++) { if (n % 2 == 0) redApples += n * n; else yellowApples += n * n; } return redApples - yellowApples; } ================================================ FILE: Arcade/TheCore/Javascript/arithmeticExpression.js ================================================ function arithmeticExpression(a, b, c) { return a + b == c || a - b == c || a * b == c || a / b == c; } ================================================ FILE: Arcade/TheCore/Javascript/arrayPacking.js ================================================ function arrayPacking(a) { return parseInt( a.map(v => v.toString(2)) .reverse() .map(e => "0".repeat(8 - e.length) + e) .join(""), 2 ); } ================================================ FILE: Arcade/TheCore/Javascript/arrayReplace.js ================================================ function arrayReplace(inputArray, elemToReplace, substitutionElem) { return inputArray.map(i => i == elemToReplace ? substitutionElem : i) } ================================================ FILE: Arcade/TheCore/Javascript/candies.js ================================================ function candies(n, m) { return Math.floor(m / n) * n; } ================================================ FILE: Arcade/TheCore/Javascript/candles.js ================================================ function candles(candlesNumber, makeNew) { let leftovers = 0; let totalCandles = 0; while (candlesNumber >= 1) { candlesNumber--; leftovers++ totalCandles++; if (leftovers == makeNew) { candlesNumber++; leftovers = 0; } } return totalCandles; } ================================================ FILE: Arcade/TheCore/Javascript/circleOfNumbers.js ================================================ function circleOfNumbers(n, firstNumber) { return (firstNumber + n / 2) % n; } ================================================ FILE: Arcade/TheCore/Javascript/comfortableNumbers.js ================================================ function s(n) { return [...n+""].map(i => +i).reduce((t, a) => t + a) } function comfortableNumbers(l, r) { let pairs = 0; for (let i = l; i < r; i++) for (let j = i + 1; j <= r; j++) if (i >= j - s(j) && i <= j + s(j) && j >= i - s(i) && j <= i + s(i)) pairs++; return pairs; } ================================================ FILE: Arcade/TheCore/Javascript/concatenateArrays.js ================================================ function concatenateArrays(a, b) { return [...a, ...b] } ================================================ FILE: Arcade/TheCore/Javascript/countBlackCells.js ================================================ function gcd(a, b) { if (a == 0) return b if (b == 0) return a return a > b ? gcd(a % b, b) : gcd(a, b % a) } function countBlackCells(n, m) { if (n == m) return n + 2 * (n - 1) if (n == 1 || m == 1) return n * m return n + m - gcd(n, m) + (gcd(n, m) - 1) * 2 } ================================================ FILE: Arcade/TheCore/Javascript/countSumOfTwoRepresentations2.js ================================================ function countSumOfTwoRepresentations2(n, l, r) { if (2 * r < n || 2 * l > n) return 0; let min = Math.max(l, n - r); let max = Math.min(r, n - l); let mid = Math.floor((max + min) / 2); return mid - min + 1; } ================================================ FILE: Arcade/TheCore/Javascript/createArray.js ================================================ function createArray(size) { return Array(size).fill(1) } ================================================ FILE: Arcade/TheCore/Javascript/differentRightmostBit.js ================================================ function differentRightmostBit(n, m) { return Math.pow(2, [...(n ^ m).toString(2)].reverse().findIndex(v => v == 1)); } ================================================ FILE: Arcade/TheCore/Javascript/extraNumber.js ================================================ function extraNumber(a, b, c) { return a == b ? c : a == c ? b : a; } ================================================ FILE: Arcade/TheCore/Javascript/firstReverseTry.js ================================================ function firstReverseTry(arr) { Array.prototype.swp = function(i, j) { const tmp = this[i] this[i] = this[j] this[j] = tmp }; if (arr.length > 0) arr.swp(0, arr.length - 1) return arr } ================================================ FILE: Arcade/TheCore/Javascript/increaseNumberRoundness.js ================================================ function increaseNumberRoundness(n) { // Array.prototype.swap = function(i, j) { // const tmp = this[i]; // this[i] = this[j]; // this[j] = tmp; // } // const s = [...n+""]; // for (let i = 0; i < s.length; i++) { // if (s[i] === "0") { // for (let j = i + 1; j < s.length; j++) { // s.swap(i, j); // if (parseInt(s.join("")) > n) return true; // } // } // } // return false; return /0[1-9]/.test(n); } ================================================ FILE: Arcade/TheCore/Javascript/isInfiniteProcess.js ================================================ function isInfiniteProcess(a, b) { return !((a < b && Math.abs(a - b) % 2 == 0) || a == b); } ================================================ FILE: Arcade/TheCore/Javascript/isPower.js ================================================ function isPower(n) { if (n == 1) return true; for (let m = 2; m <= n; m++) { for (let e = 2; e <= n; e++) { if (Math.pow(m, e) > n) break; if (Math.pow(m, e) == n) return true; } } return false } ================================================ FILE: Arcade/TheCore/Javascript/isSmooth.js ================================================ function isSmooth(arr) { const l = arr.length if (l == 1) return true let middle if (l % 2 == 0) middle = arr[l / 2] + arr[l / 2 - 1] else middle = arr[Math.floor(l / 2)] return arr[0] == middle && arr[l - 1] == middle } ================================================ FILE: Arcade/TheCore/Javascript/isSumOfConsecutive2.js ================================================ function isSumOfConsecutive2(n) { let ways = 0; for (let i = 1; i <= n; i++) { let sum = i; for (let j = i + 1; j <= n; j++) { if ((sum += j) > n) break else if (sum == n) ways++ } } return ways; } ================================================ FILE: Arcade/TheCore/Javascript/knapsackLight.js ================================================ function knapsackLight(value1, weight1, value2, weight2, maxW) { if (maxW >= weight1 + weight2) return (value1 + value2); else if (value2 > value1 && maxW >= weight2) return value2; else if (value1 > value2 && maxW >= weight1) return value1; else if (maxW >= weight1) return value1; else if (maxW >= weight2) return value2; return 0; } ================================================ FILE: Arcade/TheCore/Javascript/largestNumber.js ================================================ function largestNumber(n) { let out = ""; for(let i = 0; i < n; i++) out += "9"; return parseInt(out); } ================================================ FILE: Arcade/TheCore/Javascript/lateRide.js ================================================ function lateRide(n) { let sum = 0; for(let s of (Math.floor(n / 60)+""+(n % 60))) sum += parseInt(s); return sum; } ================================================ FILE: Arcade/TheCore/Javascript/leastFactorial.js ================================================ function fact(n) { if (n == 1) return n; return n * fact(n - 1); } function leastFactorial(n) { for (let i = 1; true; i++) { let f = fact(i) if (f >= n) return f; } } ================================================ FILE: Arcade/TheCore/Javascript/lineUp.js ================================================ function lineUp(commands) { let count = 0; let smartStudent = 0; let dumbStudent = 0; for (let c of commands) { if (c === "L" || c === "R") { smartStudent--; dumbStudent++; } else if (c === "A") { smartStudent = smartStudent + 2; dumbStudent = dumbStudent + 2; } smartStudent = smartStudent < 0 ? smartStudent + 4 : smartStudent % 4; dumbStudent = dumbStudent < 0 ? dumbStudent + 4 : dumbStudent % 4; if (smartStudent == dumbStudent) count++; } return count; } ================================================ FILE: Arcade/TheCore/Javascript/magicalWell.js ================================================ function magicalWell(a, b, n) { let dolar = 0 for (let i = 0; i < n; i++) dolar += a++ * b++ return dolar } ================================================ FILE: Arcade/TheCore/Javascript/makeArrayConsecutive2.js ================================================ function makeArrayConsecutive2(statues) { const min = Math.min.apply(null, statues) const max = Math.max.apply(null, statues) let additionalStatues = 0 for (let statue = min; statue <= max; statue++) if (!statues.includes(statue)) additionalStatues++ return additionalStatues } ================================================ FILE: Arcade/TheCore/Javascript/maxMultiple.js ================================================ function maxMultiple(divisor, bound) { if(bound % divisor == 0) return bound; return maxMultiple(divisor, bound -= 1); } ================================================ FILE: Arcade/TheCore/Javascript/metroCard.js ================================================ function metroCard(lastNumberOfDays) { return lastNumberOfDays == 31 ? [28, 30, 31] : [31]; } ================================================ FILE: Arcade/TheCore/Javascript/mirrorBits.js ================================================ function mirrorBits(a) { return parseInt([...a.toString(2)].reverse().join(""), 2) } ================================================ FILE: Arcade/TheCore/Javascript/pagesNumberingWithInk.js ================================================ function pagesNumberingWithInk(current, numberOfDigits) { while (numberOfDigits >= (current+"").length) numberOfDigits -= ((current++)+"").length return current - 1; } ================================================ FILE: Arcade/TheCore/Javascript/phoneCall.js ================================================ function phoneCall(min1, min2_10, min11, s) { let min = 0, q = 9; if(s >= min1) { s -= min1; min++; } for(let i = 0; i < 9; i++) { if(s >= min2_10) { s -= min2_10; min++; q--; } } if(q == 0) { while(s >= min11) { s -= min11; min++; } } return min; } ================================================ FILE: Arcade/TheCore/Javascript/rangeBitCount.js ================================================ function rangeBitCount(a, b) { let count = 0; for (let i = a; i <= b; i++) count += i.toString(2).replaceAll("0", "").length return count; } ================================================ FILE: Arcade/TheCore/Javascript/reachNextLevel.js ================================================ function reachNextLevel(experience, threshold, reward) { return reward + experience >= threshold; } ================================================ FILE: Arcade/TheCore/Javascript/rectangleRotation.js ================================================ function solution(a, b) { const aBisect = (a / Math.sqrt(2)) / 2 const bBisect = (b / Math.sqrt(2)) / 2 const rect1 = [Math.floor(aBisect) * 2 + 1, Math.floor(bBisect) * 2 + 1] const rect2 = [ aBisect - Math.floor(aBisect) < 0.5 ? rect1[0] - 1 : rect1[0] + 1, bBisect - Math.floor(bBisect) < 0.5 ? rect1[1] - 1 : rect1[1] + 1 ] return rect1[0] * rect1[1] + rect2[0] * rect2[1] } ================================================ FILE: Arcade/TheCore/Javascript/removeArrayPart.js ================================================ function removeArrayPart(inputArray, l, r) { return inputArray.filter((v, i) => i < l || i > r) } ================================================ FILE: Arcade/TheCore/Javascript/replaceMiddle.js ================================================ function replaceMiddle(arr) { if (arr.length % 2 == 0) arr.splice( arr.length / 2 - 1, 2, arr[arr.length / 2] + arr[arr.length / 2 - 1] ) return arr } ================================================ FILE: Arcade/TheCore/Javascript/rounders.js ================================================ function rounders(n) { const digits = [...n+""].map(i => parseInt(i)) for (let i = digits.length - 1; i >= 1; i--) { if (digits[i] >= 5) digits[i - 1]++; digits[i] = 0; } return parseInt(digits.join("")); } ================================================ FILE: Arcade/TheCore/Javascript/seatsInTheater.js ================================================ function seatsInTheater(nCols, nRows, col, row) { return (nCols - col + 1) * (nRows - row); } ================================================ FILE: Arcade/TheCore/Javascript/squareDigitsSequence.js ================================================ function squareDigitsSequence(a0) { const seq = [a0] while (true) { const sum = [...seq[0]+""] .map(i => Math.pow(+i, 2)) .reduce((total, curr) => total + curr); if (seq.includes(sum)) break; seq.unshift(sum); } return seq.length + 1; } ================================================ FILE: Arcade/TheCore/Javascript/tennisSet.js ================================================ function tennisSet(score1, score2) { return (score1 > score2) ? (score1 == 7 && (score2 == 5 || score2 == 6)) || (score1 == 6 && (score2 < 5 && score2 >= 0)) : (score2 == 7 && (score1 == 5 || score1 == 6)) || (score2 == 6 && (score1 < 5 && score1 >= 0)) } ================================================ FILE: Arcade/TheCore/Javascript/weakNumbers.js ================================================ function divisors(n) { let d = 0; for (let i = 1; i <= n; i++) if (n % i == 0) d++; return d; } function weakness(n) { let lvl = 0; const d = divisors(n); for (let i = 1; i < n; i++) if (divisors(i) > d) lvl++; return lvl; } function weakNumbers(n) { const weaknessSet = [] for (let i = 1; i <= n; i++) weaknessSet.push(weakness(i)) const weakestNumber = weaknessSet.reduce((prev, acc) => prev < acc ? acc : prev); return [ weakestNumber, weaknessSet.filter(i => i == weakestNumber).length ] } ================================================ FILE: Arcade/TheCore/Javascript/willYou.js ================================================ function willYou(young, beautiful, loved) { return (young && beautiful && !loved) || (loved && (!young || !beautiful)); } ================================================ FILE: Arcade/TheCore/Kotlin/addTwoDigits.kt ================================================ fun addTwoDigits(n: Int): Int { return n.toString().sumBy { it.toString().toInt() } } ================================================ FILE: Arcade/TheCore/Kotlin/additionWithoutCarrying.kt ================================================ fun additionWithoutCarrying(param1: Int, param2: Int): Int { var p1: String = param1.toString(); var p2: String = param2.toString(); val len: Int = Math.max(p1.length, p2.length); var result: String = ""; p1 = "0".repeat(len - p1.length) + p1; p2 = "0".repeat(len - p2.length) + p2; (len - 1 downTo 0).forEach { result = (p1[it].toString().toInt() + p2[it].toString().toInt()) .toString().last().toString() + result; } return result.toInt(); } ================================================ FILE: Arcade/TheCore/Kotlin/appleBoxes.kt ================================================ fun appleBoxes(k: Int): Int { var redApples: Int = 0; var yellowApples: Int = 0; (1..k).forEach { if (it % 2 == 0) redApples += it * it; else yellowApples += it * it; } return redApples - yellowApples; } ================================================ FILE: Arcade/TheCore/Kotlin/arithmeticExpression.kt ================================================ fun arithmeticExpression(a: Int, b: Int, c: Int) = a + b == c || a - b == c || a * b == c || a.toDouble() / b.toDouble() == c.toDouble() ================================================ FILE: Arcade/TheCore/Kotlin/arrayPacking.kt ================================================ fun arrayPacking(a: MutableList): Int { return Integer.parseInt( a.map { it.toString(2) } .reversed() .joinToString( separator = "", transform = { "0".repeat(8 - it.length) + it } ), 2 ) } ================================================ FILE: Arcade/TheCore/Kotlin/arrayReplace.kt ================================================ fun arrayReplace(inputArray: MutableList, elemToReplace: Int, substitutionElem: Int): MutableList { return inputArray .map { if (elemToReplace == it) substitutionElem else it }.toMutableList() } ================================================ FILE: Arcade/TheCore/Kotlin/candies.kt ================================================ fun candies(n: Int, m: Int) = m / n * n ================================================ FILE: Arcade/TheCore/Kotlin/candles.kt ================================================ fun candles(candlesNumber: Int, makeNew: Int): Int { var leftovers: Int = 0; var totalCandles: Int = 0; var candlesToBurn: Int = candlesNumber; while (candlesToBurn >= 1) { candlesToBurn--; leftovers++; totalCandles++; if (leftovers == makeNew) { candlesToBurn++; leftovers = 0; } } return totalCandles; } ================================================ FILE: Arcade/TheCore/Kotlin/circleOfNumbers.kt ================================================ fun circleOfNumbers(n: Int, firstNumber: Int) = (firstNumber + n / 2) % n ================================================ FILE: Arcade/TheCore/Kotlin/comfortableNumbers.kt ================================================ fun comfortableNumbers(l: Int, r: Int): Int { fun Int.s(): Int = (""+this).sumOf { (""+it).toInt() }; var pairs: Int = 0; (l..r).forEach { i -> ((i + 1)..r).forEach { j -> if (i in ((j - j.s())..(j + j.s())) && j in ((i - i.s())..(i + i.s()))) pairs++; } }; return pairs; } ================================================ FILE: Arcade/TheCore/Kotlin/concatenateArrays.kt ================================================ fun concatenateArrays(a: MutableList, b: MutableList) = a + b ================================================ FILE: Arcade/TheCore/Kotlin/countBlackCells.kt ================================================ fun gcd(a: Int, b: Int): Int { if (a == 0) return b; if (b == 0) return a; return if (a > b) gcd(a % b, b) else gcd(a, b % a); } fun countBlackCells(n: Int, m: Int): Int { if (n == m) return n + 2 * (n - 1); if (n == 1 || m == 1) return n * m; return n + m - gcd(n, m) + (gcd(n, m) - 1) * 2; } ================================================ FILE: Arcade/TheCore/Kotlin/countSumOfTwoRepresentations2.kt ================================================ fun countSumOfTwoRepresentations2(n: Int, l: Int, r: Int): Int { if (2 * r < n || 2 * l > n) return 0; val min: Double = Math.max(l.toDouble(), n.toDouble() - r.toDouble()); val max: Double = Math.min(r.toDouble(), n.toDouble() - l.toDouble()); return ((Math.floor((max + min) / 2.0) - min) + 1.0).toInt(); } ================================================ FILE: Arcade/TheCore/Kotlin/createArray.kt ================================================ fun createArray(size: Int): MutableList = MutableList(size) { 1 } ================================================ FILE: Arcade/TheCore/Kotlin/extraNumber.kt ================================================ fun extraNumber(a: Int, b: Int, c: Int) = if (a == b) c else if (a == c) b else a; ================================================ FILE: Arcade/TheCore/Kotlin/firstReverseTry.kt ================================================ fun firstReverseTry(arr: MutableList): MutableList { fun MutableList.swp(i: Int, j: Int): Unit { val tmp: T = this[i]; this[i] = this[j]; this[j] = tmp; }; if (arr.isNotEmpty()) arr.swp(0, arr.size - 1) return arr; } ================================================ FILE: Arcade/TheCore/Kotlin/increaseNumberRoundness.kt ================================================ fun increaseNumberRoundness(n: Int) = Regex("0[1-9]").containsMatchIn(n.toString()); ================================================ FILE: Arcade/TheCore/Kotlin/isInfiniteProcess.kt ================================================ fun isInfiniteProcess(a: Int, b: Int) = !((a < b && Math.abs(a - b) % 2 == 0) || a == b); ================================================ FILE: Arcade/TheCore/Kotlin/isPower.kt ================================================ fun isPower(n: Int): Boolean { if (n == 1) return true; outer@ for (i: Int in (2..n)) { for(j: Int in (2..n)) { val q: Int = Math.pow(i.toDouble(), j.toDouble()).toInt(); if (q > n) continue@outer if (q == n) return true } } return false; } ================================================ FILE: Arcade/TheCore/Kotlin/isSmooth.kt ================================================ fun isSmooth(arr: MutableList): Boolean { val l: Int = arr.size if (l == 1) return true var middle: Int = when (l % 2) { 0 -> arr[l / 2] + arr[l / 2 - 1] else -> arr[l / 2] } return arr[0] == middle && arr.last() == middle } ================================================ FILE: Arcade/TheCore/Kotlin/isSumOfConsecutive2.kt ================================================ fun isSumOfConsecutive2(n: Int): Int { var ways: Int = 0; outer@ for (i: Int in (1..n)) { var sum: Int = i; for (j: Int in ((i + 1)..n)) { sum += j; if (sum > n) continue@outer else if (sum == n) ways++; } } return ways; } ================================================ FILE: Arcade/TheCore/Kotlin/knapsackLight.kt ================================================ fun knapsackLight(value1: Int, weight1: Int, value2: Int, weight2: Int, maxW: Int): Int { if (maxW >= weight1 + weight2) return (value1 + value2); else if (value2 > value1 && maxW >= weight2) return value2; else if (value1 > value2 && maxW >= weight1) return value1; else if (maxW >= weight1) return value1; else if (maxW >= weight2) return value2; return 0; } ================================================ FILE: Arcade/TheCore/Kotlin/largestNumber.kt ================================================ fun largestNumber(n: Int) = (1..n).map { "9" }.joinToString("").toInt() ================================================ FILE: Arcade/TheCore/Kotlin/lateRide.kt ================================================ fun lateRide(n: Int) = "${n / 60}${n % 60}".sumBy { it.toString().toInt() } ================================================ FILE: Arcade/TheCore/Kotlin/leastFactorial.kt ================================================ fun fact(n: Int): Int = if (n == 1) n else n * fact(n - 1) fun leastFactorial(n: Int): Int { var i: Int = 1 while(true) { val f: Int = fact(i) if (f >= n) return f i++ } } ================================================ FILE: Arcade/TheCore/Kotlin/lineUp.kt ================================================ fun lineUp(commands: String): Int { var count: Int = 0; var smartStudent: Int = 0; var dumbStudent: Int = 0; commands.forEach { when (it) { 'L', 'R' -> { smartStudent++; dumbStudent--; } 'A' -> { smartStudent = smartStudent + 2; dumbStudent = dumbStudent + 2; } } smartStudent = if (smartStudent < 0) smartStudent + 4 else smartStudent % 4; dumbStudent = if (dumbStudent < 0) dumbStudent + 4 else dumbStudent % 4; if (smartStudent == dumbStudent) count++; } return count; } ================================================ FILE: Arcade/TheCore/Kotlin/magicalWell.kt ================================================ fun magicalWell(a: Int, b: Int, n: Int): Int = if (n == 0) 0 else a * b + magicalWell(a + 1, b + 1, n - 1) ================================================ FILE: Arcade/TheCore/Kotlin/makeArrayConsecutive2.kt ================================================ fun makeArrayConsecutive2(statues: MutableList): Int { val max: Int = statues.maxOf { it } val min: Int = statues.minOf { it } var additionalStatues = 0; (min..max).forEach({ statue -> if (!(statue in statues)) additionalStatues++ }); return additionalStatues; } ================================================ FILE: Arcade/TheCore/Kotlin/maxMultiple.kt ================================================ fun maxMultiple(divisor: Int, bound: Int): Int = if (bound % divisor == 0) bound else maxMultiple(divisor, bound - 1) ================================================ FILE: Arcade/TheCore/Kotlin/metroCard.kt ================================================ fun metroCard(lastNumberOfDays: Int) = if (lastNumberOfDays == 31) mutableListOf(28, 30, 31) else mutableListOf(31) ================================================ FILE: Arcade/TheCore/Kotlin/mirrorBits.kt ================================================ fun mirrorBits(a: Int) = Integer.parseInt(a.toString(2).reversed(), 2) ================================================ FILE: Arcade/TheCore/Kotlin/pagesNumberingWithInk.kt ================================================ fun pagesNumberingWithInk(current: Int, numberOfDigits: Int): Int { var lastPage: Int = current; var ink: Int = numberOfDigits; while (ink >= (""+lastPage).length) ink -= (""+lastPage++).length return lastPage - 1; } ================================================ FILE: Arcade/TheCore/Kotlin/phoneCall.kt ================================================ fun phoneCall(min1: Int, min2_10: Int, min11: Int, s: Int): Int { var min: Int = 0 var q: Int = 9 var p: Int = s if (p >= min1) { p -= min1; min++; } (1..9).forEach { if (p >= min2_10) { p -= min2_10; min++; q--; } } if(q == 0) { while(p >= min11) { p -= min11; min++; } } return min; } ================================================ FILE: Arcade/TheCore/Kotlin/rangeBitCount.kt ================================================ fun rangeBitCount(a: Int, b: Int) = (a..b) .fold(0, { t, i -> Integer.toString(i, 2).replace("0", "").length + t }) ================================================ FILE: Arcade/TheCore/Kotlin/reachNextLevel.kt ================================================ fun reachNextLevel(experience: Int, threshold: Int, reward: Int) = reward + experience >= threshold ================================================ FILE: Arcade/TheCore/Kotlin/rectangleRotation.kt ================================================ fun solution(a: Int, b: Int): Int { val aBisect: Double = (a / Math.sqrt(2.0)) / 2 val bBisect: Double = (b / Math.sqrt(2.0)) / 2 val rect1: Array = arrayOf( Math.floor(aBisect).toInt() * 2 + 1, Math.floor(bBisect).toInt() * 2 + 1 ) val rect2: Array = arrayOf( if (aBisect - Math.floor(aBisect) < 0.5) rect1[0] - 1 else rect1[0] + 1, if (bBisect - Math.floor(bBisect) < 0.5) rect1[1] - 1 else rect1[1] + 1 ) return rect1[0] * rect1[1] + rect2[0] * rect2[1] } ================================================ FILE: Arcade/TheCore/Kotlin/removeArrayPart.kt ================================================ fun removeArrayPart(inputArray: MutableList, l: Int, r: Int) = inputArray.filterIndexed { i, v -> i < l || i > r } ================================================ FILE: Arcade/TheCore/Kotlin/replaceMiddle.kt ================================================ fun replaceMiddle(arr: MutableList): MutableList { if (arr.size % 2 == 0) { val sum: Int = arr[arr.size / 2 - 1] + arr[arr.size / 2]; arr[arr.size / 2 - 1] = sum; arr.removeAt(arr.size / 2); } return arr; } ================================================ FILE: Arcade/TheCore/Kotlin/rounders.kt ================================================ fun rounders(n: Int): Int { val s: String = n.toString(); val digits: IntArray = IntArray(s.length) { Integer.parseInt(s[it].toString()) } (digits.size - 1 downTo 1).forEach { if (digits[it] >= 5) digits[it - 1]++; digits[it] = 0; } return Integer.parseInt(digits.joinToString("")); } ================================================ FILE: Arcade/TheCore/Kotlin/seatsInTheater.kt ================================================ fun seatsInTheater(nCols: Int, nRows: Int, col: Int, row: Int) = (nCols - col + 1) * (nRows - row) ================================================ FILE: Arcade/TheCore/Kotlin/squareDigitsSequence.kt ================================================ fun squareDigitsSequence(a0: Int): Int { val seq: MutableList = mutableListOf(a0); while (true) { val sum: Int = (""+seq[0]) .map { Math.pow((""+it).toInt().toDouble(), 2.0) } .sumOf { it.toInt() } if (sum in seq) break; seq.add(0, sum); } return seq.size + 1; } ================================================ FILE: Arcade/TheCore/Kotlin/tennisSet.kt ================================================ fun tennisSet(score1: Int, score2: Int) = if (score1 > score2) { (score1 == 7 && (score2 == 5 || score2 == 6)) || (score1 == 6 && (score2 < 5 && score2 >= 0)) } else (score2 == 7 && (score1 == 5 || score1 == 6)) || (score2 == 6 && (score1 < 5 && score1 >= 0)) ================================================ FILE: Arcade/TheCore/Kotlin/weakNumbers.kt ================================================ fun weakNumbers(n: Int): MutableList { fun Int.divisors(): Int = (1..this).count { this % it == 0 }; fun Int.weakness(): Int { val d: Int = this.divisors(); return (1..(this - 1)).count { d < it.divisors() } }; val weaknessSet: List = (1..n).map { it.weakness() }; val weakestNumber: Int = weaknessSet.maxOf { it.toDouble() }.toInt(); return mutableListOf( weakestNumber, weaknessSet.count { it == weakestNumber } ); } ================================================ FILE: Arcade/TheCore/Kotlin/willYou.kt ================================================ fun willYou(young: Boolean, beautiful: Boolean, loved: Boolean) = (young && beautiful && !loved) || (loved && (!young || !beautiful)) ================================================ FILE: Challenges/Java/AddTwoDigits.java ================================================ public final class AddTwoDigits { int addTwoDigits(int n) { int sum = 0; for(char c : (n+"").toCharArray()) { sum += new Integer(c+""); } return sum; } } ================================================ FILE: Challenges/Java/AddTwoHugeNumbers.java ================================================ final class AddTwoHugeNumbers { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } ListNode addTwoHugeNumbers(ListNode a, ListNode b) { ListNode result = new ListNode(0); ListNode head = result; int carry = 0; a = reverse(a); b = reverse(b); while(a != null || b != null){ if(a != null){ carry += a.value; a = a.next; } if(b != null){ carry += b.value; b = b.next; } head.next = new ListNode(carry % 10000); head = head.next; carry = carry / 10000; } if(carry >= 1) head.next= new ListNode(carry); return reverse(result.next); } ListNode reverse(ListNode head){ ListNode prev = null; while(head != null){ ListNode temp = head.next; head.next = prev; prev = head; head = temp; } return prev; } } ================================================ FILE: Challenges/Java/AdditionWithoutCarrying.java ================================================ public final class AdditionWithoutCarrying { int additionWithoutCarrying(int a, int b) { int s = 0, t = 1; while(s < t) { s += t * (a / t + b / t) % (t *= 10); } return s; } } ================================================ FILE: Challenges/Java/AmendTheSentence.java ================================================ final class AmendTheSentence { String amendTheSentence(String s) { String output = ""; for(String x : s.split("(?=[A-Z])")) { output += x+" "; } return output.trim().toLowerCase(); } } ================================================ FILE: Challenges/Java/Bomber.java ================================================ final class Bomber { int deadEnemies(char[][] field, int x, int y) { int deads = 0; for(int j = x; j < field[0].length; j++) { if(field[y][j] == 'E') deads++; if(field[y][j] == 'W') break; } for(int j = y; j < field.length; j++) { if(field[j][x] == 'E') deads++; if(field[j][x] == 'W') break; } for(int j = x; j >= 0; j--) { if(field[y][j] == 'E') deads++; if(field[y][j] == 'W') break; } for(int j = y; j >= 0; j--) { if(field[j][x] == 'E') deads++; if(field[j][x] == 'W') break; } return deads; } int bomber(char[][] field) { int max = 0; for(int i = 0; i < field.length; i++) { for(int j = 0; j < field[0].length; j++) { if(field[i][j] == '0') { int tmp = deadEnemies(field, j, i); if(tmp > max) max = tmp; } } } return max; } } ================================================ FILE: Challenges/Java/CampusCup.java ================================================ import java.util.Map; import java.util.HashMap; import java.util.stream.Stream; final class CampusCup { String[] campusCup(String[] emails) { Map points = new HashMap<>(); emails = Stream.of(emails) .map(e -> e.replaceFirst("^[a-z.]++@", "")) .toArray(String[]::new); for(String s : emails) { if(points.containsKey(s)) points.put(s, points.get(s) + 20); else points.put(s, 20); } for(String s : points.keySet()) { int p = points.get(s).intValue(); if(p >= 100 && p < 200) p = 3; else if(p >= 200 && p < 300) p = 8; else if(p >= 300 && p < 400) p = 15; else if(p >= 500) p = 25; else p = 0; points.put(s, p); } return points.entrySet().stream() .sorted((a, b) -> a.getKey().compareTo(b.getKey())) .sorted((i, j) -> j.getValue().compareTo(i.getValue())) .map(v -> v.getKey()) .toArray(String[]::new); } } ================================================ FILE: Challenges/Java/CatalogUpdate.java ================================================ import java.util.*; import java.util.stream.*; final class CatalogUpdate { String[][] catalogUpdate(String[][] catalog, String[][] updates) { List> out = new Vector<>(); Map> category = new HashMap<>(); for(int i = 0; i < catalog.length; i++) category.put(catalog[i][0], new Vector<>()); for(int i = 0; i < catalog.length; i++) { for(int j = 1; j < catalog[i].length; j++) category.get(catalog[i][0]).add(catalog[i][j]); } for(int i = 0; i < updates.length; i++) { if(category.containsKey(updates[i][0])) { for(int j = 1; j < updates[i].length; j++) category.get(updates[i][0]).add(updates[i][j]); continue; } category.put(updates[i][0], new Vector<>()); for(int j = 1; j < updates[i].length; j++) category.get(updates[i][0]).add(updates[i][j]); } int index = 0; for(Map.Entry> me : category.entrySet()) { out.add(new Vector<>()); out.get(index).add(me.getKey()); for(String s : me.getValue().stream().sorted().toArray(String[]::new)) out.get(index).add(s); index++; } return out.stream().map(e -> e.toArray(String[]::new)) .sorted( (a, b) -> a[0].compareTo(b[0])).toArray(String[][]::new); } } ================================================ FILE: Challenges/Java/CharacterParity.java ================================================ final class CharacterParity { String characterParity(char symbol) { if(symbol >= '0' && symbol <= '9') return symbol % 2 == 0 ? "even" : "odd"; return "not a digit"; } } ================================================ FILE: Challenges/Java/ChristmasTree.java ================================================ final class ChristmasTree { String[] christmasTree(int ln, int lh) { Vector tree = new Vector<>(ln * lh + ln + 3); String line = "", blank = ""; // tree's crown for(int i = 0, p = ln + lh; i < 3; i++) { for(int j = 0; j < p - 1; j++) blank += " "; tree.add(i != 2 ? blank+" "+"*" : blank+"***"); blank = ""; } // tree's body for(int i = 0, p = 5, n = lh + ln - 2; i < ln; i++, p += 2, n--) { for(int j = 0, q = p, m = n; j < lh; j++, q += 2, m--) { for(int w = 0; w < q; w++) line += "*"; for(int w = 0; w < m; w++) blank += " "; tree.add(blank+line); line = blank = ""; } } // tree's foot for(int i = 0, p = (tree.get(tree.size() - 1).length() - lh) / 2; i < ln; i++) { for(int w = 0; w < lh; w++) line += "*"; for(int w = 0; w < p; w++) blank += " "; tree.add(blank+(lh % 2 == 0 ? line+"*": line)); line = blank = ""; } return tree.toArray(new String[tree.size()]); } } ================================================ FILE: Challenges/Java/ClassifyStrings.java ================================================ import java.util.regex.Matcher; import java.util.regex.Pattern; public final class ClassifyStrings { String check(String s) { Pattern reg = Pattern.compile("[aeiou]{3}|[^aeiou]{5}"); return (reg.matcher(s).find() ? "bad" : "good"); } String classifyStrings(String s) { String res = ""; if(!s.contains("?")) { res = check(s); } else { String s1 = check(s.replace("?", "a")); String s2 = check(s.replace("?", "n")); if(s.length() > 4 && s.contains("???")) { res = "mixed"; } else if(s1.equals("bad") && s2.equals("bad")) { res = "bad"; } else if(s1.equals("good") && s2.equals("good")) { res = "good"; } else { res = "mixed"; } } return res; } } ================================================ FILE: Challenges/Java/ClosestInTree.java ================================================ final class ClosestInTree { // // Binary trees are already defined with this interface: // class Tree { // Tree(T x) { // value = x; // } // T value; // Tree left; // Tree right; // } void recTree(Tree t, Vector v) { v.add(t.value); if(t.left != null) recTree(t.left, v); if(t.right != null) recTree(t.right, v); } int btsTree(Tree t, int n) { Vector v = new Vector<>(); recTree(t, v); v.sort((a, b) -> a.compareTo(b)); int l = v.size(); if(n >= v.get(l - 1)) return v.get(l - 1); if(n <= v.get(0)) return v.get(0); int mid = 0; for(int i = 0, j = l; i < j;) { mid = (i + j) / 2; if(v.get(mid) == n) return v.get(mid); if(n < v.get(mid)) { if(mid > 0 && n > v.get(mid - 1)) { return getClosest(v.get(mid - 1), v.get(mid), n); } j = mid; continue; } if(mid < l - 1 && n < v.get(mid + 1)) { return getClosest(v.get(mid), v.get(mid + 1), n); } i = mid + 1; } return v.get(mid); } int getClosest(int n1, int n2, int i) { return i - n1 >= n2 - i ? n2 : n1; } int closestInTree(Tree t, int n) { int o = btsTree(t, n); return o - 1 == n ? o - 2 : o; } } ================================================ FILE: Challenges/Java/CommonCharacterCount2.java ================================================ public final class CommonCharacterCount2 { int commonCharacterCount2(String[] s) { int output = 0; Set set = new HashSet<>(); for(int i = 97, k = 0; i <= 122; i++, k = 0) { for(String str : s) { if(!str.contains(((char)i)+"")) { k++; break; } } if(k == 0) { set.add((char)i); } } for(char x : set) { int min = 0; for(String str : s) { int count = 0; for(char y : str.toCharArray()) { if(x == y) { count++; } } min = count < min ? count : min == 0 ? count : min; } output += min; } return output; } } ================================================ FILE: Challenges/Java/CompanyBotStrategy.java ================================================ public final class CompanyBotStrategy { double companyBotStrategy(int[][] trainingData) { int q = 0; double sum = 0d; for(int[] i : trainingData) { if(i[1] == 1) { q++; sum += i[0]; } } return q > 0 ? sum / q : 0; } } ================================================ FILE: Challenges/Java/ComposeRanges.java ================================================ public final class ComposeRanges { String[] composeRanges(int[] n) { List> set = new ArrayList<>(); List ran = new ArrayList<>(); String[] out = null; int l = 0; for(int i = 0; i < n.length - 1; i++) { if(i == 0) ran.add(n[i]); if(n[i + 1] - n[i] == 1 || n[i + 1] - n[i] == 0) { ran.add(n[i + 1]); } else { set.add(ran); ran = new ArrayList<>(); ran.add(n[i + 1]); } if(i == n.length - 2) set.add(ran); } l = set.size(); out = new String[l]; for(int i = 0; i < l; i++) { ran = set.get(i); out[i] = ran.size() > 1 ? ran.get(0)+"->"+ran.get(ran.size() - 1) : ran.get(0)+""; } return out; } } ================================================ FILE: Challenges/Java/ContainsCloseNums.java ================================================ final class ContainsCloseNums { boolean containsCloseNums(int[] nums, int k) { for(int i = 0; i < nums.length; i++) { for(int j = i + 1; j < nums.length; j++) { if(nums[i] == nums[j]) { if(Math.abs(i - j) <= k) return true; } } } return false; } } ================================================ FILE: Challenges/Java/ContainsDuplicates.java ================================================ final class ContainsDuplicates { boolean containsDuplicates(int[] a) { return Arrays.stream(a).distinct().toArray().length != a.length; } } ================================================ FILE: Challenges/Java/CorrectNonogram.java ================================================ import java.util.ArrayList; final class CorrectNonogram { boolean correctNonogram(int size, String[][] nonogramField) { int len = (size + 1) / 2, sz = len + size, c = 0; ArrayList row = new ArrayList(); ArrayList col = new ArrayList(); for(int x = (size + 1) / 2; x < sz; x++) { String val = "", reg = ""; for(int y = 0; y < sz; y++) { row.add(nonogramField[x][y]); col.add(nonogramField[y][x]); } for(int i = len; i < sz; i++) { val += row.get(i); } int d = 0; for(int i = 0; i < len; i++) { if(d == 0) { if(row.get(i).matches("\\d+")) { reg += "#{"+row.get(i)+"}"; d++; } } else { if(row.get(i).matches("\\d+")) { reg += ".+#{"+row.get(i)+"}"; } } } if(!val.matches("\\.*"+reg+"\\.*")) { c++; } reg = val = ""; d = 0; for(int i = len; i < sz; i++) { val += col.get(i); } for(int i = 0; i < len; i++) { if(d == 0) { if(col.get(i).matches("\\d+")) { reg += "#{"+col.get(i)+"}"; d++; } } else { if(col.get(i).matches("\\d+")) { reg += ".+#{"+col.get(i)+"}"; } } } if(!val.matches("\\.*"+reg+"\\.*")) { c++; } col.clear(); row.clear(); } return c == 0; } } ================================================ FILE: Challenges/Java/CountClouds.java ================================================ final class CountClouds { int n, m; void checker(char sky[][], int i, int j) { sky[i][j] = '*'; if(j + 1 < m && sky[i][j + 1] == '1') checker(sky, i, j + 1); if(i + 1 < n && sky[i + 1][j] == '1') checker(sky, i + 1, j); if(j - 1 >= 0 && sky[i][j - 1] == '1') checker(sky, i, j - 1); if(i - 1 >= 0 && sky[i - 1][j] == '1') checker(sky, i - 1, j); } int countClouds(char[][] skyMap) { int u = 0; n = skyMap.length; m = n > 0 ? skyMap[0].length : 0; for(int i = 0; i < n; i++) { for(int j = 0; j < m; j++) { if(skyMap[i][j] == '1') { checker(skyMap, i, j); u++; } } } return u; } } ================================================ FILE: Challenges/Java/DayOfWeek.java ================================================ import java.util.Calendar; final class DayOfWeek { int dayOfWeek(String birthdayDate) { Calendar date = Calendar.getInstance(); int[] fields = Arrays.stream(birthdayDate.split("-")) .mapToInt(n -> new Integer(n)).toArray(); int week = 0, year = fields[2] + 1; date.set(Calendar.YEAR, fields[2]); date.set(Calendar.MONTH, fields[0] - 1); date.set(Calendar.DAY_OF_MONTH, fields[1]); week = date.get(Calendar.DAY_OF_WEEK); if(fields[1] == 29) { for(;; year++) { date.set(Calendar.YEAR, year); if(year % 4 == 0 && year % 100 != 0) { date.set(Calendar.DAY_OF_MONTH, 29); if(date.get(Calendar.DAY_OF_WEEK) == week) break; } } } else { for(;; year++) { date.set(Calendar.YEAR, year); if(date.get(Calendar.DAY_OF_WEEK) == week) break; } } return year - fields[2]; } } ================================================ FILE: Challenges/Java/DomainType.java ================================================ final class DomainType { String[] domainType(String[] domains) { Map dMap = new HashMap<>() { { put("com", "commercial"); put("org", "organization"); put("net", "network"); put("info", "information"); } }; return Stream.of(domains).map(e -> { Matcher m = Pattern.compile("(?<=\\.)[a-z]+$").matcher(e); return m.find() ? m.group() : ""; }) .map(e -> dMap.get(e)) .toArray(String[]::new); } } ================================================ FILE: Challenges/Java/DrawRectangle.java ================================================ final class DrawRectangle { char[][] drawRectangle(char[][] canvas, int[] rect) { for(int i = rect[1]; i <= rect[3]; i++) { for(int j = rect[0]; j <= rect[2]; j++) { if((i == rect[1] && j == rect[0]) || (i == rect[1] && j == rect[2]) || (i == rect[3] && j == rect[0]) || (i == rect[3] && j == rect[2])) canvas[i][j] = '*'; if((i > rect[1] && i < rect[3]) && (j == rect[0] || j == rect[2])) canvas[i][j] = '|'; if((j > rect[0] && j < rect[2]) && (i == rect[1] || i == rect[3])) canvas[i][j] = '-'; } } return canvas; } } ================================================ FILE: Challenges/Java/EquilibriumPoint.java ================================================ final class EquilibriumPoint { int equilibriumPoint(int[] a) { int before = 0, after = Arrays.stream(a).sum(); for(int i = 0; i < a.length; i++) { before += i == 0 ? 0 : a[i - 1]; after = a[i] < 0 ? after + a[i] * -1 : after - a[i]; if(before == after) return i + 1; } return -1; } } ================================================ FILE: Challenges/Java/ExcelSheetColumnNumber.java ================================================ public final class ExcelSheetColumnNumber { int excelSheetColumnNumber(String s) { int sum = 0, l = s.length() - 1; for(int i = 0; i < s.length(); i++, l--) { int a = (byte)s.charAt(i) - 64; for(int j = 0; j < l; j++) { a *= 26; } sum += a; } return sum; } } ================================================ FILE: Challenges/Java/FancyRide.java ================================================ import java.util.Arrays; public final class FancyRide { String fancyRide(int l, double[] fares) { String[] options = {"UberX", "UberXL", "UberPlus", "UberBlack", "UberSUV"}; int i = 0; Arrays.sort(fares); for(; i < fares.length; i++) if(fares[i] * l > 20) break; return options[i > 0 ? i - 1 : 0]; } } ================================================ FILE: Challenges/Java/FareEstimator.java ================================================ import java.util.stream.IntStream; final class FareEstimator { double[] fareEstimator(int ride_time, int ride_distance, double[] cost_per_minute, double[] cost_per_mile) { return IntStream.range(0, cost_per_mile.length) .mapToDouble(i -> cost_per_minute[i] * ride_time + cost_per_mile[i] * ride_distance) .toArray(); } } ================================================ FILE: Challenges/Java/FileNaming.java ================================================ public final class FileNaming { String[] fileNaming(String[] names) { List list = new ArrayList(); for(int i = 0; i < names.length; i++) { if(!list.contains(names[i])) { list.add(names[i]); continue; } String s = names[i]; for(int n = 1; list.contains(s); n++) { s = names[i]+"("+n+")"; } list.add(s); } return list.toArray(new String[list.size()]); } } ================================================ FILE: Challenges/Java/FindMiddleElement.java ================================================ final class FindMiddleElement { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // int findMiddleElement(ListNode l) { int counter = 0; for(ListNode ref = l; ref != null; ref = ref.next) counter++; for(int i = 0; l != null && i < counter / 2; l = l.next, i++); return l.value; } } ================================================ FILE: Challenges/Java/FindSubarrayBySum.java ================================================ final class FindSubarrayBySum { int[] findSubarrayBySum(int s, int[] arr) { for(int i = 0; i < arr.length; i++) { int sum = 0; for(int j = i; j < arr.length; j++) if((sum += arr[j]) == s) return new int[]{i + 1, j + 1}; } return new int[]{-1}; } } ================================================ FILE: Challenges/Java/FractionReducing.java ================================================ final class FractionReducing { int[] fractionReducing(int[] fraction) { int[] res = new int[2]; for(int i = 1; i < 10; i++) { if(fraction[0] % i == 0 && fraction[1] % i == 0) { res[0] = fraction[0] / i; res[1] = fraction[1] / i; } } return res; } } ================================================ FILE: Challenges/Java/GiftSafety.java ================================================ public final class GiftSafety { int giftSafety(String gift) { int c = 0; String[] perms = new String[gift.length() - 2]; for(int i = 0; i < perms.length; i++) { String s = ""; for(int j = i; j < i + 3; j++) { s += gift.charAt(j)+""; } perms[i] = s; } for(String str : perms) { String s = ""; for(char ch : str.toCharArray()) { if(!s.contains(ch+"")) { s += ch+""; } else { c++; break; } } } return c; } } ================================================ FILE: Challenges/Java/HappyNumber.java ================================================ import java.util.Set; import java.util.HashSet; final class HappyNumber { boolean happyNumber(int n) { Set set = new HashSet<>(); while(set.add(n)) { int v = (n+"").chars().map(e -> new Integer(((char) e)+"")) .map(e -> e * e).sum(); if(v == 1) return true; else n = v; } return false; } } ================================================ FILE: Challenges/Java/HigherVersion2.java ================================================ final class HigherVersion2 { int higherVersion2(String a, String b) { String[] r1 = a.split("\\."); String[] r2 = b.split("\\."); for(int i = 0; ; i++) { try { int t1 = new Integer(r1[i]), t2 = new Integer(r2[i]); if(t1 > t2) { return 1; } if(t1 < t2) { return -1; } } catch(Exception e) { return 0; } } } } ================================================ FILE: Challenges/Java/InsertBits.java ================================================ public final class InsertBits { int insertBits(int n, int a, int b, int k) { String bn = new StringBuilder(Integer.toBinaryString(n)) .reverse().toString(), bk = new StringBuilder(Integer.toBinaryString(k)) .reverse().toString(), s = ""; for(int i = 0, l = bn.length(); i < 31 - l; i++) bn += "0"; for(int i = 0, l = bk.length(); i < 31 - l; i++) bk += "0"; for(int x = 0, y = -1; x < bn.length(); x++) { if(x >= a && x <= b && y != bk.length() - 1) { y++; s += bk.charAt(y); continue; } s += bn.charAt(x); } return Integer.parseInt(new StringBuilder(s).reverse().toString(), 2); } } ================================================ FILE: Challenges/Java/IsListPalindrome.java ================================================ import java.util.Vector; final class IsListPalindrome { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // boolean isListPalindrome(ListNode l) { Vector vec = new Vector<>(); for(; l != null; l = l.next) vec.add(l.value); int[] items = vec.stream().mapToInt(n -> n).toArray(); for(int right = 0, left = items.length - 1; left >= 0; right++, left--) if(items[right] != items[left]) return false; return true; } } ================================================ FILE: Challenges/Java/IsPowerOfTwo2.java ================================================ public final class IsPowerOfTwo2 { boolean isPowerOfTwo2(long n) { return n > 0 && (n & n - 1) == 0; } } ================================================ FILE: Challenges/Java/JumpingJimmy.java ================================================ public class JumpingJimmy { int jumpingJimmy(int[] tower, int jumpHeight) { int back = 0; for (int i : tower) { if (jumpHeight >= i) { back += i; continue; } break; } return back; } } ================================================ FILE: Challenges/Java/KthLargestElement.java ================================================ import java.util.Arrays; public final class KthLargestElement { int kthLargestElement(int[] n, int k) { Arrays.sort(n); return n[n.length - k]; } } ================================================ FILE: Challenges/Java/LongestCommonSubstring.java ================================================ import java.util.regex.Pattern; import java.util.regex.Matcher; public final class LongestCommonSubstring { int longestCommonSubstring(String s, String t) { int out = 0; Matcher mt = null; for(int x = 1, y = 0; x <= t.length(); x++) { String z = t.substring(y, x); mt = Pattern.compile(z).matcher(s); if(mt.find()) { int c = mt.group().length(); out = (c > out) ? c : out; System.out.println(z); continue; } y = (out > 1) ? x - 1 : x; } return out; } public static void main(String[] args) { String s = "abcdxyz"; String t = "xyzabcd"; int res = new LongestCommonSubstring().longestCommonSubstring(s, t); System.out.println(res); // it shows 4 } } ================================================ FILE: Challenges/Java/Lrc2subRip.java ================================================ public final class Lrc2subRip { String formatConverter(String str) { String[] v = str.replace('.', ':').split(":"); String hh = "00", mm = v[0]; int tmp = Integer.valueOf(mm).intValue(); if(tmp - 60 >= 0) { hh = "01"; tmp -= 60; mm = (tmp < 10) ? "0"+tmp+"" : tmp+""; } return hh+":"+mm+":"+v[1]+","+v[2]+"0"; } String[] lrc2subRip(String[] lrcLyrics, String songLength) { int len = lrcLyrics.length; String[] times = new String[len]; String[] lyrics = new String[len]; ArrayList output = new ArrayList(); songLength = songLength+",000"; for(int i = 0; i < len; i++) { times[i] = lyrics[i] = ""; for(char ch : lrcLyrics[i].toCharArray()) { if(ch != '[') { if(ch == ']') { break; } else { times[i] += ch+""; } } } times[i] = formatConverter(times[i]); int k = -1; for(char c : lrcLyrics[i].toCharArray()) { if(k == 0) { lyrics[i] += c+""; } if(c == ' ') { k = 0; } } } for(int i = 0; i < len; i++) { output.add((i + 1)+""); output.add(times[i]+" --> "+((i != len - 1) ? times[i + 1] : songLength)); output.add(lyrics[i]); if(i != len - 1) { output.add(""); } } return output.toArray(new String[output.size()]); } } ================================================ FILE: Challenges/Java/LunchSequenceChecker.java ================================================ import java.util.Map; import java.util.HashMap; import java.util.Vector; final class LaunchSequenceChecker { boolean launchSequenceChecker(String[] systemNames, int[] stepNumbers) { Map> map = new HashMap<>(); for(String s : systemNames) map.put(s, new Vector<>()); for(int i = 0; i < stepNumbers.length; i++) map.get(systemNames[i]).add(stepNumbers[i]); for(Vector v : map.values()) for(int i = 0; i < v.size() - 1; i++) if(v.get(i) >= v.get(i + 1)) return false; return true; } } ================================================ FILE: Challenges/Java/MaximumSum.java ================================================ final class MaximumSum { int max; void swap(int[] arr, int i, int j) { int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; } void permute(int[] arr, int l, int h, int[][] q) { if(l == h) { int sum = 0; for(int[] e : q) for(int i = e[0]; i <= e[1]; i++) sum += arr[i]; if(max < sum) max = sum; return; } for(int i = l; i <= h; i++) { swap(arr, l, i); permute(arr, l + 1, h, q); swap(arr, l, i); } } int maximumSum(int[] a, int[][] q) { permute(a, 0, a.length - 1, q); return max; } } ================================================ FILE: Challenges/Java/MergeTwoLinkedLists.java ================================================ final class MergeTwoLinkedLists { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // ListNode append(ListNode ln, int data) { if(ln == null) { ln = new ListNode(data); return ln; } ListNode n = ln; while(n.next != null) { n = n.next; } n.next = new ListNode(data); return ln; } ListNode mergeTwoLinkedLists(ListNode l1, ListNode l2) { ArrayList list = new ArrayList(); Integer[] nums = null; ListNode out = null; while(l1 != null) { list.add(l1.value); l1 = l1.next; } while(l2 != null) { list.add(l2.value); l2 = l2.next; } nums = list.toArray(new Integer[list.size()]); Arrays.sort(nums); for(int i : nums) { out = append(out, i); } return out; } } ================================================ FILE: Challenges/Java/MirrorBits.java ================================================ final class MirrorBits { int mirrorBits(int a) { return Integer.parseInt( new StringBuilder(Integer.toBinaryString(a)).reverse().toString(), 2); } } ================================================ FILE: Challenges/Java/MissingNumber.java ================================================ final class MissingNumber { int missingNumber(int[] arr) { Set set = new HashSet<>(); int out = 0; for(int i : arr) { set.add(i); } for(int i = 0; i <= arr.length; i++) { if(!set.contains(i)) { out = i; break; } } return out; } } ================================================ FILE: Challenges/Java/NewRoadSystem.java ================================================ import java.util.ArrayList; public final class NewRoadSystem { boolean newRoadSystem(boolean[][] roadRegister) { String l = "", r = ""; int sum1 = 0, sum2 = 0; for(int i = 0; i < roadRegister.length; i++) { for(int j = 0; j < roadRegister[0].length; j++) { if(roadRegister[i][j]) { l += i; r += j; } } } for(char c : l.toCharArray()) { sum1 += (byte)c; } for(char c : r.toCharArray()) { sum2 += (byte)c; } return sum1 == sum2; } } ================================================ FILE: Challenges/Java/NextLarger.java ================================================ public final class NextLarger { int[] nextLarger(int[] a) { int l = a.length; int[] out = new int[l]; for(int x = -1, i = 0, f = 0; i < l; i++, f = 0) { for(int j = i; j < l; j++) { if(a[j] > a[i]) { f = a[j]; break; } } out[x += 1] = f > 0 ? f : -1; } return out; } } ================================================ FILE: Challenges/Java/NthElementFromTheEnd.java ================================================ public final class NthElementFromTheEnd { //Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } int nthElementFromTheEnd(ListNode l, int n) { ArrayList out = new ArrayList(); ListNode ln = l; while(ln != null) { out.add(ln.value); ln = ln.next; } return (n > out.size()) ? -1 : out.get(out.size() - n); } } ================================================ FILE: Challenges/Java/PairsSum.java ================================================ final class PairsSum { boolean contains(int[] a, int e) { for(int i : a) if(i == e) return true; return false; } int pairsSum(int[] a) { int pairs = 0; for(int i = 0; i < a.length; i++) { for(int j = i + 1; j < a.length; j++) { if(contains(a, a[i] + a[j])) pairs++; } } return pairs; } } ================================================ FILE: Challenges/Java/PolygonPerimeter.java ================================================ public final class PolygonPerimeter { int polygonPerimeter(boolean[][] matrix) { int out = 0, leny = matrix.length, lenx = matrix[0].length; for(int y = 0; y < leny; y++) { for(int x = 0; x < lenx; x++) { if(matrix[y][x]) { if(y + 1 == leny || !matrix[y + 1][x]) { out++; } if(y - 1 < 0 || !matrix[y - 1][x]) { out++; } if(x + 1 == lenx || !matrix[y][x + 1]) { out++; } if(x - 1 < 0 || !matrix[y][x - 1]) { out++; } } } } return out; } } ================================================ FILE: Challenges/Java/PrimesSum2.java ================================================ final class PrimeSum2 { int primesSum2(int n) { boolean[] prime = new boolean[n + 1]; int sum = 0; Arrays.fill(prime, true); for(int p = 2; p * p <= n; p++) { if(prime[p]) { for(int i = p * p; i <= n; i += p) prime[i] = false; } } for(int i = 2; i <= n; i++) if(prime[i]) sum += i; return sum; } } ================================================ FILE: Challenges/Java/ProCategorization.java ================================================ final class ProCategorization { String[][][] proCategorization(String[] pros, String[][] preferences) { Map map = new HashMap<>(); List output = new Vector<>(); for(int i = 0; i < pros.length; i++) map.put(pros[i], preferences[i]); for(String a : Stream.of(preferences) .flatMap(e -> Stream.of(e)).distinct() .sorted().toArray(String[]::new)) { List auxList = new Vector<>(); for(String k : map.keySet()) if(Stream.of(map.get(k)) .anyMatch(e -> e.equals(a))) auxList.add(k); output.add(new String[][]{{a},auxList.stream().sorted() .toArray(String[]::new)}); } return output.toArray(String[][][]::new); } } ================================================ FILE: Challenges/Java/RangeBitCount.java ================================================ final class RangeBitCount { int rangeBitCount(int a, int b) { int counter = 0; for(int i = a; i <= b; i++) { for(char ch : Integer.toBinaryString(i).toCharArray()) { if(ch == '1') counter++; } } return counter; } } ================================================ FILE: Challenges/Java/RemoveArrayPart.java ================================================ final class RemoveArrayPart { int[] removeArrayPart(int[] inputArray, int l, int r) { return IntStream.range(0, inputArray.length) .filter(i -> i < l || i > r).map(i -> inputArray[i]).toArray(); } } ================================================ FILE: Challenges/Java/RemoveDuplicateStrings.java ================================================ public final class RemoveDuplicateStrings { String[] removeDuplicateStrings(String[] inputArray) { ArrayList list = new ArrayList(); for(String s : inputArray) { if(!list.contains(s)) { list.add(s); } } return list.toArray(new String[list.size()]); } } ================================================ FILE: Challenges/Java/ReverseInteger.java ================================================ public final class ReverseInteger { int reverseInteger(int x) { StringBuilder sb = new StringBuilder(Math.abs(x)+""); String out = sb.reverse().toString(); return (x < 0) ? Integer.valueOf("-"+out) : Integer.valueOf(out); } } ================================================ FILE: Challenges/Java/ReverseLinkedList.java ================================================ public final class ReverseLinkedList { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // ListNode reverse(ListNode l) { ListNode previous = null, current = l, next = null; while(current != null) { next = current.next; current.next = previous; previous = current; current = next; } return l = previous; } ListNode reverseLinkedList(ListNode l) { ListNode out = reverse(l); return out; } } ================================================ FILE: Challenges/Java/ReverseSentence.java ================================================ final class ReverseSentence { String reverseSentence(String sentence) { String out = ""; String[] parts = sentence.split(" "); for(int i = parts.length - 1; i >= 0; i--) { out += parts[i]+" "; } return out.trim(); } } ================================================ FILE: Challenges/Java/ReverseVowelsOfString.java ================================================ public final class ReverseVowelsOfString { String reverseVowelsOfString(String s) { String output = "", vowels = ""; for(char ch : s.toCharArray()) { if((ch+"").matches("[aeiouAEIOU]")) { String ss = ch+vowels; vowels = ss; } } for(int i = 0, x = 0; i < s.length(); i++) { if((s.charAt(i)+"").matches("[aeiouAEIOU]")) { output += vowels.charAt(x); x++; continue; } output += s.charAt(i); } return output; } } ================================================ FILE: Challenges/Java/RotateImage.java ================================================ final class RotateImage { int[][] rotateImage(int[][] a) { int lh = a.length, lw = a[0].length; int[][] out = new int[lh][lw]; for(int i = 0, x = 0; i < lw; i++, x++) { for(int j = lh - 1, y = 0; j >= 0; j--, y++) { out[i][j] = a[y][x]; } } return out; } } ================================================ FILE: Challenges/Java/ShoppingCart.java ================================================ class ShoppingCart { String[] shoppingCart(String[] requests) { Set cart = new TreeSet(); int index = 1; for(String s : requests) { String[] parts = s.split(" : "); switch(parts[0]) { case "add": cart.add(new Item(index, parts[1])); break; case "remove": for(Item i : cart) { if(i.name.equals(parts[1])) { cart.remove(i); break; } } break; case "quantity_upd": for(Item i : cart) { if(i.name.equals(parts[1])) { i.qt += Integer.parseInt(parts[2]); break; } } break; case "checkout": cart.clear(); break; } index++; } return cart.stream().map(e -> e.name+" : "+e.qt) .toArray(String[]::new); } } class Item implements Comparable { int index; String name; int qt = 1; Item(int index, String name) { this.index = index; this.name = name; } @Override public int compareTo(Item other) { return this.index - other.index; } } ================================================ FILE: Challenges/Java/ShoppingList.java ================================================ import java.util.regex.Pattern; final class ShoppingList { double shoppingList(String items) { return Pattern.compile("\\d+(?:\\.\\d*)?").matcher(items) .results().map(e -> e.group()).mapToDouble(e -> Double.parseDouble(e)) .sum(); } } ================================================ FILE: Challenges/Java/ShuffledArray.java ================================================ import java.util.ArrayList; import java.util.Arrays; public final class ShuffledArray { int[] shuffledArray(int[] shuffled) { ArrayList list = new ArrayList(); int out = 0, len = shuffled.length, sum = 0; int[] res = new int[len - 1]; for(int i : shuffled) { list.add(i); } for(int i = 0; i < len; i++, sum = 0) { for(int j = 0; j < len; j++) { if(j != i) { sum += list.get(j); } } if(list.contains(sum)) { out = sum; break; } } list.remove(new Integer(out)); for(int i = 0; i < list.size(); i++) { res[i] = list.get(i); } Arrays.sort(res); return res; } } ================================================ FILE: Challenges/Java/SortByString.java ================================================ final class SortByString { String sortByString(String s, String t) { String out = ""; for(char c : t.toCharArray()) { while(s.contains(c+"")) { s = s.replaceFirst(c+"", ""); out += c+""; } } return out; } } ================================================ FILE: Challenges/Java/SortedSquareArray.java ================================================ final class SortedSquareArray { int[] sortedSquaredArray(int[] array) { return Arrays.stream(array).map(n -> Math.abs(n) * Math.abs(n)) .sorted().toArray(); } } ================================================ FILE: Challenges/Java/Sudoku2.java ================================================ import java.util.Arrays; final class Sudoku2 { boolean sudoku2(char[][] grid) { int[] row = new int[9], col = new int[9], box = new int[9]; for(int i = 0; i < 9; i++) { for(int j = 0; j < 9; j++) { // check row if(grid[i][j] != '.') col[new Integer(grid[i][j]+"") - 1]++; // check col if(grid[j][i] != '.') row[new Integer(grid[j][i]+"") - 1]++; } // check box if((i + 1) % 3 == 0) { for(int t = 8; t > 0; t -= 3) { for(int p = t; p > t - 3; p--) { for(int q = i; q > i - 3; q--) { if(grid[p][q] != '.') box[new Integer(grid[p][q]+"") - 1]++; } } for(int p : box) if(p > 1) return false; Arrays.fill(box, 0); } } for(int p = 0; p < 9; p++) { if(row[p] > 1 || col[p] > 1) return false; } Arrays.fill(row, 0); Arrays.fill(col, 0); } return true; } } ================================================ FILE: Challenges/Java/SugarHigh.java ================================================ import java.util.ArrayList; public class SugarHigh { static int[] sugarHigh(int[] candies, int threshold) { ArrayList list = new ArrayList(); for (int i = 0; i < candies.length; i++) { if (candies[i] <= threshold) { list.add(Integer.valueOf(i)); threshold -= candies[i]; } } int[] newArray = new int[list.size()]; int idx = 0; for (Integer i : list) { newArray[idx] = i.intValue(); idx++; } return newArray; } } ================================================ FILE: Challenges/Java/SumOfTwo.java ================================================ final class SumOfTwo { boolean sumOfTwo(int[] a, int[] b, int v) { Set set = new HashSet<>(); for(int i : a) { set.add(v - i < 0 ? (v - i) * -1 : v - i); } for(int i : b) { if(set.contains(i)) { return true; } } return false; } } ================================================ FILE: Challenges/Java/SwitchLights.java ================================================ final class SwitchLights { int[] switchLights(int[] a) { for(int i = 0; i < a.length; i++) { if(a[i] == 1) for(int j = 0; j <= i; j++) a[j] = a[j] == 0 ? 1 : 0; } return a; } } ================================================ FILE: Challenges/Java/TriangleExistence.java ================================================ public final class TriangleExistence { boolean triangleExistence(int[] sides) { int s1 = sides[0] + sides[1]; int s2 = sides[1] + sides[2]; int s3 = sides[0] + sides[2]; return (s1 > sides[2] && s2 > sides[0] && s3 > sides[1]); } } ================================================ FILE: Challenges/Java/TwoArraysNthElement.java ================================================ public final class TwoArraysNthElement { int twoArraysNthElement(int[] array1, int[] array2, int n) { ArrayList arr = new ArrayList(); for(int i : array1) { arr.add(i); } for(int i : array2) { arr.add(i); } Integer[] out = arr.toArray(new Integer[arr.size()]); Arrays.sort(out); return out[n]; } } ================================================ FILE: Challenges/Java/Zigzag.java ================================================ public class Zigzag { static int zigzag(int[] a) { if (a.length == 2) { return 1; } int back = 0; for (int i = 1; i < (a.length - 1); i++) { if ((a[i] > a[i+1]) && (a[i] > a[i-1])) { back++; } else if ((a[i] < a[i+1]) && (a[i] < a[i-1])) { back++; } } return back; } } ================================================ FILE: Challenges/Javascript/amendTheSentence.js ================================================ function amendTheSentence(s) { let parts = s.split(/(?=[A-Z])/); return parts.map( (e) => { return e.toLowerCase(); } ).join(" "); } ================================================ FILE: Challenges/Javascript/characterParity.js ================================================ function characterParity(symbol) { let d = symbol.codePointAt(0) - 48; if(d >= 0 && d <= 9) return d % 2 == 0 ? "even" : "odd"; return "not a digit"; } ================================================ FILE: Challenges/Javascript/climbingStaircase.js ================================================ let jumps = [] function combination(arr,i, n, rn, u) { if(rn < 0) return; if(rn == 0) { let tmp = []; for(let j = 0; j < i; j++) tmp.push(arr[j]); jumps.push(tmp); return; } for(let k = 1; k <= n; k++) { if(k <= u) { arr[i] = k; combination(arr, i + 1, n, rn - k, u); } } } function climbingStaircase(n, k) { combination([], 0, n, n, k); return jumps; } ================================================ FILE: Challenges/Javascript/commonCharacterCount2.js ================================================ function commonCharacterCount2(s) { let out = 0, set = []; for(let i = 97, k = 0; i <= 122; i++, k = 0) { let ch = ''; for(let str of s) { ch = String.fromCharCode(i); if(!str.includes(ch)) { k++; break; } } if(k == 0) { set.push(ch); } } for(let x of set) { let min = 0; for(let str of s) { let count = 0; for(let y of str) { if(x === y) { count++; } } min = count < min ? count : min == 0 ? count : min; } out += min; } return out; } ================================================ FILE: Challenges/Javascript/companyBotStrategy.js ================================================ function companyBotStrategy(trainingData) { let q = 0, sum = 0; for(let i of trainingData) if(i[1] == 1) { q++; sum += i[0]; } return q > 0 ? sum / q : 0; } ================================================ FILE: Challenges/Javascript/containsCloseNums.js ================================================ function containsCloseNums(nums, k) { for(let i = 0; i < nums.length; i++) { for(let j = i + 1; j < nums.length; j++) { if(nums[i] == nums[j]) if(Math.abs(i - j) <= k) return true; } } return false; } ================================================ FILE: Challenges/Javascript/containsDuplicates.js ================================================ function containsDuplicates(a) { let o = [] for(let e of a) if(!o.includes(e)) o.push(e) return o.length != a.length } ================================================ FILE: Challenges/Javascript/domainType.js ================================================ function domainType(domains) { let map = { com: "commercial", org: "organization", net: "network", info: "information" }; return domains .map(e => map[/[a-z]{3,4}$/g.exec(e)]) } ================================================ FILE: Challenges/Javascript/fancyRide.js ================================================ function fancyRide(l, fares) { let options = ["UberX", "UberXL", "UberPlus", "UberBlack", "UberSUV"]; fares.sort((a, b) => a - b); let i = 0; for(; i < fares.length; i++) if(fares[i] * l > 20) break; return options[i > 0 ? i - 1 : 0]; } ================================================ FILE: Challenges/Javascript/fareEstimator.js ================================================ function fareEstimator(ride_time, ride_distance, cost_per_minute, cost_per_mile) { let out = []; for(let i = 0; i < cost_per_mile.length; i++) out[i] = cost_per_minute[i] * ride_time + cost_per_mile[i] * ride_distance; return out; } ================================================ FILE: Challenges/Javascript/fileNaming.js ================================================ function fileNaming(names) { let list = []; for(let i in names) { if(!list.includes(names[i])) { list.push(names[i]); continue; } let s = names[i]; for(let n = 1; list.includes(s); n++) { s = names[i]+"("+n+")"; } list.push(s); } return list; } ================================================ FILE: Challenges/Javascript/findMiddleElement.js ================================================ // Singly-linked lists are already defined with this interface: // function ListNode(x) { // this.value = x; // this.next = null; // } // function findMiddleElement(l) { let counter = 0; let out = l; for(let ref = l; ref != null; ref = ref.next) counter++; for(let i = 0; out != null && i < Math.floor(counter / 2); out = out.next, i++); return out.value; } ================================================ FILE: Challenges/Javascript/findSubarrayBySum.js ================================================ function findSubarrayBySum(s, arr) { for(let i = 0; i < arr.length; i++) { let sum = 0; for(let j = i; j < arr.length; j++) if((sum += arr[j]) == s) return [i + 1, j + 1]; } return [-1]; } ================================================ FILE: Challenges/Javascript/happyNumber.js ================================================ function happyNumber(n) { let set = []; while(!set.includes(n)) { let sum = 0; set.push(n); for(let e of n+"") sum += parseInt(e) ** 2; if(sum == 1) return true; else n = sum; } return false; } ================================================ FILE: Challenges/Javascript/isListPalindrome.js ================================================ // Singly-linked lists are already defined with this interface: // function ListNode(x) { // this.value = x; // this.next = null; // } // function isListPalindrome(l) { let set = []; for(; l != null; l = l.next) set.push(l.value); for(let right = 0, left = set.length - 1; left >= 0; right++, left--) if(set[right] != set[left]) return false; return true; } ================================================ FILE: Challenges/Javascript/isMAC48Address.js ================================================ function isMAC48Address(s) { let re = /[0-9A-F]{2}(-[0-9A-F]{2}){5}/i.exec(s); return re ? re[0] === s : false; } ================================================ FILE: Challenges/Javascript/launchSequenceChecker.js ================================================ function launchSequenceChecker(systemNames, stepNumbers) { let map = {}; for(let s of systemNames) map[s] = []; for(let i = 0; i < systemNames.length; i++) map[systemNames[i]].push(stepNumbers[i]); for(let s in map) for(let i = 0; i < map[s].length - 1; i++) if(map[s][i] >= map[s][i + 1]) return false; return true; } ================================================ FILE: Challenges/Javascript/maximumSum.js ================================================ let max = 0; function swap(a, i, j) { let tmp = a[i]; a[i] = a[j]; a[j] = tmp; } function permute(a, l, h, q) { if(l == h) { let tmp = sum(a, q); if(max < tmp) max = tmp; return; } for(let i = l; i <= h; i++) { swap(a, l, i); permute(a, l + 1, h, q); swap(a, l, i); } } function sum(a, q) { let sum = 0; for(let e of q) for(let i = e[0]; i <= e[1]; i++) sum += a[i]; return sum; } function maximumSum(a, q) { permute(a, 0, a.length - 1, q); return max; } ================================================ FILE: Challenges/Javascript/mirrorBits.js ================================================ function reverseString(s) { let out = ""; for(let i = s.length - 1; i >= 0; i--) out += s[i]; return out; } function mirrorBits(a) { return parseInt(reverseString((a).toString(2)), 2); } ================================================ FILE: Challenges/Javascript/missingNumber.js ================================================ function missingNumber(arr) { let out = 0; for(let i = 0; i <= arr.length; i++) { if(!arr.includes(i)) { out = i; break; } } return out; } ================================================ FILE: Challenges/Javascript/nextLarger.js ================================================ function nextLarger(a) { let out = []; for(let x = -1, i = 0, f = 0; i < a.length; i++, f = 0) { for(let j = i; j < a.length; j++) { if(a[j] > a[i]) { f = a[j]; break; } } out.push(f > 0 ? f : -1); } return out; } ================================================ FILE: Challenges/Javascript/pairsSum.js ================================================ function pairsSum(a) { let pairs = 0; for(let i = 0; i < a.length; i++) { for(let j = i + 1; j < a.length; j++) { if(a.includes(a[i] + a[j])) pairs++; } } return pairs; } ================================================ FILE: Challenges/Javascript/polygonPerimeter.js ================================================ function polygonPerimeter(matrix) { let out = 0, leny = matrix.length, lenx = matrix[0].length; for(let y = 0; y < leny; y++) { for(let x = 0; x < lenx; x++) { if(matrix[y][x]) { if(y + 1 == leny || !matrix[y + 1][x]) { out++; } if(y - 1 < 0 || !matrix[y - 1][x]) { out++; } if(x + 1 == lenx || !matrix[y][x + 1]) { out++; } if(x - 1 < 0 || !matrix[y][x - 1]) { out++; } } } } return out; } ================================================ FILE: Challenges/Javascript/rangeBitCount.js ================================================ function rangeBitCount(a, b) { c = 0; for(let i = a; i <= b; i++) { for(let o of i.toString(2).split(/(?=.)/)) c += parseInt(o); } return c; } ================================================ FILE: Challenges/Javascript/removeArrayPart.js ================================================ function removeArrayPart(a, l, r) { let out = []; for(let i = 0; i < a.length; i++) if(i < l || i > r) out.push(a[i]); return out; } ================================================ FILE: Challenges/Javascript/reverseSentence.js ================================================ function reverseSentence(sentence) { return sentence.split(" ").reverse().join(" "); } ================================================ FILE: Challenges/Javascript/reverseVowelsOfString.js ================================================ function reverseVowelsOfString(s) { let out = "", vowels = ""; for(let ch of s) { if(ch.match(/[aeiou]/i) == ch) { let ss = ch+vowels; vowels = ss; } } for(let i = 0, x = 0; i < s.length; i++) { let ch = s.charAt(i); if(ch.match(/[aeiou]/i) == ch) { out += vowels[x]; x++; continue; } out += ch; } return out; } ================================================ FILE: Challenges/Javascript/rotateImage.js ================================================ function rotateImage(a) { let h = a.length, w = a[0].length, out = []; for(let i = 0, r = []; i < h; i++, r = []) { for(let j = w - 1; j >= 0; j--) r.push(a[j][i]); out.push(r); } return out; } ================================================ FILE: Challenges/Javascript/sortByString.js ================================================ function sortByString(s, t) { let out = ""; for(let o of t) { while(s.includes(o)) { s = s.replace(o, ""); out += o; } } return out; } ================================================ FILE: Challenges/Javascript/sortedSquaredArray.js ================================================ function sortedSquaredArray(array) { return array.map(n => Math.abs(n) * Math.abs(n)) .sort((a, b) => a - b); } ================================================ FILE: Challenges/Javascript/switchLights.js ================================================ function switchLights(a) { for(let i in a) { if(a[i] == 1) a = a.map( (e, j) => e = j > i ? e : e == 1 ? 0 : 1); } return a; } ================================================ FILE: Challenges/Kotlin/companyBotStrategy.kt ================================================ fun companyBotStrategy(trainingData: MutableList>): Double { var q: Int = 0 var sum: Double = .0 for (data: MutableList in trainingData) { if (data[1] == 1) { q++ sum += data[0] } } return if (q > 0) sum / q else .0 } ================================================ FILE: Challenges/Python/concatenateArrays.py ================================================ def concatenateArrays(a, b): return a + b ================================================ FILE: Challenges/Python/reverseSentence.py ================================================ def reverseSentence(sentence): list = sentence.split(" ") i, out = list.__len__() - 1, "" while i >= 0: out += list[i] + " " i -= 1 return out[0:-1] ================================================ FILE: Challenges/Ruby/addTwoDigits.rb ================================================ def addTwoDigits(n) m = 0 n.to_s.each_char { |c| m += c.to_i } return m end ================================================ FILE: Challenges/Ruby/classifyStrings.rb ================================================ def classifyStrings s g = -> (a) do return (/[^aeiou]{5}/ =~ a or /[aeiou]{3}/ =~ a) ? "bad" : "good" end res = nil unless s.include? "?" then res = g.call s else s1 = g.call s.gsub("?", "a") s2 = g.call s.gsub("?", "n") if s.size > 4 and s.include? "???" then res = "mixed" elsif s1.eql? "bad" and s2.eql? "bad" then res = "bad" elsif s1.eql? "good" and s2.eql? "good" then res = "good" else res = "mixed" end end return res end ================================================ FILE: Challenges/Ruby/containsDuplicates.rb ================================================ def containsDuplicates(a) return a.uniq.size != a.size end ================================================ FILE: Challenges/Ruby/excelSheetColumnNumber.rb ================================================ def excelSheetColumnNumber(s) sum, l = 0, s.size - 1 s.size.times do |i| a = s[i].ord - 64 l.times { a *= 26; } sum, l = sum + a, l - 1 end return sum end ================================================ FILE: Challenges/Ruby/fractionReducing.rb ================================================ def fractionReducing(fraction) res = [] (1...10).each do |i| if fraction[0] % i == 0 and fraction[1] % i == 0 then res[0] = fraction[0] / i res[1] = fraction[1] / i end end return res end ================================================ FILE: Challenges/Ruby/giftSafety.rb ================================================ def giftSafety(g) c, p = 0, [] (g.size - 2).times do |i| s = "" (i...(i + 3)).each { |j| s += g[j] } p.push s end p.each { |s| c += 1 unless s.chars.uniq.join.eql? s } return c end ================================================ FILE: Challenges/Ruby/groupsOfAnagrams.rb ================================================ def groupsOfAnagrams w w.map{ |x| x.chars.sort.join }.uniq.size end ================================================ FILE: Challenges/Ruby/higherVersion2.rb ================================================ def higherVersion2(a, b) x, y, i = a.split(/\./), b.split(/\./), 0 loop do return 0 unless x[i] t, d = x[i].to_i, y[i].to_i return 1 if t > d return -1 if t < d i += 1 end end ================================================ FILE: Challenges/Ruby/isCryptSolution.rb ================================================ def isCryptSolution(c, s) r = /^0+\d+/ s.each do |x| 3.times do |y| c[y] = c[y].gsub(x[0], x[1]) if c[y].include? x[0] end end return false if r.match?(c[0]) or r.match?(c[1]) or r.match?(c[2]) return (c[0].to_i + c[1].to_i == c[2].to_i) end ================================================ FILE: Challenges/Ruby/kthLargestElement.rb ================================================ def kthLargestElement(n, k) n.sort[n.size - k] end ================================================ FILE: Challenges/Ruby/newRoadSystem.rb ================================================ def newRoadSystem(roadRegister) l, r, sum1, sum2, = "", "", 0, 0 roadRegister.size.times do |i| roadRegister[0].size.times do |j| l, r = l + "#{i}", r + "#{j}" if roadRegister[i][j] end end l.each_byte { |b| sum1 += b } r.each_byte { |b| sum2 += b } return sum1 == sum2 end ================================================ FILE: Challenges/Ruby/nthElementFromTheEnd.rb ================================================ # Singly-linked lists are already defined with this interface: # class ListNode # attr_accessor :value, :next # def initialize(val) # @value = val # @next = nil # end # def nthElementFromTheEnd(l, n) out, ln = [], l while ln do out.push ln.value ln = ln.next end return n > out.size ? -1 : out[out.size - n] end ================================================ FILE: Challenges/Ruby/removeDuplicateStrings.rb ================================================ def removeDuplicateStrings(inputArray) return inputArray.uniq end ================================================ FILE: Challenges/Ruby/reverseInteger.rb ================================================ def reverseInteger x a = x.to_s.reverse x < 0 ? ("-"+a).to_i : a.to_i end ================================================ FILE: Challenges/Ruby/rowsRearranging.rb ================================================ def rowsRearranging(m) m.permutation(m.size).to_a.each do |a| return true if every = -> r do (r.size - 1).times do |y| r[0].each_index do |x| return false if r[y + 1][x] <= r[y][x] end end return true end.call(a) end return false end ================================================ FILE: Challenges/Ruby/shuffledArray.rb ================================================ def shuffledArray(shuffled) out, len, sum = 0, shuffled.size, 0 len.times do |i| len.times { |j| sum += shuffled[j] unless j == i } if shuffled.include? sum then out = sum break; end sum = 0 end shuffled.delete_at shuffled.index(out) return shuffled.sort! end ================================================ FILE: Challenges/Ruby/triangleExistence.rb ================================================ def triangleExistence(sides) s1, s2, s3 = sides[0] + sides[1], sides[1] + sides[2], sides[0] + sides[2]; return (s1 > sides[2] && s2 > sides[0] && s3 > sides[1]); end ================================================ FILE: Challenges/Ruby/twoArraysNthElement.rb ================================================ def twoArraysNthElement(array1, array2, n) return (array1+array2).sort[n] end ================================================ FILE: InterviewPratice/Java/AddTwoHugeNumbers.java ================================================ final class addTwoHugeNumbers { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } ListNode addTwoHugeNumbers(ListNode a, ListNode b) { ListNode out = new ListNode(0), ref = out; int d = 0; a = reverse(a); b = reverse(b); while(a != null || b != null){ if(a != null){ d += a.value; a = a.next; } if(b != null){ d += b.value; b = b.next; } ref.next = new ListNode(d % 10000); ref = ref.next; d = d / 10000; } if(d >= 1) ref.next= new ListNode(d); return reverse(out.next); } ListNode reverse(ListNode l){ ListNode rev = null; for(; l != null; l = l.next) { ListNode head = new ListNode<>(l.value); head.next = rev; rev = head; } return rev; } } ================================================ FILE: InterviewPratice/Java/AmendTheSentence.java ================================================ final class AmendTheSenteance { String amendTheSentence(String s) { return Arrays.stream(s.split("(?=[A-Z])")) .collect(Collectors.joining(" ")).toLowerCase(); } } ================================================ FILE: InterviewPratice/Java/ClassifyStrings.java ================================================ final class ClassifyStrings { String isGoodOrBad(String s) { return Pattern.compile("[aeiou]{3}|[^aeiou]{5}") .matcher(s).find() ? "bad" : "good"; } String classifyStrings(String s) { String s1 = null, s2 = null; if(!s.contains("?")) return isGoodOrBad(s); else { s1 = isGoodOrBad(s.replace("?", "a")); s2 = isGoodOrBad(s.replace("?", "n")); if(s1.equals("bad") && s2.equals("bad") && !s.contains("???")) return "bad"; if(s1.equals("good") && s2.equals("good") && !s.contains("???")) return "good"; } return "mixed"; } } ================================================ FILE: InterviewPratice/Java/FirstDuplicate.java ================================================ import java.util.Set; import java.util.HashSet; final class FirstDuplicate { int firstDuplicate(int[] a) { Set set = new HashSet<>(); for(int i : a) if(!set.add(i)) return i; return -1; } } ================================================ FILE: InterviewPratice/Java/FirstNotRepeatingCharacter.java ================================================ final class FirstNotRepeatingCharacter { char firstNotRepeatingCharacter(String s) { int[] a = new int[26]; for(char c : s.toCharArray()) a[c - 'a']++; for(char c : s.toCharArray()) if(a[c - 'a'] == 1) return c; return '_'; } } ================================================ FILE: InterviewPratice/Java/GroupingDishes.java ================================================ import java.util.*; final class GroupingDishes { String[][] groupingDishes(String[][] dishes) { ArrayList carry = new ArrayList<>(), item = new ArrayList<>(); ArrayList dish = new ArrayList<>(); String[][] output = null; for(String[] x : dishes) { for(int y = 1; y < x.length; y++) { ArrayList tmp = new ArrayList<>(); for(String[] i : dishes) { for(int j = 1; j < i.length; j++) { if(x[y] == i[j]) { tmp.add(i[0]); } } } if(tmp.size() > 1 && !item.contains(tmp) && !dish.contains(x[y])) { dish.add(x[y]); item.add(tmp.toArray(new String[tmp.size()])); } } } dish.sort(null); for(int i = 0; i < item.size(); i++) { ArrayList tmp = new ArrayList<>(); Arrays.sort(item.get(i)); tmp.add(dish.get(i)); for(String y : item.get(i)) { tmp.add(y); } carry.add(tmp.toArray(new String[tmp.size()])); } // return output.toArray(new String[output.size()][output.get(0).length]); output = new String[carry.size()][carry.get(0).length]; for(String[] x : output) { Arrays.fill(x, ""); } for(int j = 0; j < carry.size(); j++) { for(int i = 0; i < carry.get(j).length; i++) { output[j][i] = carry.get(j)[i]; } } return output; } public static void main(String[] arguments) { String[][] dishes = {{"Salad", "Tomato", "Cucumber", "Salad", "Sauce"}, {"Pizza", "Tomato", "Sausage", "Sauce", "Dough"}, {"Quesadilla", "Chicken", "Cheese", "Sauce"}, {"Sandwich", "Salad", "Bread", "Tomato", "Cheese"}}; String[][] gd = new GroupingDishes().groupingDishes(dishes); for(String[] x : gd) { for(String y : x) { System.out.print(y+" "); } System.out.println(); } } } ================================================ FILE: InterviewPratice/Java/IsCryptSolution.java ================================================ final class IsCryptSolution { boolean isCryptSolution(String[] crypt, char[][] solution) { for(int i = 0; i < 3; i++) for(char[] c : solution) crypt[i] = crypt[i].replaceAll(c[0]+"", c[1]+""); for(String s : crypt) if(s.matches("0+\\d+")) return false; return Double.parseDouble(crypt[0]) + Double.parseDouble(crypt[1]) == Double.parseDouble(crypt[2]); } } ================================================ FILE: InterviewPratice/Java/IsListPalindrome.java ================================================ final class IsListPalindrome { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // boolean isListPalindrome(ListNode l) { ListNode rev = new ListNode<>(null), ref = l; for(; ref != null; ref = ref.next) { ListNode tmp = new ListNode<>(ref.value); tmp.next = rev; rev = tmp; } for(; l != null && rev != null; l = l.next, rev = rev.next) if(!l.value.equals(rev.value)) return false; return true; } } ================================================ FILE: InterviewPratice/Java/MergeTwoLinkedLists.java ================================================ final class mergeTwoLinkedLists { // Definition for singly-linked list: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // ListNode mergeTwoLinkedLists(ListNode l1, ListNode l2) { if(l1 == null) return l2; if(l2 == null) return l1; if(l1.value < l2.value) { l1.next = mergeTwoLinkedLists(l1.next, l2); return l1; } l2.next = mergeTwoLinkedLists(l1, l2.next); return l2; } } ================================================ FILE: InterviewPratice/Java/RearrangeLastN.java ================================================ final class RearrangeLastN { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // ListNode rearrangeLastN(ListNode l, int n) { if(l == null) return l; int size = 1; ListNode r = l, a = new ListNode<>(null), b = new ListNode<>(null), ra = a, rb = b; for(; r != null; r = r.next, size++); r = l; for(int i = 1; r != null; r = r.next, i++) { if(i < size - n) ra = ra.next = new ListNode<>(r.value); else rb = rb.next = new ListNode<>(r.value); } for(rb = b, ra = a; rb.next != null; rb = rb.next); rb.next = ra.next; return b.next; } } ================================================ FILE: InterviewPratice/Java/RemoveKFromList.java ================================================ final class RemoveKFromList { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // ListNode removeKFromList(ListNode l, int k) { ListNode out = new ListNode<>(null), ref = out; for(; l != null; l = l.next) { if(l.value != k) { ref.next = new ListNode<>(l.value); ref = ref.next; } } return out.next; } } ================================================ FILE: InterviewPratice/Java/ReverseNodeInKGroups.java ================================================ final class ReverseNodeInKGroups { // Singly-linked lists are already defined with this interface: // class ListNode { // ListNode(T x) { // value = x; // } // T value; // ListNode next; // } // ListNode reverse(ListNode l){ ListNode rev = null; for(; l != null; l = l.next) { ListNode head = new ListNode<>(l.value); head.next = rev; rev = head; } return rev; } ListNode reverseNodesInKGroups(ListNode l, int k) { ListNode out = new ListNode<>(null), carry = new ListNode<>(null), ref = out, aux = carry; int i = 1; for(; l != null; l = l.next, i++) { aux.next = new ListNode<>(l.value); aux = aux.next; if(i % k == 0) { ref.next = reverse(carry.next); for(; ref.next != null; ref = ref.next); carry = new ListNode<>(l.value); aux = carry; } } ref.next = carry.next; return out.next; } } ================================================ FILE: InterviewPratice/Java/RotateImage.java ================================================ final class RotateImage { int[][] rotateImage(int[][] a) { int[][] out = new int[a.length][a[0].length]; for(int x = 0, i = a.length - 1; x < out[0].length; x++, i--) { for(int y = 0; y < out.length; y++) out[y][x] = a[i][y]; } return out; } } ================================================ FILE: InterviewPratice/Java/Strstr.java ================================================ final class Strstr { int strstr(String s, String x) { int d = 256, m = x.length(), n = s.length(), q = 7; int p = 0, t = 0, h = 1; for(int i = 0; i < m - 1; i++) { h = (h * d) % q; } for(int i = 0; i < m; i++) { p = (p * d + x.charAt(i)) % q; t = (t * d + s.charAt(i)) % q; } for(int i = 0, j = 0; i <= n - m; i++) { if(p == t) { for(j = 0; j < m; j++) { if(s.charAt(i + j) != x.charAt(j)) { break; } } if (j == m) { return i; } } if(i < n - m) { t = ( d * (t - s.charAt(i) * h) + s.charAt(i + m)) % q; if(t < 0) { t = (t + q); } } } return -1; } } ================================================ FILE: InterviewPratice/Java/Sudoku2.java ================================================ import java.util.Arrays; final class Sudoku2 { boolean sudoku2(char[][] grid) { int[] row = new int[9], col = new int[9], box = new int[9]; for(int i = 0; i < 9; i++) { for(int j = 0; j < 9; j++) { if(grid[i][j] != '.') row[Integer.parseInt(grid[i][j]+"") - 1]++; if(grid[j][i] != '.') col[Integer.parseInt(grid[j][i]+"") - 1]++; } for(int j = 0; j < 9; j++) if(row[j] > 1 || col[j] > 1) return false; Arrays.fill(row, 0); Arrays.fill(col, 0); } for(int i = 1; i <= 9; i += 3) { for(int j = 1; j <= 9; j += 3) { if(grid[i][j] != '.') box[Integer.parseInt(grid[i][j]+"") - 1]++; if(grid[i][j + 1] != '.') box[Integer.parseInt(grid[i][j + 1]+"") - 1]++; if(grid[i - 1][j + 1] != '.') box[Integer.parseInt(grid[i - 1][j + 1]+"") - 1]++; if(grid[i + 1][j + 1] != '.') box[Integer.parseInt(grid[i + 1][j + 1]+"") - 1]++; if(grid[i][j - 1] != '.') box[Integer.parseInt(grid[i][j - 1]+"") - 1]++; if(grid[i - 1][j - 1] != '.') box[Integer.parseInt(grid[i - 1][j - 1]+"") - 1]++; if(grid[i + 1][j - 1] != '.') box[Integer.parseInt(grid[i + 1][j - 1]+"") - 1]++; if(grid[i + 1][j] != '.') box[Integer.parseInt(grid[i + 1][j]+"") - 1]++; if(grid[i - 1][j] != '.') box[Integer.parseInt(grid[i - 1][j]+"") - 1]++; for(int e : box) if(e > 1) return false; Arrays.fill(box, 0); } } return true; } } ================================================ FILE: InterviewPratice/Javascript/firstDuplicate.js ================================================ const firstDuplicate = (a) => { for(let i = 0; i < a.length; i++) { if(a[Math.abs(a[i]) - 1] < 0) return Math.abs(a[i]); a[Math.abs(a[i]) - 1] = -a[Math.abs(a[i]) - 1]; } return -1; } ================================================ FILE: InterviewPratice/Javascript/firstNotRepeatingCharacter.js ================================================ const firstNotRepeatingCharacter = (s) => { let a = []; for(let i = 0; i < 26; i++) a.push(0); for(let e of s) a[e.charCodeAt(0) - 97]++; for(let e of s) if(a[e.charCodeAt(0) - 97] == 1) return e; return "_"; } ================================================ FILE: InterviewPratice/Javascript/groupingDishes.js ================================================ function groupingDishes(dishes) { let flange = [], stuff = [], output = []; for(let i = 0; i < dishes.length; i++) { for(let j = 1; j < dishes[i].length; j++) { let tmp = []; for(let x = 0; x < dishes.length; x++) { for(let y = 1; y < dishes[x].length; y++) { if(dishes[i][j] == dishes[x][y]) { tmp.push(dishes[x][0]); } } } if(tmp.length > 1 && !stuff.includes(tmp) && !flange.includes(dishes[i][j])) { flange.push(dishes[i][j]); stuff.push(tmp); } } } flange.sort(); for(let i = 0; i < stuff.length; i++) { stuff[i].sort(); let tmp = []; tmp.push(flange[i]); for(let j = 0; j < stuff[i].length; j++) { tmp.push(stuff[i][j]); } output.push(tmp); } return output; } let dishes = [["Salad", "Tomato", "Cucumber", "Salad", "Sauce"], ["Pizza", "Tomato", "Sausage", "Sauce", "Dough"], ["Quesadilla", "Chicken", "Cheese", "Sauce"], ["Sandwich", "Salad", "Bread", "Tomato", "Cheese"]]; let input = groupingDishes(dishes); for(let i in input) { console.log(input[i]); } ================================================ FILE: InterviewPratice/Javascript/isCryptSolution.js ================================================ function isCryptSolution(crypt, solution) { for(let i = 0; i < 3; i++) { for(let c of solution) crypt[i] = crypt[i].replace(new RegExp(c[0], "g"), c[1]); } for(let s of crypt) if(/^0+\d+/g.test(s)) return false; return parseInt(crypt[0]) + parseInt(crypt[1]) == parseInt(crypt[2]); } ================================================ FILE: InterviewPratice/Javascript/mergeTwoLinkedLists.js ================================================ // Singly-linked lists are already defined with this interface: // function ListNode(x) { // this.value = x; // this.next = null; // } // function mergeTwoLinkedLists(l1, l2) { if(l1 == null) return l2; if(l2 == null) return l1; if(l1.value < l2.value) { l1.next = mergeTwoLinkedLists(l1.next, l2); return l1; } l2.next = mergeTwoLinkedLists(l1, l2.next); return l2; } ================================================ FILE: InterviewPratice/Javascript/rotateImage.js ================================================ const rotateImage = (a) => { let out = []; for(let i = 0; i < a.length; i++) out.push(new Array(a[0].length)); for(let x = 0, i = a.length - 1; x < a[0].length; x++, i--) { for(let y = 0; y < a.length; y++) out[y][x] = a[i][y]; } return out; } ================================================ FILE: InterviewPratice/Javascript/sudoku2.js ================================================ const check = str => { let c = 0, chars = ""; for(let i in str) { let ch = str.charAt(i); if(!chars.includes(ch) || ch == ".") { chars += ch; } else { c++; } } return c == 0; }; const sudoku2 = grid => { let c = 0, str = ""; for(let i = 0; i < 9; i++, str = "") { for(let j = 0; j < 9; j++) { str += grid[i][j]; } c = !check(str) ? c + 1 : c; str = ""; for(let j = 0; j < 9; j++) { str += grid[j][i]; } c = !check(str) ? c + 1 : c; } for(let i = 0, x = 1; i < 3; i++, x += 3) { str = ""; for(let j = 0, y = 1; j < 3; j++, y += 3, str = "") { str += grid[x][y]; str += grid[x][y + 1]; str += grid[x - 1][y + 1]; str += grid[x + 1][y + 1]; str += grid[x][y - 1]; str += grid[x - 1][y - 1]; str += grid[x + 1][y - 1]; str += grid[x + 1][y]; str += grid[x- 1][y]; c = !check(str) ? c + 1 : c; } } return c == 0; }; ================================================ FILE: InterviewPratice/Ruby/firstDuplicate.rb ================================================ def firstDuplicate a a.each do |i| return i.abs if a[i.abs - 1] < 0 a[i.abs - 1] *= -1 end return -1 end ================================================ FILE: InterviewPratice/Ruby/firstNotRepeatingCharacter.rb ================================================ def firstNotRepeatingCharacter s s.chars.uniq.each do |c| if s.include? c return c if s.chars.count(c) == 1 end end return "_" end ================================================ FILE: InterviewPratice/runlength_encoding.java ================================================ public static String encoding(String inputStream) { int n = inputStream.length(); StringBuilder output = new StringBuilder() for (int = 0; i < n; i++) { int count = 1; while (i < n - 1 && inputStream.charAt(i) == inputStream.charAt(i + 1)) { count ++; index ++; } output.append(count); output.append(inputStream.charAt(i)); } return output.toString(); } ================================================ FILE: LICENSE ================================================ MIT License Copyright (c) 2018 Neemias Santos Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ # CodeSignal solutions ![GitHub language count](https://img.shields.io/github/languages/count/neemiassgc/CodeSignal-Solutions?color=blue) ![GitHub top language](https://img.shields.io/github/languages/top/neemiassgc/CodeSignal-Solutions?label=java&logo=java&color=blue) ![GitHub license](https://img.shields.io/github/license/neemiassgc/CodeSignal-Solutions?color=blue) ![GitHub forks](https://img.shields.io/github/forks/neemiassgc/CodeSignal-Solutions?color=blue) ![GitHub Repo stars](https://img.shields.io/github/stars/neemiassgc/CodeSignal-Solutions?color=blue) ![GitHub last commit](https://img.shields.io/github/last-commit/neemiassgc/CodeSignal-Solutions?color=blue) Solutions of coding from [CodeSignal](https://codesignal.com) platform