Showing preview only (296K chars total). Download the full file or copy to clipboard to get everything.
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.<String>of(inputArray)
.mapToInt(n -> n.length())
.max()
.getAsInt();
return Stream.<String>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<String> 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<String> 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<String> 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<T> {
// ListNode(T x) {
// value = x;
// }
// T value;
// ListNode<T> next;
// }
//
ListNode<Integer> removeKFromList(ListNode<Integer> l, int k) {
ListNode<Integer> 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 <bitset>
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<String> 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<Integer> 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>): 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<Int>, elemToReplace: Int, substitutionElem: Int): MutableList<Int> {
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<Int>, b: MutableList<Int>) = 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<Int> =
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<Int>): MutableList<Int> {
fun <T> MutableList<T>.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<Int>): 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>): 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<Int> = arrayOf(
Math.floor(aBisect).toInt() * 2 + 1,
Math.floor(bBisect).toInt() * 2 + 1
)
val rect2: Array<Int> = 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<Int>, l: Int, r: Int) = inputArray.filterIndexed { i, v -> i < l || i > r }
================================================
FILE: Arcade/TheCore/Kotlin/replaceMiddle.kt
================================================
fun replaceMiddle(arr: MutableList<Int>): MutableList<Int> {
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<Int> = 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<Int> {
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<Int> = (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<T> {
// ListNode(T x) {
// value = x;
// }
// T value;
// ListNode<T> next;
// }
ListNode<Integer> addTwoHugeNumbers(ListNode<Integer> a, ListNode<Integer> b) {
ListNode<Integer> result = new ListNode<Integer>(0);
ListNode<Integer> 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<Integer>(carry % 10000);
head = head.next;
carry = carry / 10000;
}
if(carry >= 1)
head.next= new ListNode<Integer>(carry);
return reverse(result.next);
}
ListNode<Integer> reverse(ListNode<Integer> head){
ListNode<Integer> prev = null;
while(head != null){
ListNode<Integer> 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<String, Integer> points = new HashMap<>();
emails = Stream.<String>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<List<String>> out = new Vector<>();
Map<String, Vector<String>> 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<String, Vector<String>> 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<String> 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<T> {
// Tree(T x) {
// value = x;
// }
// T value;
// Tree<T> left;
// Tree<T> right;
// }
void recTree(Tree<Integer> t, Vector<Integer> v) {
v.add(t.value);
if(t.left != null) recTree(t.left, v);
if(t.right != null) recTree(t.right, v);
}
int btsTree(Tree<Integer> t, int n) {
Vector<Integer> 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<Integer> 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<Character> 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<List<Integer>> set = new ArrayList<>();
List<Integer> 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<String> row = new ArrayList();
ArrayList<String> 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<String, String> dMap = new HashMap<>() {
{
put("com", "commercial");
put("org", "organization");
put("net", "network");
put("info", "information");
}
};
return Stream.<String>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<String> 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<T> {
// ListNode(T x) {
// value = x;
// }
// T value;
// ListNode<T> next;
// }
//
int findMiddleElement(ListNode<Integer> l) {
int counter = 0;
for(ListNode<Integer> ref = l; ref != null; ref = ref.next) counter++;
for(int i = 0; l != null && i < counter / 2; l = l.next, i++);
return l.value;
}
}
==========================
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
SYMBOL INDEX (664 symbols across 421 files)
FILE: Arcade/Databases/customerMessages.sql
function response (line 2) | CREATE FUNCTION response(name VARCHAR(40)) RETURNS VARCHAR(200) DETERMIN...
FILE: Arcade/Databases/driversInfo.sql
type names (line 5) | CREATE TABLE names (
type summary (line 11) | CREATE TABLE summary (
FILE: Arcade/Databases/queriesExecution.sql
type my_queries (line 11) | CREATE TABLE my_queries (
type output (line 18) | CREATE TABLE output (
FILE: Arcade/Databases/sortBook.sql
function romanConverter (line 8) | CREATE FUNCTION romanConverter (value VARCHAR(25)) RETURNS INT
function findSymbol (line 31) | CREATE FUNCTION findSymbol (value CHAR(1)) RETURNS INT
FILE: Arcade/Databases/stringsStatistics.sql
type letter (line 5) | CREATE TABLE letter (
type total (line 11) | CREATE TABLE total (
type occurrence (line 17) | CREATE TABLE occurrence (
type max_occurrence (line 23) | CREATE TABLE max_occurrence (
type max_occurrence_reached (line 29) | CREATE TABLE max_occurrence_reached (
type chars (line 35) | CREATE TABLE chars (
FILE: Arcade/Databases/tableSecurity.sql
type emp (line 3) | CREATE OR REPLACE VIEW emp
FILE: Arcade/Databases/typeInheritance.sql
function isNumber (line 1) | CREATE FUNCTION isNumber(class VARCHAR(45))
FILE: Arcade/Intro/Java/AbsoluteValuesSumMinimization.java
class AbsoluteValuesSumMinimization (line 4) | final class AbsoluteValuesSumMinimization {
method absoluteValuesSumMinimization (line 6) | int absoluteValuesSumMinimization(int[] a) {
FILE: Arcade/Intro/Java/Add.java
class Add (line 1) | public class Add {
method add (line 3) | int add(int param1, int param2) {
FILE: Arcade/Intro/Java/AddBorder.java
class AddBorder (line 1) | final class AddBorder {
method addBorder (line 3) | String[] addBorder(String[] picture) {
FILE: Arcade/Intro/Java/AdjacentElementsProduct.java
class AdjacentElementsProduct (line 3) | final class AdjacentElementsProduct {
method adjacentElementsProduct (line 5) | int adjacentElementsProduct(int[] inputArray) {
FILE: Arcade/Intro/Java/AllLongestStrings.java
class AllLongestStrings (line 3) | public class AllLongestStrings {
method allLongestStrings (line 5) | String[] allLongestStrings(String[] inputArray) {
FILE: Arcade/Intro/Java/AlmostIncreasingSequence.java
class AlmostIncreasingSequence (line 1) | final class AlmostIncreasingSequence {
method almostIncreasingSequence (line 3) | boolean almostIncreasingSequence(int[] sequence) {
FILE: Arcade/Intro/Java/AlphabeticShift.java
class AlphabeticShift (line 3) | final class AlphabeticShift {
method alphabeticShift (line 5) | String alphabeticShift(String inputString) {
FILE: Arcade/Intro/Java/AlternatingSums.java
class AlternatingSums (line 1) | final class AlternatingSums {
method alternatingSums (line 3) | int[] alternatingSums(int[] a) {
FILE: Arcade/Intro/Java/AreEquallyStrong.java
class AreEquallyStrong (line 1) | public final class AreEquallyStrong {
method areEquallyStrong (line 3) | boolean areEquallyStrong(int yourLeft, int yourRight, int friendsLeft,...
FILE: Arcade/Intro/Java/AreSimilar.java
class AreSimilar (line 3) | final class AreSimilar {
method swap (line 5) | void swap(int[] a, int p, int q) {
method areSimilar (line 11) | boolean areSimilar(int[] a, int[] b) {
FILE: Arcade/Intro/Java/ArrayChange.java
class ArrayChange (line 1) | final class ArrayChange {
method arrayChange (line 3) | int arrayChange(int[] inputArray) {
FILE: Arcade/Intro/Java/ArrayMaxConsecutiveSum.java
class ArrayMaxConsecutiveSum (line 1) | final class ArrayMaxConsecutiveSum {
method arrayMaxConsecutiveSum (line 3) | int arrayMaxConsecutiveSum(int[] inputArray, int k) {
FILE: Arcade/Intro/Java/ArrayMaximalAdjacentDifference.java
class ArrayMaximalAdjacentDifference (line 3) | final class ArrayMaximalAdjacentDifference {
method arrayMaximalAdjacentDifference (line 5) | int arrayMaximalAdjacentDifference(int[] inputArray) {
FILE: Arcade/Intro/Java/ArrayReplace.java
class ArrayReplace (line 3) | final class ArrayReplace {
method arrayReplace (line 5) | int[] arrayReplace(int[] inputArray, int elemToReplace, int substituti...
FILE: Arcade/Intro/Java/AvoidObstacles.java
class AvoidObstacles (line 1) | final class AvoidObstacles {
method avoidObstacles (line 3) | int avoidObstacles(int[] inputArray) {
FILE: Arcade/Intro/Java/BishopAndPawn.java
class BishopAndPawn (line 1) | final class BishopAndPawn {
method bishopAndPawn (line 3) | boolean bishopAndPawn(String bishop, String pawn) {
FILE: Arcade/Intro/Java/BoxBlur.java
class BoxBlur (line 3) | final class BoxBlur {
method boxBlur (line 5) | int[][] boxBlur(int[][] image) {
FILE: Arcade/Intro/Java/BuildPalindrome.java
class BuildPalindrome (line 1) | final class BuildPalindrome {
method reverseString (line 3) | String reverseString(String str) {
method buildPalindrome (line 7) | String buildPalindrome(String st) {
FILE: Arcade/Intro/Java/CenturyFromYear.java
class CenturyFromYear (line 1) | public class CenturyFromYear {
method centuryFromYear (line 3) | int centuryFromYear(int year) {
FILE: Arcade/Intro/Java/CheckPalindrome.java
class CheckPalindrome (line 1) | public class CheckPalindrome {
method checkPalindrome (line 3) | boolean checkPalindrome(String inputString) {
FILE: Arcade/Intro/Java/ChessBoardCellColor.java
class ChessBoardCellColor (line 1) | final class ChessBoardCellColor {
method chessBoardCellColor (line 3) | boolean chessBoardCellColor(String cell1, String cell2) {
FILE: Arcade/Intro/Java/ChessKnight.java
class ChessKnight (line 1) | final class ChessKnight {
method isSafe (line 3) | boolean isSafe(int x, int y) {
method chessKnight (line 7) | int chessKnight(String cell) {
FILE: Arcade/Intro/Java/CircleOfNumbers.java
class CircleOfNumbers (line 1) | final class CircleOfNumbers {
method circleOfNumbers (line 3) | int circleOfNumbers(int n, int firstNumber) {
FILE: Arcade/Intro/Java/CommonCharacterCount.java
class CommonCharacterCount (line 4) | final class CommonCharacterCount {
method commonCharacterCount (line 6) | int commonCharacterCount(String s1, String s2) {
FILE: Arcade/Intro/Java/DeleteDigit.java
class DeleteDigit (line 1) | final class DeleteDigit {
method deleteDigit (line 3) | int deleteDigit(int n) {
FILE: Arcade/Intro/Java/DepositProfit.java
class DepositProfit (line 1) | final class DepositProfit {
method depositProfit (line 3) | int depositProfit(int deposit, int rate, int threshold) {
FILE: Arcade/Intro/Java/DifferentSquares.java
class DifferentSquares (line 4) | final class DifferentSquares {
method differentSquares (line 6) | int differentSquares(int[][] matrix) {
FILE: Arcade/Intro/Java/DifferentSymbolsNaive.java
class DifferentSymbolsNaive (line 1) | final class DifferentSymbolsNaive {
method differentSymbolsNaive (line 3) | int differentSymbolsNaive(String s) {
FILE: Arcade/Intro/Java/DigitDegree.java
class DigitDegree (line 1) | final class DigitDegree {
method digitDegree (line 3) | int digitDegree(int n) {
FILE: Arcade/Intro/Java/DigitsProduct.java
class DigitsProduct (line 1) | final class DigitsProduct {
method digitsProduct (line 3) | int digitsProduct(int product) {
FILE: Arcade/Intro/Java/ElectionsWinners.java
class ElectionsWinners (line 3) | final class ElectionsWinners {
method electionsWinners (line 5) | int electionsWinners(int[] votes, int k) {
FILE: Arcade/Intro/Java/EvenDigitsOnly.java
class EvenDigitsOnly (line 1) | final class EvenDigitsOnly {
method evenDigitsOnly (line 3) | boolean evenDigitsOnly(int n) {
FILE: Arcade/Intro/Java/ExtractEachKth.java
class ExtractEachKth (line 3) | public final class ExtractEachKth {
method extractEachKth (line 5) | int[] extractEachKth(int[] inputArray, int k) {
FILE: Arcade/Intro/Java/FileNaming.java
class FileNaming (line 3) | final class FileNaming {
method fileNaming (line 5) | String[] fileNaming(String[] names) {
FILE: Arcade/Intro/Java/FindEmailDomain.java
class FindEmailDomain (line 1) | final class FindEmailDomain {
method findEmailDomain (line 3) | String findEmailDomain(String address) {
FILE: Arcade/Intro/Java/FirstDigit.java
class FirstDigit (line 1) | final class FirstDigit {
method firstDigit (line 3) | char firstDigit(String inputString) {
FILE: Arcade/Intro/Java/GrowingPlant.java
class GrowingPlant (line 1) | public final class GrowingPlant {
method growingPlant (line 3) | int growingPlant(int upSpeed, int downSpeed, int desiredHeight) {
FILE: Arcade/Intro/Java/IsBeautifulString.java
class IsBeautifulString (line 1) | final class IsBeautifulString {
method isBeautifulString (line 3) | boolean isBeautifulString(String inputString) {
FILE: Arcade/Intro/Java/IsDigit.java
class IsDigit (line 1) | final class IsDigit {
method isDigit (line 3) | boolean isDigit(char symbol) {
FILE: Arcade/Intro/Java/IsIPv4Address.java
class IsIPv4Address (line 1) | final class IsIPv4Address {
method isIPv4Address (line 3) | boolean isIPv4Address(String inputString) {
FILE: Arcade/Intro/Java/IsLucky.java
class IsLucky (line 1) | final class IsLucky {
method isLucky (line 3) | boolean isLucky(int n) {
FILE: Arcade/Intro/Java/IsMAC48Adress.java
class IsMAC48Adress (line 1) | final class IsMAC48Adress {
method isMAC48Address (line 3) | boolean isMAC48Address(String inputString) {
FILE: Arcade/Intro/Java/KnapsackLight.java
class KnapsackLight (line 1) | final class KnapsackLight {
method knapsackLight (line 3) | int knapsackLight(int value1, int weight1, int value2, int weight2, in...
FILE: Arcade/Intro/Java/LineEnconding.java
class LineEnconding (line 4) | final class LineEnconding {
method lineEncoding (line 6) | String lineEncoding(String s) {
FILE: Arcade/Intro/Java/LongestDigitsPrefix.java
class LongestDigitsPrefix (line 1) | final class LongestDigitsPrefix {
method longestDigitsPrefix (line 3) | String longestDigitsPrefix(String inputString) {
FILE: Arcade/Intro/Java/LongestWord.java
class LongestWord (line 3) | final class LongestWord {
method longestWord (line 5) | String longestWord(String text) {
FILE: Arcade/Intro/Java/MakeArrayConsecutive2.java
class MakeArrayConsecutive2 (line 4) | final class MakeArrayConsecutive2 {
method makeArrayConsecutive2 (line 6) | int makeArrayConsecutive2(int[] statues) {
FILE: Arcade/Intro/Java/MatrixElementsSum.java
class MatrixElementsSum (line 1) | public class MatrixElementsSum {
method matrixElementsSum (line 3) | int matrixElementsSum(int[][] matrix) {
FILE: Arcade/Intro/Java/MessageFromBinaryCode.java
class MessageFromBinaryCode (line 4) | final class MessageFromBinaryCode {
method messageFromBinaryCode (line 6) | String messageFromBinaryCode(String code) {
FILE: Arcade/Intro/Java/Minesweeper.java
class Minesweeper (line 1) | final class Minesweeper {
method minesweeper (line 3) | int[][] minesweeper(boolean[][] matrix) {
FILE: Arcade/Intro/Java/PalindromeRearranging.java
class PalindromeRearranging (line 3) | final class PalindromeRearranging {
method palindromeRearranging (line 5) | boolean palindromeRearranging(String inputString) {
FILE: Arcade/Intro/Java/RemoveKFromList.java
class RemoveKFromList (line 1) | final class RemoveKFromList {
method removeKFromList (line 12) | ListNode<Integer> removeKFromList(ListNode<Integer> l, int k) {
FILE: Arcade/Intro/Java/ReverseInParentheses.java
class ReverseInParentheses (line 4) | final class ReverseInParentheses {
method reverseInParentheses (line 6) | String reverseInParentheses(String inputString) {
FILE: Arcade/Intro/Java/ShapeArea.java
class ShapeArea (line 1) | public class ShapeArea {
method shapeArea (line 3) | int shapeArea(int n) {
FILE: Arcade/Intro/Java/SortByHeight.java
class SortByHeight (line 4) | public class SortByHeight {
method sortByHeight (line 6) | int[] sortByHeight(int[] a) {
FILE: Arcade/Intro/Java/SpiralNumbers.java
class SpiralNumbers (line 1) | final class SpiralNumbers {
method spiralNumbers (line 3) | int[][] spiralNumbers(int n) {
FILE: Arcade/Intro/Java/StringsRearrangement.java
class StringsRearrangement (line 4) | final class StringsRearrangement {
method check (line 8) | boolean check(String s1, String s2) {
method permute (line 17) | void permute(String[] arr, int l, int h) {
method swap (line 35) | void swap(String[] arr, int i, int j) {
method stringsRearrangement (line 41) | boolean stringsRearrangement(String[] inputArray) {
FILE: Arcade/Intro/Java/Sudoku.java
class Sudoku (line 3) | final class Sudoku {
method sudoku (line 5) | boolean sudoku(int[][] grid) {
FILE: Arcade/Intro/Java/SumUpNumbers.java
class SumUpNumbers (line 1) | final class SumUpNumbers {
method sumUpNumbers (line 3) | int sumUpNumbers(String inputString) {
FILE: Arcade/Intro/Java/ValidTime.java
class ValidTime (line 1) | final class ValidTime {
method validTime (line 3) | boolean validTime(String time) {
FILE: Arcade/Intro/Java/VariableName.java
class VariableName (line 1) | final class VariableName {
method variableName (line 3) | boolean variableName(String name) {
FILE: Arcade/Intro/Python/stringsRearrangement.py
function isDifferByOneChar (line 3) | def isDifferByOneChar(str1, str2):
function stringsRearrangement (line 10) | def stringsRearrangement(inputArray):
FILE: Arcade/Intro/Ruby/absoluteValuesSumMinimization.rb
function absoluteValuesSumMinimization (line 1) | def absoluteValuesSumMinimization(a)
FILE: Arcade/Intro/Ruby/add.rb
function add (line 1) | def add(param1, param2)
FILE: Arcade/Intro/Ruby/addBorder.rb
function addBorder (line 1) | def addBorder(picture)
FILE: Arcade/Intro/Ruby/adjacentElementsProduct.rb
function adjacentElementsProduct (line 1) | def adjacentElementsProduct(inputArray)
FILE: Arcade/Intro/Ruby/allLongestStrings.rb
function allLongestStrings (line 1) | def allLongestStrings(a)
FILE: Arcade/Intro/Ruby/almostIncreasingSequence.rb
function almostIncreasingSequence (line 1) | def almostIncreasingSequence(sequence)
FILE: Arcade/Intro/Ruby/alphabeticShift.rb
function alphabeticShift (line 1) | def alphabeticShift(inputString)
FILE: Arcade/Intro/Ruby/alternatingSums.rb
function alternatingSums (line 1) | def alternatingSums(a)
FILE: Arcade/Intro/Ruby/areEquallyStrong.rb
function areEquallyStrong (line 1) | def areEquallyStrong(yourLeft, yourRight, friendsLeft, friendsRight)
FILE: Arcade/Intro/Ruby/areSimilar.rb
function areSimilar (line 1) | def areSimilar(a, b)
FILE: Arcade/Intro/Ruby/arrayChange.rb
function arrayChange (line 1) | def arrayChange(inputArray)
FILE: Arcade/Intro/Ruby/arrayMaxConsecutiveSum.rb
function arrayMaximalAdjacentDifference (line 1) | def arrayMaximalAdjacentDifference(inputArray)
FILE: Arcade/Intro/Ruby/arrayMaximalAdjacentDifference.rb
function arrayMaxConsecutiveSum (line 1) | def arrayMaxConsecutiveSum(inputArray, k)
FILE: Arcade/Intro/Ruby/arrayReplace.rb
function arrayReplace (line 1) | def arrayReplace(inputArray, elemToReplace, substitutionElem)
FILE: Arcade/Intro/Ruby/avoidObstacles.rb
function avoidObstacles (line 1) | def avoidObstacles(inputArray)
FILE: Arcade/Intro/Ruby/bishopAndPawn.rb
function bishopAndPawn (line 1) | def bishopAndPawn(bishop, pawn)
FILE: Arcade/Intro/Ruby/boxBlur.rb
function boxBlur (line 1) | def boxBlur(image)
FILE: Arcade/Intro/Ruby/buildPalindrome.rb
function buildPalindrome (line 1) | def buildPalindrome(st)
FILE: Arcade/Intro/Ruby/centuryFromYear.rb
function centuryFromYear (line 1) | def centuryFromYear(year)
FILE: Arcade/Intro/Ruby/checkPalindrome.rb
function checkPalindrome (line 1) | def checkPalindrome(inputString)
FILE: Arcade/Intro/Ruby/chessBoardCellColor.rb
function chessBoardCellColor (line 1) | def chessBoardCellColor(cell1, cell2)
FILE: Arcade/Intro/Ruby/chessKnight.rb
function isSafe (line 1) | def isSafe(x, y)
function chessKnight (line 5) | def chessKnight(cell)
FILE: Arcade/Intro/Ruby/circleOfNumbers.rb
function circleOfNumbers (line 1) | def circleOfNumbers(n, firstNumber)
FILE: Arcade/Intro/Ruby/commonCharacterCount.rb
function commonCharacterCount (line 1) | def commonCharacterCount(s1, s2)
FILE: Arcade/Intro/Ruby/deleteDigit.rb
function deleteDigit (line 1) | def deleteDigit(n)
FILE: Arcade/Intro/Ruby/depositProfit.rb
function depositProfit (line 1) | def depositProfit(deposit, rate, threshold)
FILE: Arcade/Intro/Ruby/differentSquares.rb
function differentSquares (line 1) | def differentSquares(matrix)
FILE: Arcade/Intro/Ruby/differentSymbolsNaive.rb
function differentSymbolsNaive (line 1) | def differentSymbolsNaive(s)
FILE: Arcade/Intro/Ruby/digitDegree.rb
function digitDegree (line 1) | def digitDegree(n)
FILE: Arcade/Intro/Ruby/digitsProduct.rb
function digitsProduct (line 1) | def digitsProduct(product)
FILE: Arcade/Intro/Ruby/electionsWinners.rb
function electionsWinners (line 1) | def electionsWinners(votes, k)
FILE: Arcade/Intro/Ruby/evenDigitsOnly.rb
function evenDigitsOnly (line 1) | def evenDigitsOnly(n)
FILE: Arcade/Intro/Ruby/extractEachKth.rb
function extractEachKth (line 1) | def extractEachKth(inputArray, k)
FILE: Arcade/Intro/Ruby/fileNaming.rb
function fileNaming (line 1) | def fileNaming(names)
FILE: Arcade/Intro/Ruby/findEmailDomain.rb
function findEmailDomain (line 1) | def findEmailDomain(address)
FILE: Arcade/Intro/Ruby/firstDigit.rb
function firstDigit (line 1) | def firstDigit(inputString)
FILE: Arcade/Intro/Ruby/growingPlant.rb
function growingPlant (line 1) | def growingPlant(upSpeed, downSpeed, desiredHeight)
FILE: Arcade/Intro/Ruby/isBeautifulString.rb
function isBeautifulString (line 1) | def isBeautifulString(inputString)
FILE: Arcade/Intro/Ruby/isDigit.rb
function isDigit (line 1) | def isDigit(symbol)
FILE: Arcade/Intro/Ruby/isIPv4Address.rb
function isIPv4Address (line 1) | def isIPv4Address(inputString)
FILE: Arcade/Intro/Ruby/isLuck.rb
function isLucky (line 1) | def isLucky(n)
FILE: Arcade/Intro/Ruby/isMAC48Address.rb
function isMAC48Address (line 1) | def isMAC48Address(inputString)
FILE: Arcade/Intro/Ruby/isPowerOfTwo2.rb
function isPowerOfTwo2 (line 1) | def isPowerOfTwo2 n
FILE: Arcade/Intro/Ruby/knapsackLight.rb
function knapsackLight (line 1) | def knapsackLight(value1, weight1, value2, weight2, maxW)
FILE: Arcade/Intro/Ruby/lineEncoding.rb
function lineEncoding (line 1) | def lineEncoding(s)
FILE: Arcade/Intro/Ruby/longestDigitsPrefix.rb
function longestDigitsPrefix (line 1) | def longestDigitsPrefix(inputString)
FILE: Arcade/Intro/Ruby/longestWord.rb
function longestWord (line 1) | def longestWord(text)
FILE: Arcade/Intro/Ruby/makeArrayConsecutive2.rb
function makeArrayConsecutive2 (line 1) | def makeArrayConsecutive2(statues)
FILE: Arcade/Intro/Ruby/matrixElementsSum.rb
function matrixElementsSum (line 1) | def matrixElementsSum(matrix)
FILE: Arcade/Intro/Ruby/messageFromBinaryCode.rb
function messageFromBinaryCode (line 1) | def messageFromBinaryCode(code)
FILE: Arcade/Intro/Ruby/palindromeRearranging.rb
function palindromeRearranging (line 1) | def palindromeRearranging(inputString)
FILE: Arcade/Intro/Ruby/reverseInParentheses.rb
function reverseInParentheses (line 1) | def reverseInParentheses(inputString)
FILE: Arcade/Intro/Ruby/shapeArea.rb
function shapeArea (line 1) | def shapeArea(n)
FILE: Arcade/Intro/Ruby/sortByHeight.rb
function sortByHeight (line 1) | def sortByHeight(a)
FILE: Arcade/Intro/Ruby/sudoku.rb
function sudoku (line 1) | def sudoku(grid)
FILE: Arcade/Intro/Ruby/sumUpNumbers.rb
function sumUpNumbers (line 1) | def sumUpNumbers(inputString)
FILE: Arcade/Intro/Ruby/validTime.rb
function validTime (line 1) | def validTime(time)
FILE: Arcade/Intro/Ruby/variableName.rb
function variableName (line 1) | def variableName(name)
FILE: Arcade/Intro/javascript/absoluteValuesSumMinimization.js
function absoluteValuesSumMinimization (line 1) | function absoluteValuesSumMinimization(a) {
FILE: Arcade/Intro/javascript/addBorder.js
function addBorder (line 1) | function addBorder(picture) {
FILE: Arcade/Intro/javascript/adjacentElementsProduct.js
function adjacentElementsProduct (line 1) | function adjacentElementsProduct(inputArray) {
FILE: Arcade/Intro/javascript/allLongestStrings.js
function allLongestStrings (line 1) | function allLongestStrings(inputArray) {
FILE: Arcade/Intro/javascript/almostIncreasingSequence.js
function almostIncreasingSequence (line 1) | function almostIncreasingSequence(sequence) {
FILE: Arcade/Intro/javascript/alphabeticShift.js
function alphabeticShift (line 1) | function alphabeticShift(inputString) {
FILE: Arcade/Intro/javascript/alternatingSums.js
function alternatingSums (line 1) | function alternatingSums(a) {
FILE: Arcade/Intro/javascript/areEquallyStrong.js
function areEquallyStrong (line 1) | function areEquallyStrong(yourLeft, yourRight, friendsLeft, friendsRight) {
FILE: Arcade/Intro/javascript/areSimilar.js
function areSimilar (line 1) | function areSimilar(a, b) {
FILE: Arcade/Intro/javascript/arrayChange.js
function arrayChange (line 1) | function arrayChange(inputArray) {
FILE: Arcade/Intro/javascript/arrayMaxConsecutiveSum.js
function arrayMaxConsecutiveSum (line 1) | function arrayMaxConsecutiveSum(inputArray, k) {
FILE: Arcade/Intro/javascript/arrayMaximalAdjacentDifference.js
function arrayMaximalAdjacentDifference (line 1) | function arrayMaximalAdjacentDifference(inputArray) {
FILE: Arcade/Intro/javascript/arrayReplace.js
function arrayReplace (line 1) | function arrayReplace(inputArray, elemToReplace, substitutionElem) {
FILE: Arcade/Intro/javascript/avoidObstacles.js
function avoidObstacles (line 1) | function avoidObstacles(inputArray) {
FILE: Arcade/Intro/javascript/bishopAndPawn.js
function bishopAndPawn (line 1) | function bishopAndPawn(bishop, pawn) {
FILE: Arcade/Intro/javascript/boxBlur.js
function boxBlur (line 1) | function boxBlur(image) {
FILE: Arcade/Intro/javascript/buildPalindrome.js
function reverse (line 1) | function reverse(s) {
function buildPalindrome (line 7) | function buildPalindrome(st) {
FILE: Arcade/Intro/javascript/centuryFromYear.js
function centuryFromYear (line 1) | function centuryFromYear(year) {
FILE: Arcade/Intro/javascript/checkPalindrome.js
function checkPalindrome (line 1) | function checkPalindrome(string) {
FILE: Arcade/Intro/javascript/chessBoardCellColo.js
function chessBoardCellColor (line 1) | function chessBoardCellColor(cell1, cell2) {
FILE: Arcade/Intro/javascript/chessKnight.js
function isSafe (line 1) | function isSafe(x, y) {
function chessKnight (line 5) | function chessKnight(cell) {
FILE: Arcade/Intro/javascript/circleOfNumbers.js
function circleOfNumbers (line 1) | function circleOfNumbers(n, firstNumber) {
FILE: Arcade/Intro/javascript/commonCharacterCount.js
function commonCharacterCount (line 1) | function commonCharacterCount(s1, s2) {
FILE: Arcade/Intro/javascript/deleteDigit.js
function deleteDigit (line 1) | function deleteDigit(n) {
FILE: Arcade/Intro/javascript/depositProfit.js
function depositProfit (line 1) | function depositProfit(deposit, rate, threshold) {
FILE: Arcade/Intro/javascript/differentSquares.js
function differentSquares (line 1) | function differentSquares(matrix) {
FILE: Arcade/Intro/javascript/differentSymbolsNaive.js
function differentSymbolsNaive (line 1) | function differentSymbolsNaive(s) {
FILE: Arcade/Intro/javascript/digitDegree.js
function digitDegree (line 1) | function digitDegree(n) {
FILE: Arcade/Intro/javascript/digitsProduct.js
function digitsProduct (line 1) | function digitsProduct(product) {
FILE: Arcade/Intro/javascript/electionsWinners.js
function electionsWinners (line 1) | function electionsWinners(votes, k) {
FILE: Arcade/Intro/javascript/evenDigitsOnly.js
function evenDigitsOnly (line 1) | function evenDigitsOnly(n) {
FILE: Arcade/Intro/javascript/extractEachKth.js
function extractEachKth (line 1) | function extractEachKth(inputArray, k) {
FILE: Arcade/Intro/javascript/fileNaming.js
function fileNaming (line 1) | function fileNaming(names) {
FILE: Arcade/Intro/javascript/findEmailDomain.js
function findEmailDomain (line 1) | function findEmailDomain(address) {
FILE: Arcade/Intro/javascript/firstDigit.js
function firstDigit (line 1) | function firstDigit(inputString) {
FILE: Arcade/Intro/javascript/isBeautifulString.js
function isBeautifulString (line 1) | function isBeautifulString(inputString) {
FILE: Arcade/Intro/javascript/isDigit.js
function isDigit (line 1) | function isDigit(symbol) {
FILE: Arcade/Intro/javascript/isIPv4Address.js
function isIPv4Address (line 1) | function isIPv4Address(inputString) {
FILE: Arcade/Intro/javascript/isLucky.js
function isLucky (line 1) | function isLucky(n) {
FILE: Arcade/Intro/javascript/isMAC48Address.js
function isMAC48Address (line 1) | function isMAC48Address(inputString) {
FILE: Arcade/Intro/javascript/knapsackLight.js
function knapsackLight (line 1) | function knapsackLight(value1, weight1, value2, weight2, maxW) {
FILE: Arcade/Intro/javascript/lineEncoding.js
function lineEncoding (line 1) | function lineEncoding(s) {
FILE: Arcade/Intro/javascript/longestDigitsPrefix.js
function longestDigitsPrefix (line 1) | function longestDigitsPrefix(inputString) {
FILE: Arcade/Intro/javascript/longestWord.js
function longestWord (line 1) | function longestWord(text) {
FILE: Arcade/Intro/javascript/makeArrayConsecutive2.js
function makeArrayConsecutive2 (line 1) | function makeArrayConsecutive2(statues) {
FILE: Arcade/Intro/javascript/matrixElementsSum.js
function matrixElementsSum (line 1) | function matrixElementsSum(matrix) {
FILE: Arcade/Intro/javascript/messageFromBinaryCode.js
function messageFromBinaryCode (line 1) | function messageFromBinaryCode(code) {
FILE: Arcade/Intro/javascript/minesweeper.js
function minesweeper (line 1) | function minesweeper(matrix) {
FILE: Arcade/Intro/javascript/palindromeRearranging.js
function palindromeRearranging (line 1) | function palindromeRearranging(inputString) {
FILE: Arcade/Intro/javascript/reverseInParentheses.js
function reverseString (line 1) | function reverseString(str) {
function reverseInParentheses (line 7) | function reverseInParentheses(inputString) {
FILE: Arcade/Intro/javascript/shapeArea.js
function shapeArea (line 1) | function shapeArea(n) {
FILE: Arcade/Intro/javascript/sortByHeight.js
function sortByHeight (line 1) | function sortByHeight(a) {
FILE: Arcade/Intro/javascript/spiralNumbers.js
function spiralNumbers (line 1) | function spiralNumbers(n) {
FILE: Arcade/Intro/javascript/sudoku.js
function sudoku (line 1) | function sudoku(grid) {
FILE: Arcade/Intro/javascript/sumUpNumbers.js
function sumUpNumbers (line 1) | function sumUpNumbers(inputString) {
FILE: Arcade/Intro/javascript/validTime.js
function validTime (line 1) | function validTime(time) {
FILE: Arcade/Intro/javascript/variableName.js
function variableName (line 1) | function variableName(name) {
FILE: Arcade/TheCore/C++/differentRightmostBit.cpp
function differentRightmostBit (line 1) | int differentRightmostBit(int n, int m) {
FILE: Arcade/TheCore/C++/equalPairOfBits.cpp
function equalPairOfBits (line 1) | int equalPairOfBits(int n, int m) {
FILE: Arcade/TheCore/C++/killKthBit.cpp
function killKthBit (line 5) | int killKthBit(int n, int k) {
FILE: Arcade/TheCore/C++/secondRightmostZeroBit.cpp
function secondRightmostZeroBit (line 1) | int secondRightmostZeroBit(int n) {
FILE: Arcade/TheCore/C++/swapAdjacentBits.cpp
function swapAdjacentBits (line 1) | int swapAdjacentBits(int n) {
FILE: Arcade/TheCore/Java/AddTwoDigits.java
class AddTwoDigits (line 1) | final class AddTwoDigits {
method addTwoDigits (line 3) | int addTwoDigits(int n) {
FILE: Arcade/TheCore/Java/AdditionWithoutCarrying.java
class AdditionWithoutCarrying (line 1) | final class AdditionWithoutCarrying {
method additionWithoutCarrying (line 3) | int additionWithoutCarrying(int param1, int param2) {
FILE: Arcade/TheCore/Java/AppleBoxes.java
class AppleBoxes (line 1) | final class AppleBoxes {
method appleBoxes (line 3) | int appleBoxes(int k) {
FILE: Arcade/TheCore/Java/ArithmeticExpression.java
class ArithmeticExpression (line 1) | final class ArithmeticExpression {
method arithmeticExpression (line 3) | boolean arithmeticExpression(int a, int b, int c) {
FILE: Arcade/TheCore/Java/ArrayPacking.java
class ArrayPacking (line 1) | final class ArrayPacking {
method arrayPacking (line 3) | int arrayPacking(int[] a) {
FILE: Arcade/TheCore/Java/ArrayReplace.java
class ArrayReplace (line 3) | final class ArrayReplace {
method arrayReplace (line 5) | int[] arrayReplace(int[] inputArray, int elemToReplace, int substituti...
FILE: Arcade/TheCore/Java/Candies.java
class Candies (line 1) | final class Candies {
method candies (line 3) | int candies(int n, int m) {
FILE: Arcade/TheCore/Java/Candles.java
class Candles (line 1) | final class Candles {
method candles (line 3) | int candles(int candlesNumber, int makeNew) {
FILE: Arcade/TheCore/Java/CircleOfNumbers.java
class CircleOfNumbers (line 1) | final class CircleOfNumbers {
method circleOfNumbers (line 3) | int circleOfNumbers(int n, int firstNumber) {
FILE: Arcade/TheCore/Java/ComfortableNumbers.java
class ComfortableNumbers (line 3) | final class ComfortableNumbers {
method comfortableNumbers (line 5) | int comfortableNumbers(int l, int r) {
FILE: Arcade/TheCore/Java/ConcatenateArrays.java
class ConcatenateArrays (line 1) | final class ConcatenateArrays {
method concatenateArrays (line 3) | int[] concatenateArrays(int[] a, int[] b) {
FILE: Arcade/TheCore/Java/CountBlackCells.java
class CountBlackCells (line 1) | final class CountBlackCells {
method gcd (line 3) | int gcd(int a, int b) {
method countBlackCells (line 10) | int countBlackCells(int n, int m) {
FILE: Arcade/TheCore/Java/CountSumOfTwoRepresentations2.java
class CountSumOfTwoRepresentations2 (line 1) | final class CountSumOfTwoRepresentations2 {
method countSumOfTwoRepresentations2 (line 3) | int countSumOfTwoRepresentations2(int n, int l, int r) {
FILE: Arcade/TheCore/Java/CreateArray.java
class CreateArray (line 1) | final class CreateArray {
method createArray (line 3) | int[] createArray(int size) {
FILE: Arcade/TheCore/Java/ExtraNumber.java
class ExtraNumber (line 1) | final class ExtraNumber {
method extraNumber (line 3) | int extraNumber(int a, int b, int c) {
FILE: Arcade/TheCore/Java/FirstReverseTry.java
class FirstReverseTry (line 1) | final class FirstReverseTry {
method firstReverseTry (line 3) | int[] firstReverseTry(int[] arr) {
FILE: Arcade/TheCore/Java/IncreaseNumberRoundness.java
class IncreaseNumberRoundness (line 1) | final class IncreaseNumberRoundness {
method increaseNumberRoundness (line 3) | boolean increaseNumberRoundness(int n) {
FILE: Arcade/TheCore/Java/IsInfiniteProcess.java
class IsInfiniteProcess (line 1) | final class IsInfiniteProcess {
method isInfiniteProcess (line 3) | boolean isInfiniteProcess(int a, int b) {
FILE: Arcade/TheCore/Java/IsPower.java
class IsPower (line 1) | final class IsPower {
method isPower (line 3) | boolean isPower(int n) {
FILE: Arcade/TheCore/Java/IsSmooth.java
class IsSmooth (line 1) | final class IsSmooth {
method isSmooth (line 3) | boolean isSmooth(int[] arr) {
FILE: Arcade/TheCore/Java/IsSumOfConsecutive2.java
class IsSumOfConsecutive2 (line 1) | final class IsSumOfConsecutive2 {
method isSumOfConsecutive2 (line 3) | int isSumOfConsecutive2(int n) {
FILE: Arcade/TheCore/Java/KnapsackLight.java
class KnapsackLight (line 1) | final class KnapsackLight {
method knapsackLight (line 3) | int knapsackLight(int value1, int weight1, int value2, int weight2, in...
FILE: Arcade/TheCore/Java/LargestNumber.java
class LargestNumber (line 1) | final class LargestNumber {
method largestNumber (line 3) | int largestNumber(int n) {
FILE: Arcade/TheCore/Java/LateRide.java
class LateRide (line 1) | final class LateRide {
method lateRide (line 3) | int lateRide(int n) {
FILE: Arcade/TheCore/Java/LeastFactorial.java
class LeastFactorial (line 1) | final class LeastFactorial {
method fact (line 3) | int fact(int n) {
method leastFactorial (line 7) | int leastFactorial(int n) {
FILE: Arcade/TheCore/Java/LineUp.java
class LineUp (line 1) | final class LineUp {
method lineUp (line 3) | int lineUp(String commands) {
FILE: Arcade/TheCore/Java/MagicalWell.java
class MagicalWell (line 1) | final class MagicalWell {
method magicalWell (line 3) | int magicalWell(int a, int b, int n) {
FILE: Arcade/TheCore/Java/MakeArrayConsecutive2.java
class MakeArrayConsecutive2 (line 1) | final class MakeArrayConsecutive2 {
method makeArrayConsecutive2 (line 3) | int makeArrayConsecutive2(int[] statues) {
FILE: Arcade/TheCore/Java/MaxMultiple.java
class MaxMultiple (line 1) | final class MaxMultiple {
method maxMultiple (line 4) | int maxMultiple(int divisor, int bound) {
FILE: Arcade/TheCore/Java/MetroCard.java
class MetroCard (line 1) | final class MetroCard {
method metroCard (line 3) | int[] metroCard(int lastNumberOfDays) {
FILE: Arcade/TheCore/Java/MirrorBits.java
class MirrorBits (line 1) | final class MirrorBits {
method mirrorBits (line 3) | int mirrorBits(int a) {
FILE: Arcade/TheCore/Java/PagesNumberingWithInk.java
class PagesNumberingWithInk (line 1) | final class PagesNumberingWithInk {
method pagesNumberingWithInk (line 3) | int pagesNumberingWithInk(int current, int numberOfDigits) {
FILE: Arcade/TheCore/Java/PhoneCall.java
class PhoneCall (line 1) | final class PhoneCall {
method phoneCall (line 3) | int phoneCall(int min1, int min2_10, int min11, int s) {
FILE: Arcade/TheCore/Java/RangeBitCount.java
class RangeBitCount (line 3) | final class RangeBitCount {
method rangeBitCount (line 5) | int rangeBitCount(int a, int b) {
FILE: Arcade/TheCore/Java/ReachNextLevel.java
class ReachNextLevel (line 1) | final class ReachNextLevel {
method reachNextLevel (line 3) | boolean reachNextLevel(int experience, int threshold, int reward) {
FILE: Arcade/TheCore/Java/RectangleRotation.java
class RectangleRotation (line 1) | final class RectangleRotation {
method solution (line 3) | int solution(int a, int b) {
FILE: Arcade/TheCore/Java/RemoveArrayPart.java
class RemoveArrayPart (line 1) | final class RemoveArrayPart {
method removeArrayPart (line 3) | int[] removeArrayPart(int[] inputArray, int l, int r) {
FILE: Arcade/TheCore/Java/ReplaceMiddle.java
class ReplaceMiddle (line 1) | final class ReplaceMiddle {
method replaceMiddle (line 3) | int[] replaceMiddle(int[] arr) {
FILE: Arcade/TheCore/Java/Rounders.java
class Rounders (line 1) | final class Rounders {
method rounders (line 3) | int rounders(int n) {
FILE: Arcade/TheCore/Java/SeatsInTheater.java
class SeatsInTheater (line 1) | final class SeatsInTheater {
method seatsInTheater (line 3) | int seatsInTheater(int nCols, int nRows, int col, int row) {
FILE: Arcade/TheCore/Java/SquareDigitsSequence.java
class SquareDigitsSequence (line 5) | final class SquareDigitsSequence {
method squareDigitsSequence (line 7) | int squareDigitsSequence(int a0) {
FILE: Arcade/TheCore/Java/TennisSet.java
class TennisSet (line 1) | final class TennisSet {
method tennisSet (line 3) | boolean tennisSet(int score1, int score2) {
FILE: Arcade/TheCore/Java/WeakNumbers.java
class WeakNumbers (line 4) | final class WeakNumbers {
method weakNumbers (line 6) | int[] weakNumbers(int n) {
FILE: Arcade/TheCore/Java/WillYou.java
class WillYou (line 1) | final class WillYou {
method willYou (line 3) | boolean willYou(boolean young, boolean beautiful, boolean loved) {
FILE: Arcade/TheCore/Javascript/addTwoDigits.js
function addTwoDigits (line 1) | function addTwoDigits(n) {
FILE: Arcade/TheCore/Javascript/additionWithoutCarrying.js
function additionWithoutCarrying (line 1) | function additionWithoutCarrying(param1, param2) {
FILE: Arcade/TheCore/Javascript/appleBoxes.js
function appleBoxes (line 1) | function appleBoxes(k) {
FILE: Arcade/TheCore/Javascript/arithmeticExpression.js
function arithmeticExpression (line 1) | function arithmeticExpression(a, b, c) {
FILE: Arcade/TheCore/Javascript/arrayPacking.js
function arrayPacking (line 1) | function arrayPacking(a) {
FILE: Arcade/TheCore/Javascript/arrayReplace.js
function arrayReplace (line 1) | function arrayReplace(inputArray, elemToReplace, substitutionElem) {
FILE: Arcade/TheCore/Javascript/candies.js
function candies (line 1) | function candies(n, m) {
FILE: Arcade/TheCore/Javascript/candles.js
function candles (line 1) | function candles(candlesNumber, makeNew) {
FILE: Arcade/TheCore/Javascript/circleOfNumbers.js
function circleOfNumbers (line 1) | function circleOfNumbers(n, firstNumber) {
FILE: Arcade/TheCore/Javascript/comfortableNumbers.js
function s (line 1) | function s(n) {
function comfortableNumbers (line 5) | function comfortableNumbers(l, r) {
FILE: Arcade/TheCore/Javascript/concatenateArrays.js
function concatenateArrays (line 1) | function concatenateArrays(a, b) {
FILE: Arcade/TheCore/Javascript/countBlackCells.js
function gcd (line 1) | function gcd(a, b) {
function countBlackCells (line 8) | function countBlackCells(n, m) {
FILE: Arcade/TheCore/Javascript/countSumOfTwoRepresentations2.js
function countSumOfTwoRepresentations2 (line 1) | function countSumOfTwoRepresentations2(n, l, r) {
FILE: Arcade/TheCore/Javascript/createArray.js
function createArray (line 1) | function createArray(size) {
FILE: Arcade/TheCore/Javascript/differentRightmostBit.js
function differentRightmostBit (line 1) | function differentRightmostBit(n, m) {
FILE: Arcade/TheCore/Javascript/extraNumber.js
function extraNumber (line 1) | function extraNumber(a, b, c) {
FILE: Arcade/TheCore/Javascript/firstReverseTry.js
function firstReverseTry (line 1) | function firstReverseTry(arr) {
FILE: Arcade/TheCore/Javascript/increaseNumberRoundness.js
function increaseNumberRoundness (line 1) | function increaseNumberRoundness(n) {
FILE: Arcade/TheCore/Javascript/isInfiniteProcess.js
function isInfiniteProcess (line 1) | function isInfiniteProcess(a, b) {
FILE: Arcade/TheCore/Javascript/isPower.js
function isPower (line 1) | function isPower(n) {
FILE: Arcade/TheCore/Javascript/isSmooth.js
function isSmooth (line 1) | function isSmooth(arr) {
FILE: Arcade/TheCore/Javascript/isSumOfConsecutive2.js
function isSumOfConsecutive2 (line 1) | function isSumOfConsecutive2(n) {
FILE: Arcade/TheCore/Javascript/knapsackLight.js
function knapsackLight (line 1) | function knapsackLight(value1, weight1, value2, weight2, maxW) {
FILE: Arcade/TheCore/Javascript/largestNumber.js
function largestNumber (line 1) | function largestNumber(n) {
FILE: Arcade/TheCore/Javascript/lateRide.js
function lateRide (line 1) | function lateRide(n) {
FILE: Arcade/TheCore/Javascript/leastFactorial.js
function fact (line 1) | function fact(n) {
function leastFactorial (line 6) | function leastFactorial(n) {
FILE: Arcade/TheCore/Javascript/lineUp.js
function lineUp (line 1) | function lineUp(commands) {
FILE: Arcade/TheCore/Javascript/magicalWell.js
function magicalWell (line 1) | function magicalWell(a, b, n) {
FILE: Arcade/TheCore/Javascript/makeArrayConsecutive2.js
function makeArrayConsecutive2 (line 1) | function makeArrayConsecutive2(statues) {
FILE: Arcade/TheCore/Javascript/maxMultiple.js
function maxMultiple (line 1) | function maxMultiple(divisor, bound) {
FILE: Arcade/TheCore/Javascript/metroCard.js
function metroCard (line 1) | function metroCard(lastNumberOfDays) {
FILE: Arcade/TheCore/Javascript/mirrorBits.js
function mirrorBits (line 1) | function mirrorBits(a) {
FILE: Arcade/TheCore/Javascript/pagesNumberingWithInk.js
function pagesNumberingWithInk (line 1) | function pagesNumberingWithInk(current, numberOfDigits) {
FILE: Arcade/TheCore/Javascript/phoneCall.js
function phoneCall (line 1) | function phoneCall(min1, min2_10, min11, s) {
FILE: Arcade/TheCore/Javascript/rangeBitCount.js
function rangeBitCount (line 1) | function rangeBitCount(a, b) {
FILE: Arcade/TheCore/Javascript/reachNextLevel.js
function reachNextLevel (line 1) | function reachNextLevel(experience, threshold, reward) {
FILE: Arcade/TheCore/Javascript/rectangleRotation.js
function solution (line 1) | function solution(a, b) {
FILE: Arcade/TheCore/Javascript/removeArrayPart.js
function removeArrayPart (line 1) | function removeArrayPart(inputArray, l, r) {
FILE: Arcade/TheCore/Javascript/replaceMiddle.js
function replaceMiddle (line 1) | function replaceMiddle(arr) {
FILE: Arcade/TheCore/Javascript/rounders.js
function rounders (line 1) | function rounders(n) {
FILE: Arcade/TheCore/Javascript/seatsInTheater.js
function seatsInTheater (line 1) | function seatsInTheater(nCols, nRows, col, row) {
FILE: Arcade/TheCore/Javascript/squareDigitsSequence.js
function squareDigitsSequence (line 1) | function squareDigitsSequence(a0) {
FILE: Arcade/TheCore/Javascript/tennisSet.js
function tennisSet (line 1) | function tennisSet(score1, score2) {
FILE: Arcade/TheCore/Javascript/weakNumbers.js
function divisors (line 1) | function divisors(n) {
function weakness (line 10) | function weakness(n) {
function weakNumbers (line 20) | function weakNumbers(n) {
FILE: Arcade/TheCore/Javascript/willYou.js
function willYou (line 1) | function willYou(young, beautiful, loved) {
FILE: Challenges/Java/AddTwoDigits.java
class AddTwoDigits (line 1) | public final class AddTwoDigits {
method addTwoDigits (line 3) | int addTwoDigits(int n) {
FILE: Challenges/Java/AddTwoHugeNumbers.java
class AddTwoHugeNumbers (line 1) | final class AddTwoHugeNumbers {
method addTwoHugeNumbers (line 11) | ListNode<Integer> addTwoHugeNumbers(ListNode<Integer> a, ListNode<Inte...
method reverse (line 36) | ListNode<Integer> reverse(ListNode<Integer> head){
FILE: Challenges/Java/AdditionWithoutCarrying.java
class AdditionWithoutCarrying (line 1) | public final class AdditionWithoutCarrying {
method additionWithoutCarrying (line 3) | int additionWithoutCarrying(int a, int b) {
FILE: Challenges/Java/AmendTheSentence.java
class AmendTheSentence (line 1) | final class AmendTheSentence {
method amendTheSentence (line 3) | String amendTheSentence(String s) {
FILE: Challenges/Java/Bomber.java
class Bomber (line 1) | final class Bomber {
method deadEnemies (line 2) | int deadEnemies(char[][] field, int x, int y) {
method bomber (line 28) | int bomber(char[][] field) {
FILE: Challenges/Java/CampusCup.java
class CampusCup (line 5) | final class CampusCup {
method campusCup (line 7) | String[] campusCup(String[] emails) {
FILE: Challenges/Java/CatalogUpdate.java
class CatalogUpdate (line 5) | final class CatalogUpdate {
method catalogUpdate (line 7) | String[][] catalogUpdate(String[][] catalog, String[][] updates) {
FILE: Challenges/Java/CharacterParity.java
class CharacterParity (line 1) | final class CharacterParity {
method characterParity (line 3) | String characterParity(char symbol) {
FILE: Challenges/Java/ChristmasTree.java
class ChristmasTree (line 1) | final class ChristmasTree {
method christmasTree (line 3) | String[] christmasTree(int ln, int lh) {
FILE: Challenges/Java/ClassifyStrings.java
class ClassifyStrings (line 4) | public final class ClassifyStrings {
method check (line 6) | String check(String s) {
method classifyStrings (line 11) | String classifyStrings(String s) {
FILE: Challenges/Java/ClosestInTree.java
class ClosestInTree (line 1) | final class ClosestInTree {
method recTree (line 12) | void recTree(Tree<Integer> t, Vector<Integer> v) {
method btsTree (line 18) | int btsTree(Tree<Integer> t, int n) {
method getClosest (line 54) | int getClosest(int n1, int n2, int i) {
method closestInTree (line 58) | int closestInTree(Tree<Integer> t, int n) {
FILE: Challenges/Java/CommonCharacterCount2.java
class CommonCharacterCount2 (line 1) | public final class CommonCharacterCount2 {
method commonCharacterCount2 (line 3) | int commonCharacterCount2(String[] s) {
FILE: Challenges/Java/CompanyBotStrategy.java
class CompanyBotStrategy (line 1) | public final class CompanyBotStrategy {
method companyBotStrategy (line 3) | double companyBotStrategy(int[][] trainingData) {
FILE: Challenges/Java/ComposeRanges.java
class ComposeRanges (line 1) | public final class ComposeRanges {
method composeRanges (line 3) | String[] composeRanges(int[] n) {
FILE: Challenges/Java/ContainsCloseNums.java
class ContainsCloseNums (line 1) | final class ContainsCloseNums {
method containsCloseNums (line 3) | boolean containsCloseNums(int[] nums, int k) {
FILE: Challenges/Java/ContainsDuplicates.java
class ContainsDuplicates (line 1) | final class ContainsDuplicates {
method containsDuplicates (line 3) | boolean containsDuplicates(int[] a) {
FILE: Challenges/Java/CorrectNonogram.java
class CorrectNonogram (line 3) | final class CorrectNonogram {
method correctNonogram (line 5) | boolean correctNonogram(int size, String[][] nonogramField) {
FILE: Challenges/Java/CountClouds.java
class CountClouds (line 1) | final class CountClouds {
method checker (line 5) | void checker(char sky[][], int i, int j) {
method countClouds (line 17) | int countClouds(char[][] skyMap) {
FILE: Challenges/Java/DayOfWeek.java
class DayOfWeek (line 3) | final class DayOfWeek {
method dayOfWeek (line 5) | int dayOfWeek(String birthdayDate) {
FILE: Challenges/Java/DomainType.java
class DomainType (line 1) | final class DomainType {
method domainType (line 3) | String[] domainType(String[] domains) {
FILE: Challenges/Java/DrawRectangle.java
class DrawRectangle (line 1) | final class DrawRectangle {
method drawRectangle (line 3) | char[][] drawRectangle(char[][] canvas, int[] rect) {
FILE: Challenges/Java/EquilibriumPoint.java
class EquilibriumPoint (line 1) | final class EquilibriumPoint {
method equilibriumPoint (line 3) | int equilibriumPoint(int[] a) {
FILE: Challenges/Java/ExcelSheetColumnNumber.java
class ExcelSheetColumnNumber (line 1) | public final class ExcelSheetColumnNumber {
method excelSheetColumnNumber (line 3) | int excelSheetColumnNumber(String s) {
FILE: Challenges/Java/FancyRide.java
class FancyRide (line 3) | public final class FancyRide {
method fancyRide (line 5) | String fancyRide(int l, double[] fares) {
FILE: Challenges/Java/FareEstimator.java
class FareEstimator (line 3) | final class FareEstimator {
method fareEstimator (line 5) | double[] fareEstimator(int ride_time, int ride_distance, double[] cost...
FILE: Challenges/Java/FileNaming.java
class FileNaming (line 1) | public final class FileNaming {
method fileNaming (line 3) | String[] fileNaming(String[] names) {
FILE: Challenges/Java/FindMiddleElement.java
class FindMiddleElement (line 1) | final class FindMiddleElement {
method findMiddleElement (line 13) | int findMiddleElement(ListNode<Integer> l) {
FILE: Challenges/Java/FindSubarrayBySum.java
class FindSubarrayBySum (line 1) | final class FindSubarrayBySum {
method findSubarrayBySum (line 3) | int[] findSubarrayBySum(int s, int[] arr) {
FILE: Challenges/Java/FractionReducing.java
class FractionReducing (line 1) | final class FractionReducing {
method fractionReducing (line 3) | int[] fractionReducing(int[] fraction) {
FILE: Challenges/Java/GiftSafety.java
class GiftSafety (line 1) | public final class GiftSafety {
method giftSafety (line 3) | int giftSafety(String gift) {
FILE: Challenges/Java/HappyNumber.java
class HappyNumber (line 4) | final class HappyNumber {
method happyNumber (line 6) | boolean happyNumber(int n) {
FILE: Challenges/Java/HigherVersion2.java
class HigherVersion2 (line 1) | final class HigherVersion2 {
method higherVersion2 (line 3) | int higherVersion2(String a, String b) {
FILE: Challenges/Java/InsertBits.java
class InsertBits (line 1) | public final class InsertBits {
method insertBits (line 3) | int insertBits(int n, int a, int b, int k) {
FILE: Challenges/Java/IsListPalindrome.java
class IsListPalindrome (line 3) | final class IsListPalindrome {
method isListPalindrome (line 14) | boolean isListPalindrome(ListNode<Integer> l) {
FILE: Challenges/Java/IsPowerOfTwo2.java
class IsPowerOfTwo2 (line 1) | public final class IsPowerOfTwo2 {
method isPowerOfTwo2 (line 3) | boolean isPowerOfTwo2(long n) {
FILE: Challenges/Java/JumpingJimmy.java
class JumpingJimmy (line 1) | public class JumpingJimmy {
method jumpingJimmy (line 3) | int jumpingJimmy(int[] tower, int jumpHeight) {
FILE: Challenges/Java/KthLargestElement.java
class KthLargestElement (line 3) | public final class KthLargestElement {
method kthLargestElement (line 5) | int kthLargestElement(int[] n, int k) {
FILE: Challenges/Java/LongestCommonSubstring.java
class LongestCommonSubstring (line 4) | public final class LongestCommonSubstring {
method longestCommonSubstring (line 6) | int longestCommonSubstring(String s, String t) {
method main (line 25) | public static void main(String[] args) {
FILE: Challenges/Java/Lrc2subRip.java
class Lrc2subRip (line 1) | public final class Lrc2subRip {
method formatConverter (line 3) | String formatConverter(String str) {
method lrc2subRip (line 15) | String[] lrc2subRip(String[] lrcLyrics, String songLength) {
FILE: Challenges/Java/LunchSequenceChecker.java
class LaunchSequenceChecker (line 5) | final class LaunchSequenceChecker {
method launchSequenceChecker (line 7) | boolean launchSequenceChecker(String[] systemNames, int[] stepNumbers) {
FILE: Challenges/Java/MaximumSum.java
class MaximumSum (line 1) | final class MaximumSum {
method swap (line 5) | void swap(int[] arr, int i, int j) {
method permute (line 11) | void permute(int[] arr, int l, int h, int[][] q) {
method maximumSum (line 25) | int maximumSum(int[] a, int[][] q) {
FILE: Challenges/Java/MergeTwoLinkedLists.java
class MergeTwoLinkedLists (line 1) | final class MergeTwoLinkedLists {
method append (line 12) | ListNode<Integer> append(ListNode<Integer> ln, int data) {
method mergeTwoLinkedLists (line 23) | ListNode<Integer> mergeTwoLinkedLists(ListNode<Integer> l1, ListNode<I...
FILE: Challenges/Java/MirrorBits.java
class MirrorBits (line 1) | final class MirrorBits {
method mirrorBits (line 3) | int mirrorBits(int a) {
FILE: Challenges/Java/MissingNumber.java
class MissingNumber (line 1) | final class MissingNumber {
method missingNumber (line 3) | int missingNumber(int[] arr) {
FILE: Challenges/Java/NewRoadSystem.java
class NewRoadSystem (line 3) | public final class NewRoadSystem {
method newRoadSystem (line 5) | boolean newRoadSystem(boolean[][] roadRegister) {
FILE: Challenges/Java/NextLarger.java
class NextLarger (line 1) | public final class NextLarger {
method nextLarger (line 3) | int[] nextLarger(int[] a) {
FILE: Challenges/Java/NthElementFromTheEnd.java
class NthElementFromTheEnd (line 1) | public final class NthElementFromTheEnd {
method nthElementFromTheEnd (line 11) | int nthElementFromTheEnd(ListNode<Integer> l, int n) {
FILE: Challenges/Java/PairsSum.java
class PairsSum (line 1) | final class PairsSum {
method contains (line 3) | boolean contains(int[] a, int e) {
method pairsSum (line 8) | int pairsSum(int[] a) {
FILE: Challenges/Java/PolygonPerimeter.java
class PolygonPerimeter (line 1) | public final class PolygonPerimeter {
method polygonPerimeter (line 3) | int polygonPerimeter(boolean[][] matrix) {
FILE: Challenges/Java/PrimesSum2.java
class PrimeSum2 (line 1) | final class PrimeSum2 {
method primesSum2 (line 3) | int primesSum2(int n) {
FILE: Challenges/Java/ProCategorization.java
class ProCategorization (line 1) | final class ProCategorization {
method proCategorization (line 3) | String[][][] proCategorization(String[] pros, String[][] preferences) {
FILE: Challenges/Java/RangeBitCount.java
class RangeBitCount (line 1) | final class RangeBitCount {
method rangeBitCount (line 3) | int rangeBitCount(int a, int b) {
FILE: Challenges/Java/RemoveArrayPart.java
class RemoveArrayPart (line 1) | final class RemoveArrayPart {
method removeArrayPart (line 3) | int[] removeArrayPart(int[] inputArray, int l, int r) {
FILE: Challenges/Java/RemoveDuplicateStrings.java
class RemoveDuplicateStrings (line 1) | public final class RemoveDuplicateStrings {
method removeDuplicateStrings (line 3) | String[] removeDuplicateStrings(String[] inputArray) {
FILE: Challenges/Java/ReverseInteger.java
class ReverseInteger (line 1) | public final class ReverseInteger {
method reverseInteger (line 3) | int reverseInteger(int x) {
FILE: Challenges/Java/ReverseLinkedList.java
class ReverseLinkedList (line 1) | public final class ReverseLinkedList {
method reverse (line 13) | ListNode<Integer> reverse(ListNode<Integer> l) {
method reverseLinkedList (line 24) | ListNode<Integer> reverseLinkedList(ListNode<Integer> l) {
FILE: Challenges/Java/ReverseSentence.java
class ReverseSentence (line 1) | final class ReverseSentence {
method reverseSentence (line 3) | String reverseSentence(String sentence) {
FILE: Challenges/Java/ReverseVowelsOfString.java
class ReverseVowelsOfString (line 1) | public final class ReverseVowelsOfString {
method reverseVowelsOfString (line 3) | String reverseVowelsOfString(String s) {
FILE: Challenges/Java/RotateImage.java
class RotateImage (line 1) | final class RotateImage {
method rotateImage (line 3) | int[][] rotateImage(int[][] a) {
FILE: Challenges/Java/ShoppingCart.java
class ShoppingCart (line 1) | class ShoppingCart {
method shoppingCart (line 3) | String[] shoppingCart(String[] requests) {
class Item (line 43) | class Item implements Comparable<Item> {
method Item (line 49) | Item(int index, String name) {
method compareTo (line 54) | @Override
FILE: Challenges/Java/ShoppingList.java
class ShoppingList (line 3) | final class ShoppingList {
method shoppingList (line 5) | double shoppingList(String items) {
FILE: Challenges/Java/ShuffledArray.java
class ShuffledArray (line 4) | public final class ShuffledArray {
method shuffledArray (line 6) | int[] shuffledArray(int[] shuffled) {
FILE: Challenges/Java/SortByString.java
class SortByString (line 1) | final class SortByString {
method sortByString (line 3) | String sortByString(String s, String t) {
FILE: Challenges/Java/SortedSquareArray.java
class SortedSquareArray (line 1) | final class SortedSquareArray {
method sortedSquaredArray (line 3) | int[] sortedSquaredArray(int[] array) {
FILE: Challenges/Java/Sudoku2.java
class Sudoku2 (line 3) | final class Sudoku2 {
method sudoku2 (line 5) | boolean sudoku2(char[][] grid) {
FILE: Challenges/Java/SugarHigh.java
class SugarHigh (line 3) | public class SugarHigh {
method sugarHigh (line 5) | static int[] sugarHigh(int[] candies, int threshold) {
FILE: Challenges/Java/SumOfTwo.java
class SumOfTwo (line 1) | final class SumOfTwo {
method sumOfTwo (line 3) | boolean sumOfTwo(int[] a, int[] b, int v) {
FILE: Challenges/Java/SwitchLights.java
class SwitchLights (line 1) | final class SwitchLights {
method switchLights (line 3) | int[] switchLights(int[] a) {
FILE: Challenges/Java/TriangleExistence.java
class TriangleExistence (line 1) | public final class TriangleExistence {
method triangleExistence (line 3) | boolean triangleExistence(int[] sides) {
FILE: Challenges/Java/TwoArraysNthElement.java
class TwoArraysNthElement (line 1) | public final class TwoArraysNthElement {
method twoArraysNthElement (line 3) | int twoArraysNthElement(int[] array1, int[] array2, int n) {
FILE: Challenges/Java/Zigzag.java
class Zigzag (line 1) | public class Zigzag {
method zigzag (line 3) | static int zigzag(int[] a) {
FILE: Challenges/Javascript/amendTheSentence.js
function amendTheSentence (line 1) | function amendTheSentence(s) {
FILE: Challenges/Javascript/characterParity.js
function characterParity (line 1) | function characterParity(symbol) {
FILE: Challenges/Javascript/climbingStaircase.js
function combination (line 3) | function combination(arr,i, n, rn, u) {
function climbingStaircase (line 21) | function climbingStaircase(n, k) {
FILE: Challenges/Javascript/commonCharacterCount2.js
function commonCharacterCount2 (line 1) | function commonCharacterCount2(s) {
FILE: Challenges/Javascript/companyBotStrategy.js
function companyBotStrategy (line 1) | function companyBotStrategy(trainingData) {
FILE: Challenges/Javascript/containsCloseNums.js
function containsCloseNums (line 1) | function containsCloseNums(nums, k) {
FILE: Challenges/Javascript/containsDuplicates.js
function containsDuplicates (line 1) | function containsDuplicates(a) {
FILE: Challenges/Javascript/domainType.js
function domainType (line 1) | function domainType(domains) {
FILE: Challenges/Javascript/fancyRide.js
function fancyRide (line 1) | function fancyRide(l, fares) {
FILE: Challenges/Javascript/fareEstimator.js
function fareEstimator (line 1) | function fareEstimator(ride_time, ride_distance, cost_per_minute, cost_p...
FILE: Challenges/Javascript/fileNaming.js
function fileNaming (line 1) | function fileNaming(names) {
FILE: Challenges/Javascript/findMiddleElement.js
function findMiddleElement (line 7) | function findMiddleElement(l) {
FILE: Challenges/Javascript/findSubarrayBySum.js
function findSubarrayBySum (line 1) | function findSubarrayBySum(s, arr) {
FILE: Challenges/Javascript/happyNumber.js
function happyNumber (line 1) | function happyNumber(n) {
FILE: Challenges/Javascript/isListPalindrome.js
function isListPalindrome (line 7) | function isListPalindrome(l) {
FILE: Challenges/Javascript/isMAC48Address.js
function isMAC48Address (line 1) | function isMAC48Address(s) {
FILE: Challenges/Javascript/launchSequenceChecker.js
function launchSequenceChecker (line 1) | function launchSequenceChecker(systemNames, stepNumbers) {
FILE: Challenges/Javascript/maximumSum.js
function swap (line 3) | function swap(a, i, j) {
function permute (line 9) | function permute(a, l, h, q) {
function sum (line 22) | function sum(a, q) {
function maximumSum (line 28) | function maximumSum(a, q) {
FILE: Challenges/Javascript/mirrorBits.js
function reverseString (line 1) | function reverseString(s) {
function mirrorBits (line 7) | function mirrorBits(a) {
FILE: Challenges/Javascript/missingNumber.js
function missingNumber (line 1) | function missingNumber(arr) {
FILE: Challenges/Javascript/nextLarger.js
function nextLarger (line 1) | function nextLarger(a) {
FILE: Challenges/Javascript/pairsSum.js
function pairsSum (line 1) | function pairsSum(a) {
FILE: Challenges/Javascript/polygonPerimeter.js
function polygonPerimeter (line 1) | function polygonPerimeter(matrix) {
FILE: Challenges/Javascript/rangeBitCount.js
function rangeBitCount (line 1) | function rangeBitCount(a, b) {
FILE: Challenges/Javascript/removeArrayPart.js
function removeArrayPart (line 1) | function removeArrayPart(a, l, r) {
FILE: Challenges/Javascript/reverseSentence.js
function reverseSentence (line 1) | function reverseSentence(sentence) {
FILE: Challenges/Javascript/reverseVowelsOfString.js
function reverseVowelsOfString (line 1) | function reverseVowelsOfString(s) {
FILE: Challenges/Javascript/rotateImage.js
function rotateImage (line 1) | function rotateImage(a) {
FILE: Challenges/Javascript/sortByString.js
function sortByString (line 1) | function sortByString(s, t) {
FILE: Challenges/Javascript/sortedSquaredArray.js
function sortedSquaredArray (line 1) | function sortedSquaredArray(array) {
FILE: Challenges/Javascript/switchLights.js
function switchLights (line 1) | function switchLights(a) {
FILE: Challenges/Python/concatenateArrays.py
function concatenateArrays (line 1) | def concatenateArrays(a, b):
FILE: Challenges/Python/reverseSentence.py
function reverseSentence (line 1) | def reverseSentence(sentence):
FILE: Challenges/Ruby/addTwoDigits.rb
function addTwoDigits (line 1) | def addTwoDigits(n)
FILE: Challenges/Ruby/classifyStrings.rb
function classifyStrings (line 1) | def classifyStrings s
FILE: Challenges/Ruby/containsDuplicates.rb
function containsDuplicates (line 1) | def containsDuplicates(a)
FILE: Challenges/Ruby/excelSheetColumnNumber.rb
function excelSheetColumnNumber (line 1) | def excelSheetColumnNumber(s)
FILE: Challenges/Ruby/fractionReducing.rb
function fractionReducing (line 1) | def fractionReducing(fraction)
FILE: Challenges/Ruby/giftSafety.rb
function giftSafety (line 1) | def giftSafety(g)
FILE: Challenges/Ruby/groupsOfAnagrams.rb
function groupsOfAnagrams (line 1) | def groupsOfAnagrams w
FILE: Challenges/Ruby/higherVersion2.rb
function higherVersion2 (line 1) | def higherVersion2(a, b)
FILE: Challenges/Ruby/isCryptSolution.rb
function isCryptSolution (line 1) | def isCryptSolution(c, s)
FILE: Challenges/Ruby/kthLargestElement.rb
function kthLargestElement (line 1) | def kthLargestElement(n, k)
FILE: Challenges/Ruby/newRoadSystem.rb
function newRoadSystem (line 1) | def newRoadSystem(roadRegister)
FILE: Challenges/Ruby/nthElementFromTheEnd.rb
function nthElementFromTheEnd (line 9) | def nthElementFromTheEnd(l, n)
FILE: Challenges/Ruby/removeDuplicateStrings.rb
function removeDuplicateStrings (line 1) | def removeDuplicateStrings(inputArray)
FILE: Challenges/Ruby/reverseInteger.rb
function reverseInteger (line 1) | def reverseInteger x
FILE: Challenges/Ruby/rowsRearranging.rb
function rowsRearranging (line 1) | def rowsRearranging(m)
FILE: Challenges/Ruby/shuffledArray.rb
function shuffledArray (line 1) | def shuffledArray(shuffled)
FILE: Challenges/Ruby/triangleExistence.rb
function triangleExistence (line 1) | def triangleExistence(sides)
FILE: Challenges/Ruby/twoArraysNthElement.rb
function twoArraysNthElement (line 1) | def twoArraysNthElement(array1, array2, n)
FILE: InterviewPratice/Java/AddTwoHugeNumbers.java
class addTwoHugeNumbers (line 1) | final class addTwoHugeNumbers {
method addTwoHugeNumbers (line 11) | ListNode<Integer> addTwoHugeNumbers(ListNode<Integer> a, ListNode<Inte...
method reverse (line 40) | ListNode<Integer> reverse(ListNode<Integer> l){
FILE: InterviewPratice/Java/AmendTheSentence.java
class AmendTheSenteance (line 1) | final class AmendTheSenteance {
method amendTheSentence (line 3) | String amendTheSentence(String s) {
FILE: InterviewPratice/Java/ClassifyStrings.java
class ClassifyStrings (line 1) | final class ClassifyStrings {
method isGoodOrBad (line 3) | String isGoodOrBad(String s) {
method classifyStrings (line 8) | String classifyStrings(String s) {
FILE: InterviewPratice/Java/FirstDuplicate.java
class FirstDuplicate (line 4) | final class FirstDuplicate {
method firstDuplicate (line 6) | int firstDuplicate(int[] a) {
FILE: InterviewPratice/Java/FirstNotRepeatingCharacter.java
class FirstNotRepeatingCharacter (line 1) | final class FirstNotRepeatingCharacter {
method firstNotRepeatingCharacter (line 3) | char firstNotRepeatingCharacter(String s) {
FILE: InterviewPratice/Java/GroupingDishes.java
class GroupingDishes (line 3) | final class GroupingDishes {
method groupingDishes (line 5) | String[][] groupingDishes(String[][] dishes) {
method main (line 61) | public static void main(String[] arguments) {
FILE: InterviewPratice/Java/IsCryptSolution.java
class IsCryptSolution (line 1) | final class IsCryptSolution {
method isCryptSolution (line 3) | boolean isCryptSolution(String[] crypt, char[][] solution) {
FILE: InterviewPratice/Java/IsListPalindrome.java
class IsListPalindrome (line 1) | final class IsListPalindrome {
method isListPalindrome (line 13) | boolean isListPalindrome(ListNode<Integer> l) {
FILE: InterviewPratice/Java/MergeTwoLinkedLists.java
class mergeTwoLinkedLists (line 1) | final class mergeTwoLinkedLists {
method mergeTwoLinkedLists (line 12) | ListNode<Integer> mergeTwoLinkedLists(ListNode<Integer> l1, ListNode<I...
FILE: InterviewPratice/Java/RearrangeLastN.java
class RearrangeLastN (line 1) | final class RearrangeLastN {
method rearrangeLastN (line 13) | ListNode<Integer> rearrangeLastN(ListNode<Integer> l, int n) {
FILE: InterviewPratice/Java/RemoveKFromList.java
class RemoveKFromList (line 1) | final class RemoveKFromList {
method removeKFromList (line 12) | ListNode<Integer> removeKFromList(ListNode<Integer> l, int k) {
FILE: InterviewPratice/Java/ReverseNodeInKGroups.java
class ReverseNodeInKGroups (line 1) | final class ReverseNodeInKGroups {
method reverse (line 12) | ListNode<Integer> reverse(ListNode<Integer> l){
method reverseNodesInKGroups (line 24) | ListNode<Integer> reverseNodesInKGroups(ListNode<Integer> l, int k) {
FILE: InterviewPratice/Java/RotateImage.java
class RotateImage (line 1) | final class RotateImage {
method rotateImage (line 3) | int[][] rotateImage(int[][] a) {
FILE: InterviewPratice/Java/Strstr.java
class Strstr (line 1) | final class Strstr {
method strstr (line 3) | int strstr(String s, String x) {
FILE: InterviewPratice/Java/Sudoku2.java
class Sudoku2 (line 3) | final class Sudoku2 {
method sudoku2 (line 5) | boolean sudoku2(char[][] grid) {
FILE: InterviewPratice/Javascript/groupingDishes.js
function groupingDishes (line 1) | function groupingDishes(dishes) {
FILE: InterviewPratice/Javascript/isCryptSolution.js
function isCryptSolution (line 1) | function isCryptSolution(crypt, solution) {
FILE: InterviewPratice/Javascript/mergeTwoLinkedLists.js
function mergeTwoLinkedLists (line 7) | function mergeTwoLinkedLists(l1, l2) {
FILE: InterviewPratice/Ruby/firstDuplicate.rb
function firstDuplicate (line 1) | def firstDuplicate a
FILE: InterviewPratice/Ruby/firstNotRepeatingCharacter.rb
function firstNotRepeatingCharacter (line 1) | def firstNotRepeatingCharacter s
FILE: InterviewPratice/runlength_encoding.java
method encoding (line 1) | public static String encoding(String inputStream) {
Condensed preview — 550 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (238K chars).
[
{
"path": ".gitignore",
"chars": 4516,
"preview": "# Created by https://www.toptal.com/developers/gitignore/api/java,kotlin,node,c++,text,images,diskimage,sublimetext\n# Ed"
},
{
"path": "Arcade/Databases/alarmClocks.sql",
"chars": 499,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE alarmClocks()\nBEGIN\n SET @currentDate := (SELECT * FROM"
},
{
"path": "Arcade/Databases/automaticNotifications.sql",
"chars": 137,
"preview": "CREATE PROCEDURE automaticNotifications()\n SELECT email\n FROM users\n WHERE role NOT IN (\"admin\", \"premium\")\n\n "
},
{
"path": "Arcade/Databases/battleshipGameResults.sql",
"chars": 1011,
"preview": "CREATE PROCEDURE battleshipGameResults()\nBEGIN\n\t/* Write your SQL here. Terminate each statement with a semicolon. */\n "
},
{
"path": "Arcade/Databases/booksCatalogs.sql",
"chars": 212,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE booksCatalogs()\nBEGIN\n\tSELECT DISTINCT SUBSTRING_INDEX(Ext"
},
{
"path": "Arcade/Databases/bugsInComponent.sql",
"chars": 561,
"preview": "CREATE PROCEDURE bugsInComponent()\nBEGIN\n /* Write your SQL here. Terminate each statement with a semicolon. */\n S"
},
{
"path": "Arcade/Databases/checkExpenditure.sql",
"chars": 358,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE checkExpenditure()\nBEGIN\n SELECT ae.id AS id,\n IF(SU"
},
{
"path": "Arcade/Databases/closestCells.sql",
"chars": 319,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE closestCells()\nBEGIN\n SELECT l.id AS id1,\n (S"
},
{
"path": "Arcade/Databases/combinationLock.sql",
"chars": 170,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE combinationLock()\nBEGIN\n\tSELECT ROUND(EXP(SUM(LOG(LENGTH(c"
},
{
"path": "Arcade/Databases/companyEmployees.sql",
"chars": 178,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE companyEmployees()\nBEGIN\n\tSELECT dep_name, emp_name FROM d"
},
{
"path": "Arcade/Databases/consecutiveIds.sql",
"chars": 190,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE consecutiveIds()\nBEGIN\n SET @uid := 0;\n\tSELECT id AS ol"
},
{
"path": "Arcade/Databases/contestLeaderboard.sql",
"chars": 116,
"preview": "CREATE PROCEDURE contestLeaderboard()\nBEGIN\n SELECT name FROM leaderboard\n ORDER BY score DESC LIMIT 3, 5;\nEND"
},
{
"path": "Arcade/Databases/correctIPs.sql",
"chars": 193,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE correctIPs()\nBEGIN\n\tSELECT id, ip FROM ips\n WHERE ip RE"
},
{
"path": "Arcade/Databases/countriesInfo.sql",
"chars": 188,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE countriesInfo()\nBEGIN\n\tSELECT COUNT(*) AS number, AVG(popu"
},
{
"path": "Arcade/Databases/countriesSelection.sql",
"chars": 122,
"preview": "CREATE PROCEDURE countriesSelection()\nBEGIN\n\tSELECT * FROM countries WHERE continent = \"Africa\"\n ORDER BY name ASC;\nE"
},
{
"path": "Arcade/Databases/coursesDistribution.sql",
"chars": 464,
"preview": "CREATE PROCEDURE coursesDistribution()\nBEGIN\n ALTER TABLE groupcourses ADD FOREIGN KEY (course_id)\n REFERENCES cou"
},
{
"path": "Arcade/Databases/currencyCodes.sql",
"chars": 143,
"preview": "CREATE PROCEDURE currencyCodes()\nBEGIN\n DELETE FROM currencies\n WHERE LENGTH(code) != 3;\n\n SELECT * FROM curren"
},
{
"path": "Arcade/Databases/customerMessages.sql",
"chars": 681,
"preview": "DROP FUNCTION IF EXISTS response;\nCREATE FUNCTION response(name VARCHAR(40)) RETURNS VARCHAR(200) DETERMINISTIC\nBEGIN\n "
},
{
"path": "Arcade/Databases/dancingCompetition.sql",
"chars": 812,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE dancingCompetition()\nBEGIN\n SELECT it.arbiter_id, it.fi"
},
{
"path": "Arcade/Databases/dateFormatting.sql",
"chars": 174,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE dateFormatting()\nBEGIN\n\tSELECT DATE_FORMAT(date_str, \"%Y-%"
},
{
"path": "Arcade/Databases/driversInfo.sql",
"chars": 1359,
"preview": "CREATE PROCEDURE driversInfo()\nBEGIN\n\t/* Write your SQL here. Terminate each statement with a semicolon. */\n DROP TAB"
},
{
"path": "Arcade/Databases/emptyDepartments.sql",
"chars": 223,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE emptyDepartments()\nBEGIN\n SELECT d.dep_name FROM depart"
},
{
"path": "Arcade/Databases/expressionsVerification.sql",
"chars": 270,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE expressionsVerification()\nBEGIN\n\tSELECT * FROM expressions"
},
{
"path": "Arcade/Databases/filmLibrary.sql",
"chars": 429,
"preview": "CREATE PROCEDURE filmLibrary()\nBEGIN\n\t/* Write your SQL here. Terminate each statement with a semicolon. */\n SET @fav"
},
{
"path": "Arcade/Databases/findTable.sql",
"chars": 333,
"preview": "CREATE PROCEDURE findTable()\nBEGIN\n /* Write your SQL here. Terminate each statement with a semicolon. */\n SELECT "
},
{
"path": "Arcade/Databases/freeSeats.sql",
"chars": 505,
"preview": "CREATE PROCEDURE freeSeats()\nBEGIN\n\t/* Write your SQL here. Terminate each statement with a semicolon. */\n \n S"
},
{
"path": "Arcade/Databases/giftPackaging.sql",
"chars": 403,
"preview": "CREATE PROCEDURE giftPackaging()\nBEGIN\n\t/* Write your SQL here. Terminate each statement with a semicolon. */\n SELECT"
},
{
"path": "Arcade/Databases/gradeDistribution.sql",
"chars": 148,
"preview": "CREATE PROCEDURE gradeDistribution()\nBEGIN\n SELECT Name, ID FROM Grades\n WHERE Final > (Midterm1+Midterm2) / 2\n "
},
{
"path": "Arcade/Databases/habitatArea.sql",
"chars": 211,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE habitatArea()\nBEGIN\n\tSELECT ST_Area(ST_ConvexHull(ST_GeomF"
},
{
"path": "Arcade/Databases/holidayEvent.sql",
"chars": 303,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE holidayEvent()\nBEGIN\n SET @counter := 0;\n SELECT DIS"
},
{
"path": "Arcade/Databases/hostnamesOrdering.sql",
"chars": 429,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE hostnamesOrdering()\nBEGIN\n SELECT id, hostname FROM hos"
},
{
"path": "Arcade/Databases/importantEvents.sql",
"chars": 201,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE importantEvents()\nBEGIN\n\tSELECT id, name, event_date, part"
},
{
"path": "Arcade/Databases/interestClub.sql",
"chars": 209,
"preview": "CREATE PROCEDURE interestClub()\n SELECT name\n FROM people_interests\n WHERE interests & (FIND_IN_SET('reading', "
},
{
"path": "Arcade/Databases/itemCounts.sql",
"chars": 231,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE itemCounts()\nBEGIN\n SELECT item_name, item_type, COUNT("
},
{
"path": "Arcade/Databases/legsCount.sql",
"chars": 157,
"preview": "DROP PROCEDURE IF EXISTS legsCount;\nCREATE PROCEDURE legsCount()\n SELECT SUM(IF(type = \"human\", 2, 4)) as summary_leg"
},
{
"path": "Arcade/Databases/localCalendar.sql",
"chars": 509,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE localCalendar()\nBEGIN\n\tSELECT e.event_id AS event_id, IF(\n"
},
{
"path": "Arcade/Databases/marketReport.sql",
"chars": 361,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE marketReport()\nBEGIN\n WITH cte AS (\n SELECT coun"
},
{
"path": "Arcade/Databases/mischievousNephews.sql",
"chars": 339,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE mischievousNephews()\nBEGIN\n\tSELECT WEEKDAY(mischief_date) "
},
{
"path": "Arcade/Databases/monthlyScholarships.sql",
"chars": 127,
"preview": "CREATE PROCEDURE monthlyScholarships()\nBEGIN\n\tSELECT id, scholarship / 12 AS scholarship\n FROM scholarships ORDER BY "
},
{
"path": "Arcade/Databases/mostExpensive.sql",
"chars": 126,
"preview": "CREATE PROCEDURE mostExpensive()\nBEGIN\n SELECT name FROM Products ORDER BY price * quantity DESC,\n name ASC LIMIT "
},
{
"path": "Arcade/Databases/movieDirectors.sql",
"chars": 215,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE movieDirectors()\nBEGIN\n\tSELECT director FROM moviesInfo\n "
},
{
"path": "Arcade/Databases/netIncome.sql",
"chars": 256,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE netIncome()\nBEGIN\n\tSELECT YEAR(date) AS year, QUARTER(date"
},
{
"path": "Arcade/Databases/newsSubscribers.sql",
"chars": 268,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE newsSubscribers()\nBEGIN\n SELECT subscriber FROM half_ye"
},
{
"path": "Arcade/Databases/nicknames.sql",
"chars": 230,
"preview": "CREATE PROCEDURE nicknames()\nBEGIN\n\tUPDATE reservedNicknames\n SET nickname = CONCAT(\"rename - \", nickname),\n id = "
},
{
"path": "Arcade/Databases/nullIntern.sql",
"chars": 219,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE nullIntern()\nBEGIN\n\tSELECT COUNT(id) AS number_of_nulls FR"
},
{
"path": "Arcade/Databases/officeBranches.sql",
"chars": 265,
"preview": "CREATE PROCEDURE officeBranches()\nBEGIN\n ALTER TABLE branches ADD FOREIGN KEY (branchtype_id)\n REFERENCES branch_t"
},
{
"path": "Arcade/Databases/orderAnalytics.sql",
"chars": 322,
"preview": "DROP PROCEDURE IF EXISTS orderAnalytics;\nCREATE PROCEDURE orderAnalytics()\nBEGIN\n WITH order_analytics AS (\n S"
},
{
"path": "Arcade/Databases/orderOfSuccession.sql",
"chars": 202,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE orderOfSuccession()\nBEGIN\n SELECT CONCAT(IF(gender = \"M"
},
{
"path": "Arcade/Databases/orderPrices.sql",
"chars": 528,
"preview": "DROP FUNCTION IF EXISTS get_total;\nCREATE FUNCTION get_total(items VARCHAR(45)) RETURNS INT DETERMINISTIC\nBEGIN\n SET "
},
{
"path": "Arcade/Databases/orderingEmails.sql",
"chars": 299,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE orderingEmails()\nBEGIN\n\tSELECT id, email_title, CONCAT(FLO"
},
{
"path": "Arcade/Databases/pastEvents.sql",
"chars": 365,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE pastEvents()\nBEGIN\n SELECT name, event_date FROM Events"
},
{
"path": "Arcade/Databases/personalHobbies.sql",
"chars": 190,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE personalHobbies()\nBEGIN\n\tSELECT name FROM people_hobbies\n "
},
{
"path": "Arcade/Databases/placesOfInterest.sql",
"chars": 601,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE placesOfInterest()\nBEGIN\n SELECT country, SUM(\n "
},
{
"path": "Arcade/Databases/placesOfInterestPairs.sql",
"chars": 301,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE placesOfInterestPairs()\nBEGIN\n\tSELECT s1.name AS place1, s"
},
{
"path": "Arcade/Databases/projectList.sql",
"chars": 124,
"preview": "CREATE PROCEDURE projectList()\nBEGIN\n\tSELECT project_name, team_lead, income\n FROM Projects ORDER BY internal_id ASC;"
},
{
"path": "Arcade/Databases/projectsTeam.sql",
"chars": 100,
"preview": "CREATE PROCEDURE projectsTeam()\nBEGIN\n\tSELECT DISTINCT name FROM projectLog ORDER BY (name) ASC;\nEND"
},
{
"path": "Arcade/Databases/queriesExecution.sql",
"chars": 1469,
"preview": "CREATE PROCEDURE queriesExecution()\nBEGIN\n\t/* Write your SQL here. Terminate each statement with a semicolon. */\n DEC"
},
{
"path": "Arcade/Databases/recentHires.sql",
"chars": 1000,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE recentHires()\nBEGIN\n SET @let := 0;\n WITH\n ct"
},
{
"path": "Arcade/Databases/restaurantInfo.sql",
"chars": 234,
"preview": "CREATE PROCEDURE restaurantInfo()\nBEGIN\n ALTER TABLE restaurants ADD COLUMN description VARCHAR(100)\n DEFAULT(\"TBD"
},
{
"path": "Arcade/Databases/routeLength.sql",
"chars": 268,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE routeLength()\nBEGIN\n\tSELECT ROUND(\n SUM(\n "
},
{
"path": "Arcade/Databases/salaryDifference.sql",
"chars": 439,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE salaryDifference()\nBEGIN\n SELECT COALESCE(((SELECT MAX("
},
{
"path": "Arcade/Databases/scholarshipsDistribution.sql",
"chars": 230,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE scholarshipsDistribution()\nBEGIN\n\tSELECT candidate_id AS s"
},
{
"path": "Arcade/Databases/securityBreach.sql",
"chars": 273,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE securityBreach()\nBEGIN\n\tSELECT first_name, second_name, at"
},
{
"path": "Arcade/Databases/soccerGamesSeries.sql",
"chars": 755,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE soccerGameSeries()\nBEGIN\n SELECT IF(\n wins > 0, "
},
{
"path": "Arcade/Databases/soccerPlayers.sql",
"chars": 260,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE soccerPlayers()\nBEGIN\n\tSELECT GROUP_CONCAT(\n first_"
},
{
"path": "Arcade/Databases/sortBook.sql",
"chars": 1056,
"preview": "CREATE PROCEDURE sortBookChapters()\nBEGIN\n\t/* Write your SQL here. Terminate each statement with a semicolon. */\n SEL"
},
{
"path": "Arcade/Databases/storageOptimization.sql",
"chars": 473,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE storageOptimization()\nBEGIN\n SELECT id, 'name' AS colum"
},
{
"path": "Arcade/Databases/stringsStatistics.sql",
"chars": 2618,
"preview": "CREATE PROCEDURE stringsStatistics()\nBEGIN\n\t/* Write your SQL here. Terminate each statement with a semicolon. */\n DR"
},
{
"path": "Arcade/Databases/studentsInClubs.sql",
"chars": 175,
"preview": "CREATE PROCEDURE studentsInClubs()\n SELECT * FROM students\n WHERE EXISTS (\n SELECT * FROM clubs AS c WHERE "
},
{
"path": "Arcade/Databases/sunnyHolidays.sql",
"chars": 225,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE sunnyHolidays()\nBEGIN\n\tSELECT h.holiday_date AS ski_date F"
},
{
"path": "Arcade/Databases/suspectsInvestigation.sql",
"chars": 214,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE suspectsInvestigation()\nBEGIN\n\tSELECT id, name, surname FR"
},
{
"path": "Arcade/Databases/suspectsInvestigation2.sql",
"chars": 221,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE suspectsInvestigation2()\nBEGIN\n\tSELECT id, name, surname F"
},
{
"path": "Arcade/Databases/tableSecurity.sql",
"chars": 276,
"preview": "CREATE PROCEDURE tableSecurity()\nBEGIN\n CREATE OR REPLACE VIEW emp\n AS SELECT id,\n name,\n "
},
{
"path": "Arcade/Databases/testCheck.sql",
"chars": 199,
"preview": "CREATE PROCEDURE testCheck()\n SELECT id, IF (\n correct_answer = given_answer,\n \"correct\", IF(given_answer IS NU"
},
{
"path": "Arcade/Databases/tictactoeTournament.sql",
"chars": 1805,
"preview": "CREATE PROCEDURE tictactoeTournament()\nBEGIN\n /* Write your SQL here. Terminate each statement with a semicolon. */\n "
},
{
"path": "Arcade/Databases/top5AverageGrade.sql",
"chars": 234,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE top5AverageGrade()\nBEGIN\n\tSELECT ROUND(AVG(s1.grade), 2) A"
},
{
"path": "Arcade/Databases/trackingSystem.sql",
"chars": 917,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE trackingSystem()\nBEGIN\n WITH\n cte_id AS (\n "
},
{
"path": "Arcade/Databases/travelDiary.sql",
"chars": 213,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE travelDiary()\nBEGIN\n SELECT GROUP_CONCAT(\n DISTI"
},
{
"path": "Arcade/Databases/typeInheritance.sql",
"chars": 774,
"preview": "CREATE FUNCTION isNumber(class VARCHAR(45))\nRETURNS BOOLEAN\nBEGIN\n DECLARE basec VARCHAR(45) DEFAULT '';\n DECLARE "
},
{
"path": "Arcade/Databases/unluckyEmployees.sql",
"chars": 695,
"preview": "CREATE PROCEDURE unluckyEmployees()\nBEGIN\n\t/* Write your SQL here. Terminate each statement with a semicolon. */\n SET"
},
{
"path": "Arcade/Databases/userCountries.sql",
"chars": 229,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE userCountries()\nBEGIN\n\tSELECT u.id, IFNULL(c.country, \"unk"
},
{
"path": "Arcade/Databases/usersByContinent.sql",
"chars": 188,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE usersByContinent()\nBEGIN\n\tSELECT continent, SUM(users) AS "
},
{
"path": "Arcade/Databases/validPhoneNumbers.sql",
"chars": 241,
"preview": "/*Please add ; after each select statement*/\nCREATE PROCEDURE validPhoneNumbers()\nBEGIN\n\tSELECT name, surname, phone_num"
},
{
"path": "Arcade/Databases/volleyballResults.sql",
"chars": 87,
"preview": "CREATE PROCEDURE volleyballResults()\nBEGIN\n SELECT * FROM results ORDER BY wins;\nEND"
},
{
"path": "Arcade/Databases/websiteHacking.sql",
"chars": 132,
"preview": "CREATE PROCEDURE websiteHacking()\n SELECT id,login,name\n FROM users\n WHERE type='user'\n OR type LIKE \"%\"\n "
},
{
"path": "Arcade/Intro/Java/AbsoluteValuesSumMinimization.java",
"chars": 423,
"preview": "import java.util.Arrays;\nimport java.util.stream.IntStream;\n\nfinal class AbsoluteValuesSumMinimization {\n\n\tint absoluteV"
},
{
"path": "Arcade/Intro/Java/Add.java",
"chars": 89,
"preview": "public class Add {\n\n\tint add(int param1, int param2) {\n \treturn param1 + param2;\n\n\t}\n}"
},
{
"path": "Arcade/Intro/Java/AddBorder.java",
"chars": 322,
"preview": "final class AddBorder {\n\n\tString[] addBorder(String[] picture) {\n\t int len = picture.length + 2;\n\t String[] o = ne"
},
{
"path": "Arcade/Intro/Java/AdjacentElementsProduct.java",
"chars": 268,
"preview": "import java.util.stream.IntStream;\n\nfinal class AdjacentElementsProduct {\n\t\n\tint adjacentElementsProduct(int[] inputArra"
},
{
"path": "Arcade/Intro/Java/AllLongestStrings.java",
"chars": 320,
"preview": "import java.util.Arrays;\n\npublic class AllLongestStrings {\n\n\tString[] allLongestStrings(String[] inputArray) {\n\t int "
},
{
"path": "Arcade/Intro/Java/AlmostIncreasingSequence.java",
"chars": 380,
"preview": "final class AlmostIncreasingSequence {\n\n\tboolean almostIncreasingSequence(int[] sequence) {\n\t int last = -0x186a0, la"
},
{
"path": "Arcade/Intro/Java/AlphabeticShift.java",
"chars": 282,
"preview": "import java.util.stream.Collectors;\n\nfinal class AlphabeticShift {\n\n\tString alphabeticShift(String inputString) {\n\t r"
},
{
"path": "Arcade/Intro/Java/AlternatingSums.java",
"chars": 204,
"preview": "final class AlternatingSums {\n\n\tint[] alternatingSums(int[] a) {\n\t\tint[] o = new int[2];\n\t for(int i = 0; i < a.lengt"
},
{
"path": "Arcade/Intro/Java/AreEquallyStrong.java",
"chars": 272,
"preview": "public final class AreEquallyStrong {\n\n\tboolean areEquallyStrong(int yourLeft, int yourRight, int friendsLeft, int frien"
},
{
"path": "Arcade/Intro/Java/AreSimilar.java",
"chars": 638,
"preview": "import java.util.Arrays;\n\nfinal class AreSimilar {\n\n\tvoid swap(int[] a, int p, int q) {\n\t int tmp = a[p];\n\t a[p] ="
},
{
"path": "Arcade/Intro/Java/ArrayChange.java",
"chars": 271,
"preview": "final class ArrayChange {\n\n\tint arrayChange(int[] inputArray) {\n\t\tint c = 0;\n\t for(int i = 0; i < inputArray.length -"
},
{
"path": "Arcade/Intro/Java/ArrayMaxConsecutiveSum.java",
"chars": 329,
"preview": "final class ArrayMaxConsecutiveSum {\n\n\tint arrayMaxConsecutiveSum(int[] inputArray, int k) {\n int max = 0, t = 0;\n"
},
{
"path": "Arcade/Intro/Java/ArrayMaximalAdjacentDifference.java",
"chars": 279,
"preview": "import java.util.stream.IntStream;\n\nfinal class ArrayMaximalAdjacentDifference {\n\t\n\tint arrayMaximalAdjacentDifference(i"
},
{
"path": "Arcade/Intro/Java/ArrayReplace.java",
"chars": 246,
"preview": "import java.util.Arrays;\n\nfinal class ArrayReplace {\n\n\tint[] arrayReplace(int[] inputArray, int elemToReplace, int subst"
},
{
"path": "Arcade/Intro/Java/AvoidObstacles.java",
"chars": 317,
"preview": "final class AvoidObstacles {\n\n\tint avoidObstacles(int[] inputArray) {\n\t boolean k = true;\n\t for(int i = 2; ; i++) "
},
{
"path": "Arcade/Intro/Java/BishopAndPawn.java",
"chars": 195,
"preview": "final class BishopAndPawn {\n\n\tboolean bishopAndPawn(String bishop, String pawn) {\n\t return Math.abs(bishop.charAt(0) "
},
{
"path": "Arcade/Intro/Java/BoxBlur.java",
"chars": 487,
"preview": "import java.util.Arrays;\n\nfinal class BoxBlur {\n\n\tint[][] boxBlur(int[][] image) {\n\t int h = image.length - 2;\n\t i"
},
{
"path": "Arcade/Intro/Java/BuildPalindrome.java",
"chars": 413,
"preview": "final class BuildPalindrome {\n\n\tString reverseString(String str) {\n\t return new StringBuilder(str).reverse().toString"
},
{
"path": "Arcade/Intro/Java/CenturyFromYear.java",
"chars": 103,
"preview": "public class CenturyFromYear {\n\n\tint centuryFromYear(int year) {\n\t return 1 + (year - 1) / 100;\n\t}\n}"
},
{
"path": "Arcade/Intro/Java/CheckPalindrome.java",
"chars": 153,
"preview": "public class CheckPalindrome {\n\t\n\tboolean checkPalindrome(String inputString) {\n\t return new StringBuilder(str).rever"
},
{
"path": "Arcade/Intro/Java/ChessBoardCellColor.java",
"chars": 316,
"preview": "final class ChessBoardCellColor {\n\n\tboolean chessBoardCellColor(String cell1, String cell2) {\n\t int x1 = cell1.charAt"
},
{
"path": "Arcade/Intro/Java/ChessKnight.java",
"chars": 574,
"preview": "final class ChessKnight {\n\n\tboolean isSafe(int x, int y) {\n\t return x >= 0 && x < 8 && y >= 0 && y < 8;\n\t}\n\n\tint ches"
},
{
"path": "Arcade/Intro/Java/CircleOfNumbers.java",
"chars": 121,
"preview": "final class CircleOfNumbers {\n\n\tint circleOfNumbers(int n, int firstNumber) {\n\t return (n / 2 + firstNumber) % n;\n\t}\n"
},
{
"path": "Arcade/Intro/Java/CommonCharacterCount.java",
"chars": 618,
"preview": "import java.util.stream.IntStream;\nimport java.util.stream.Collectors;\n\nfinal class CommonCharacterCount {\n\t\n\tint common"
},
{
"path": "Arcade/Intro/Java/DeleteDigit.java",
"chars": 335,
"preview": "final class DeleteDigit {\n\n\tint deleteDigit(int n) {\n\t int max = 0, len = (n+\"\").length();\n\t \n\t for(int i = 0; "
},
{
"path": "Arcade/Intro/Java/DepositProfit.java",
"chars": 192,
"preview": "final class DepositProfit {\n\n\tint depositProfit(int deposit, int rate, int threshold) {\n\t float d = deposit;\n\t for"
},
{
"path": "Arcade/Intro/Java/DifferentSquares.java",
"chars": 496,
"preview": "import java.util.Set;\nimport java.util.HashSet;\n\nfinal class DifferentSquares {\n\n\tint differentSquares(int[][] matrix) {"
},
{
"path": "Arcade/Intro/Java/DifferentSymbolsNaive.java",
"chars": 132,
"preview": "final class DifferentSymbolsNaive {\n\n\tint differentSymbolsNaive(String s) {\n\t return s.chars().distinct().toArray().l"
},
{
"path": "Arcade/Intro/Java/DigitDegree.java",
"chars": 228,
"preview": "final class DigitDegree {\n\n\tint digitDegree(int n) {\n\t int counter = 0;\n\t \n\t for(; (n+\"\").length() > 1; counter"
},
{
"path": "Arcade/Intro/Java/DigitsProduct.java",
"chars": 291,
"preview": "final class DigitsProduct {\n\n\tint digitsProduct(int product) {\n\t if(product == 0) return 10;\n\t if(product < 10) re"
},
{
"path": "Arcade/Intro/Java/ElectionsWinners.java",
"chars": 345,
"preview": "import java.util.Arrays;\n\nfinal class ElectionsWinners {\n\n\tint electionsWinners(int[] votes, int k) {\n\t int winners ="
},
{
"path": "Arcade/Intro/Java/EvenDigitsOnly.java",
"chars": 138,
"preview": "final class EvenDigitsOnly {\n\t\n\tboolean evenDigitsOnly(int n) {\n\t return (n+\"\").chars().allMatch(e -> new Integer(e+\""
},
{
"path": "Arcade/Intro/Java/ExtractEachKth.java",
"chars": 247,
"preview": "import java.util.stream.IntStream;\n\npublic final class ExtractEachKth {\n\n\tint[] extractEachKth(int[] inputArray, int k) "
},
{
"path": "Arcade/Intro/Java/FileNaming.java",
"chars": 383,
"preview": "import java.util.Vector;\n\nfinal class FileNaming {\n\n\tString[] fileNaming(String[] names) {\n\t Vector<String> vector = "
},
{
"path": "Arcade/Intro/Java/FindEmailDomain.java",
"chars": 153,
"preview": "final class FindEmailDomain {\n\n\tString findEmailDomain(String address) {\n\t\tString[] pieces = address.split(\"@\");\n\t\tretur"
},
{
"path": "Arcade/Intro/Java/FirstDigit.java",
"chars": 169,
"preview": "final class FirstDigit {\n\n\tchar firstDigit(String inputString) {\n\t return (char) inputString.chars()\n\t .filter(e -"
},
{
"path": "Arcade/Intro/Java/GrowingPlant.java",
"chars": 271,
"preview": "public final class GrowingPlant {\n\n\tint growingPlant(int upSpeed, int downSpeed, int desiredHeight) {\n\t\tint count = 0, h"
},
{
"path": "Arcade/Intro/Java/IsBeautifulString.java",
"chars": 269,
"preview": "final class IsBeautifulString {\n\n\tboolean isBeautifulString(String inputString) {\n\t byte[] abc = new byte[26];\n\t f"
},
{
"path": "Arcade/Intro/Java/IsDigit.java",
"chars": 99,
"preview": "final class IsDigit {\n\n\tboolean isDigit(char symbol) {\n\t return (symbol+\"\").matches(\"\\\\d\");\n\t}\n}"
},
{
"path": "Arcade/Intro/Java/IsIPv4Address.java",
"chars": 411,
"preview": "final class IsIPv4Address {\n\n\tboolean isIPv4Address(String inputString) {\n\t String[] split = inputString.split(\"\\\\.\")"
},
{
"path": "Arcade/Intro/Java/IsLucky.java",
"chars": 342,
"preview": "final class IsLucky {\n\t\n\tboolean isLucky(int n) {\n\t String ticket = n+\"\"; \n\t return ticket\n\t .substring("
},
{
"path": "Arcade/Intro/Java/IsMAC48Adress.java",
"chars": 144,
"preview": "final class IsMAC48Adress {\n\n\tboolean isMAC48Address(String inputString) {\n\t return inputString.matches(\"[0-9A-F]{2}("
},
{
"path": "Arcade/Intro/Java/KnapsackLight.java",
"chars": 405,
"preview": "final class KnapsackLight {\n\n\tint knapsackLight(int value1, int weight1, int value2, int weight2, int maxW) {\n\t if(ma"
},
{
"path": "Arcade/Intro/Java/LineEnconding.java",
"chars": 608,
"preview": "import java.util.List;\nimport java.util.ArrayList;\n\nfinal class LineEnconding {\n\n\tString lineEncoding(String s) {\n\t L"
},
{
"path": "Arcade/Intro/Java/LongestDigitsPrefix.java",
"chars": 264,
"preview": "final class LongestDigitsPrefix {\n\n\tString longestDigitsPrefix(String inputString) {\n\t String output = \"\";\n\t \n\t fo"
},
{
"path": "Arcade/Intro/Java/LongestWord.java",
"chars": 232,
"preview": "import java.util.Arrays;\n\nfinal class LongestWord {\n\n\tString longestWord(String text) {\n\t return Arrays.stream(text.r"
},
{
"path": "Arcade/Intro/Java/MakeArrayConsecutive2.java",
"chars": 293,
"preview": "import java.util.Arrays;\nimport java.util.stream.IntStream;\n\nfinal class MakeArrayConsecutive2 {\n\n\tint makeArrayConsecut"
},
{
"path": "Arcade/Intro/Java/MatrixElementsSum.java",
"chars": 266,
"preview": "public class MatrixElementsSum {\n\t\n\tint matrixElementsSum(int[][] matrix) {\n\t\tint sum = 0;\n\t\tfor(int i = 0; i < matrix[0"
},
{
"path": "Arcade/Intro/Java/MessageFromBinaryCode.java",
"chars": 281,
"preview": "import java.util.stream.Collectors;\nimport java.util.Arrays;\n\nfinal class MessageFromBinaryCode {\n\n\tString messageFromBi"
},
{
"path": "Arcade/Intro/Java/Minesweeper.java",
"chars": 802,
"preview": "final class Minesweeper {\n\n\tint[][] minesweeper(boolean[][] matrix) {\n\t int w = matrix[0].length, h = matrix.length;\n"
},
{
"path": "Arcade/Intro/Java/PalindromeRearranging.java",
"chars": 359,
"preview": "import java.util.Arrays;\n\nfinal class PalindromeRearranging {\n\n\tboolean palindromeRearranging(String inputString) {\n\t\tin"
},
{
"path": "Arcade/Intro/Java/RemoveKFromList.java",
"chars": 544,
"preview": "final class RemoveKFromList {\n\t\n\t// Singly-linked lists are already defined with this interface:\n\t// class ListNode<T> {"
},
{
"path": "Arcade/Intro/Java/ReverseInParentheses.java",
"chars": 494,
"preview": "import java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\nfinal class ReverseInParentheses {\n\n String reverseI"
},
{
"path": "Arcade/Intro/Java/ShapeArea.java",
"chars": 154,
"preview": "public class ShapeArea {\n\n\tint shapeArea(int n) {\n\t return IntStream.range(0, n).map(p -> (p - n) * -1)\n\t .map"
},
{
"path": "Arcade/Intro/Java/SortByHeight.java",
"chars": 462,
"preview": "import java.util.ArrayList;\nimport java.util.Arrays;\n\npublic class SortByHeight {\n\t\n\tint[] sortByHeight(int[] a) {\n\t\tfor"
},
{
"path": "Arcade/Intro/Java/SpiralNumbers.java",
"chars": 622,
"preview": "final class SpiralNumbers {\n\n\tint[][] spiralNumbers(int n) {\n\t int[][] spiral = new int[n][n];\n\t int left = 0, rig"
},
{
"path": "Arcade/Intro/Java/StringsRearrangement.java",
"chars": 977,
"preview": "import java.util.Arrays;\nimport java.util.ArrayList;\n\nfinal class StringsRearrangement {\n\n\tboolean flag;\n\n\tboolean check"
},
{
"path": "Arcade/Intro/Java/Sudoku.java",
"chars": 778,
"preview": "import java.util.Arrays;\n\nfinal class Sudoku {\n\n\tboolean sudoku(int[][] grid) {\n\t int n = grid.length, sqrt = (int) M"
},
{
"path": "Arcade/Intro/Java/SumUpNumbers.java",
"chars": 219,
"preview": "final class SumUpNumbers {\n\n\tint sumUpNumbers(String inputString) { \n\t return Arrays.stream(inputString.replaceAll"
},
{
"path": "Arcade/Intro/Java/ValidTime.java",
"chars": 166,
"preview": "final class ValidTime {\n\n\tboolean validTime(String time) {\n\t String[] dig = time.split(\":\");\n\t return new Integer("
},
{
"path": "Arcade/Intro/Java/VariableName.java",
"chars": 113,
"preview": "final class VariableName {\n\n\tboolean variableName(String name) {\n\t return name.matches(\"^[a-zA-Z_]\\\\w*\");\n\t}\n}"
},
{
"path": "Arcade/Intro/Python/stringsRearrangement.py",
"chars": 455,
"preview": "import itertools\n\ndef isDifferByOneChar(str1, str2):\n\tcount = 0\n\tfor i in range(len(str1)):\n\t\tif str1[i] != str2[i]:\n\t\t\t"
},
{
"path": "Arcade/Intro/Ruby/absoluteValuesSumMinimization.rb",
"chars": 68,
"preview": "def absoluteValuesSumMinimization(a)\n\treturn a[(a.size - 1) / 2]\nend"
},
{
"path": "Arcade/Intro/Ruby/add.rb",
"chars": 54,
"preview": "def add(param1, param2)\n return param1 + param2\nend"
},
{
"path": "Arcade/Intro/Ruby/addBorder.rb",
"chars": 129,
"preview": "def addBorder(picture)\n\tborder = \"*\" * (picture[0].size + 2)\n\treturn picture.map{|e| \"*\"+e+\"*\"}.insert(0, border).push b"
},
{
"path": "Arcade/Intro/Ruby/adjacentElementsProduct.rb",
"chars": 194,
"preview": "def adjacentElementsProduct(inputArray)\n\tmax = inputArray[0] * inputArray[1]\n\t(inputArray.size - 1).times do |i|\n\t\tq = i"
},
{
"path": "Arcade/Intro/Ruby/allLongestStrings.rb",
"chars": 82,
"preview": "def allLongestStrings(a)\n\treturn a.filter{|e| e.size == a.map{|e| e.size}.max}\nend"
},
{
"path": "Arcade/Intro/Ruby/almostIncreasingSequence.rb",
"chars": 259,
"preview": "def almostIncreasingSequence(sequence)\n\tl, lp, c = -100000, l, c = 0\n \n sequence.each do |e|\n if e <= l\n "
},
{
"path": "Arcade/Intro/Ruby/alphabeticShift.rb",
"chars": 121,
"preview": "def alphabeticShift(inputString)\n return inputString.chars\n .map{|c| c == 'z' ? 'a' : (c.ord + 1).chr}.join\nen"
},
{
"path": "Arcade/Intro/Ruby/alternatingSums.rb",
"chars": 138,
"preview": "def alternatingSums(a)\n\tdef alternatingSums(a)\n\t o = [0, 0]\n\t\ta.size.times{|i| o[(i + 1) % 2 == 0 ? 1 : 0] += a[i]}\n\t"
},
{
"path": "Arcade/Intro/Ruby/areEquallyStrong.rb",
"chars": 198,
"preview": "def areEquallyStrong(yourLeft, yourRight, friendsLeft, friendsRight)\n\tyl, yr, fl, fr = yourLeft, yourRight, friendsLeft,"
},
{
"path": "Arcade/Intro/Ruby/areSimilar.rb",
"chars": 117,
"preview": "def areSimilar(a, b)\n c = 0\n a.size.times {|i| c += 1 if a[i] != b[i]}\n return a.sort == b.sort && c < 3\nend"
},
{
"path": "Arcade/Intro/Ruby/arrayChange.rb",
"chars": 176,
"preview": "def arrayChange(inputArray)\n\tc = 0\n\t(inputArray.size - 1).times do |i|\n\t\twhile inputArray[i + 1] <= inputArray[i] do\n\t\t\t"
},
{
"path": "Arcade/Intro/Ruby/arrayMaxConsecutiveSum.rb",
"chars": 152,
"preview": "def arrayMaximalAdjacentDifference(inputArray)\n return (0..(inputArray.size - 2)).to_a\n \t.map{|i| (inputArray[i + "
},
{
"path": "Arcade/Intro/Ruby/arrayMaximalAdjacentDifference.rb",
"chars": 223,
"preview": "def arrayMaxConsecutiveSum(inputArray, k)\n max = t = 0\n \n (0..(inputArray.size - k)).each do |i|\n t = (i"
},
{
"path": "Arcade/Intro/Ruby/arrayReplace.rb",
"chars": 142,
"preview": "def arrayReplace(inputArray, elemToReplace, substitutionElem) \n return inputArray.map{|e| e == elemToReplace ? sub"
},
{
"path": "Arcade/Intro/Ruby/avoidObstacles.rb",
"chars": 249,
"preview": "def avoidObstacles(inputArray)\n\tk, i = true, 2\n loop do\n inputArray.each do |e|\n if e % i == 0\n "
},
{
"path": "Arcade/Intro/Ruby/bishopAndPawn.rb",
"chars": 115,
"preview": "def bishopAndPawn(bishop, pawn)\n\treturn (bishop[0].ord - pawn[0].ord).abs a== (bishop[1].ord - pawn[1].ord).abs\nend"
},
{
"path": "Arcade/Intro/Ruby/boxBlur.rb",
"chars": 425,
"preview": "def boxBlur(image)\n h, w = image.size - 2, image[0].size - 2\n sum = Array.new(h) {Array.new(w,[])}\n (1..h).each"
},
{
"path": "Arcade/Intro/Ruby/buildPalindrome.rb",
"chars": 162,
"preview": "def buildPalindrome(st)\n\treturn st if st.reverse.eql? st\n\tout = sg = \"\"\n\tst.each_char{|ch|\n\treturn out if (out = st+(sg "
},
{
"path": "Arcade/Intro/Ruby/centuryFromYear.rb",
"chars": 99,
"preview": "def centuryFromYear(year)\n\treturn year / 100 + 1 if(year / 100 * 100 < year)\n\treturn year / 100\nend"
},
{
"path": "Arcade/Intro/Ruby/checkPalindrome.rb",
"chars": 83,
"preview": "def checkPalindrome(inputString)\n return inputString.reverse == inputString;\nend"
},
{
"path": "Arcade/Intro/Ruby/chessBoardCellColor.rb",
"chars": 165,
"preview": "def chessBoardCellColor(cell1, cell2)\n x1, x2 = cell1[0].ord, cell1[1].ord\n y1, y2 = cell2[0].ord, cell2[1].ord\n "
},
{
"path": "Arcade/Intro/Ruby/chessKnight.rb",
"chars": 483,
"preview": "def isSafe(x, y)\n return (x >= 0 and x < 8 and y >= 0 and y < 8);\nend\n\ndef chessKnight(cell)\n x, y, out = cell[0]."
},
{
"path": "Arcade/Intro/Ruby/circleOfNumbers.rb",
"chars": 76,
"preview": "def circleOfNumbers(n, firstNumber)\n return (firstNumber + n / 2) % n\nend"
},
{
"path": "Arcade/Intro/Ruby/commonCharacterCount.rb",
"chars": 284,
"preview": "def commonCharacterCount(s1, s2)\n\tq = (0x61..0x7b).to_a.filter{|e| s1.include?(e.chr) && s2.include?(e.chr)}\n\t\t.map{|e| "
},
{
"path": "Arcade/Intro/Ruby/deleteDigit.rb",
"chars": 192,
"preview": "def deleteDigit(n)\n max, s = 0, n.to_s\n s.size.times do |i|\n v = (0..s.size).to_a.filter{|j| j != i}.map{|j"
},
{
"path": "Arcade/Intro/Ruby/depositProfit.rb",
"chars": 161,
"preview": "def depositProfit(deposit, rate, threshold)\n y = 1\n loop do\n return y if (deposit += rate / 100.0 * deposit"
},
{
"path": "Arcade/Intro/Ruby/differentSquares.rb",
"chars": 327,
"preview": "def differentSquares(matrix)\n set = []\n (matrix.size - 1).times do |x|\n (matrix[0].size - 1).times do |y|\n "
},
{
"path": "Arcade/Intro/Ruby/differentSymbolsNaive.rb",
"chars": 54,
"preview": "def differentSymbolsNaive(s)\n s.chars.uniq.size\nend"
},
{
"path": "Arcade/Intro/Ruby/digitDegree.rb",
"chars": 167,
"preview": "def digitDegree(n)\n counter = 0\n \n while n.to_s.size > 1\n n = n.to_s.chars.map{|e| e.to_i}.sum\n c"
},
{
"path": "Arcade/Intro/Ruby/digitsProduct.rb",
"chars": 276,
"preview": "def digitsProduct(product)\n return 10 if product == 0\n return product if product < 10\n\n s = \"\";\n 9.downto(2)"
},
{
"path": "Arcade/Intro/Ruby/electionsWinners.rb",
"chars": 312,
"preview": "def electionsWinners(votes, k)\n winners = 0\n votes.size.times do |i|\n win = true\n votes.size.times d"
},
{
"path": "Arcade/Intro/Ruby/evenDigitsOnly.rb",
"chars": 75,
"preview": "def evenDigitsOnly(n)\n return n.to_s.chars.all?{|e| e.to_i % 2 == 0}\nend"
},
{
"path": "Arcade/Intro/Ruby/extractEachKth.rb",
"chars": 132,
"preview": "def extractEachKth(inputArray, k)\n return (0...inputArray.size).to_a\n .filter{|i| (i + 1) % k != 0}.map{|i| inputA"
},
{
"path": "Arcade/Intro/Ruby/fileNaming.rb",
"chars": 247,
"preview": "def fileNaming(names)\n set = []\n names.size.times do |i|\n aux, k = names[i], 1\n while set.include? a"
},
{
"path": "Arcade/Intro/Ruby/findEmailDomain.rb",
"chars": 98,
"preview": "def findEmailDomain(address)\n pieces = address.split /@/\n return pieces[pieces.size - 1]\nend"
},
{
"path": "Arcade/Intro/Ruby/firstDigit.rb",
"chars": 89,
"preview": "def firstDigit(inputString)\n return inputString.chars.filter{|e| /\\d/.match? e}[0]\nend"
},
{
"path": "Arcade/Intro/Ruby/growingPlant.rb",
"chars": 197,
"preview": "def growingPlant(upSpeed, downSpeed, desiredHeight)\n c = h = 0\n loop do\n h += upSpeed\n c += 1\n "
},
{
"path": "Arcade/Intro/Ruby/isBeautifulString.rb",
"chars": 171,
"preview": "def isBeautifulString(inputString)\n\tabc = Array.new(26, 0)\n\tinputString.each_byte{|b| abc[b - 97] += 1}\n\t25.times{|i| re"
},
{
"path": "Arcade/Intro/Ruby/isDigit.rb",
"chars": 53,
"preview": "def isDigit(symbol)\n return symbol.match? /\\d/\nend"
},
{
"path": "Arcade/Intro/Ruby/isIPv4Address.rb",
"chars": 284,
"preview": "def isIPv4Address(inputString)\n split = inputString.split /\\./\n return false if split.size != 4\n split.each do "
},
{
"path": "Arcade/Intro/Ruby/isLuck.rb",
"chars": 157,
"preview": "def isLucky(n)\n str = n.to_s\n return str[0...str.size / 2].chars.map{|e| e.to_i}.sum ==\n str[(str.size / 2)..st"
},
{
"path": "Arcade/Intro/Ruby/isMAC48Address.rb",
"chars": 119,
"preview": "def isMAC48Address(inputString)\n return /[0-9A-F]{2}(-[0-9A-F]{2}){5}/.match(inputString).to_s.eql?(inputString)\nend"
},
{
"path": "Arcade/Intro/Ruby/isPowerOfTwo2.rb",
"chars": 61,
"preview": "def isPowerOfTwo2 n\n return n > 0 && (n & n - 1) == 0;\nend"
},
{
"path": "Arcade/Intro/Ruby/knapsackLight.rb",
"chars": 318,
"preview": "def knapsackLight(value1, weight1, value2, weight2, maxW)\n return value1 + value2 if maxW >= weight1 + weight2\n re"
},
{
"path": "Arcade/Intro/Ruby/lineEncoding.rb",
"chars": 321,
"preview": "def lineEncoding(s)\n subs, aux, prev = [], \"\", s[0]\n \n s.size.times do |i|\n if s[i] != prev\n "
},
{
"path": "Arcade/Intro/Ruby/longestDigitsPrefix.rb",
"chars": 196,
"preview": "def longestDigitsPrefix(inputString)\n out = \"\"\n \n inputString.chars.to_a.each do |c|\n if /\\d/.match? c t"
},
{
"path": "Arcade/Intro/Ruby/longestWord.rb",
"chars": 115,
"preview": "def longestWord(text)\n return text.gsub(/[^a-zA-Z ]/, \" \")\n .split(/ /).sort{|a, b| b.size <=> a.size}[0]\nend"
},
{
"path": "Arcade/Intro/Ruby/makeArrayConsecutive2.rb",
"chars": 101,
"preview": "def makeArrayConsecutive2(statues)\n return (statues.min..statues.max).to_a.size - statues.size\nend"
},
{
"path": "Arcade/Intro/Ruby/matrixElementsSum.rb",
"chars": 174,
"preview": "def matrixElementsSum(matrix)\n\tsum = 0\n\tmatrix[0].size.times do |i|\n\t\tmatrix.size.times do |j|\n\t\t\tbreak if matrix[j][i] "
},
{
"path": "Arcade/Intro/Ruby/messageFromBinaryCode.rb",
"chars": 100,
"preview": "def messageFromBinaryCode(code)\n return code.split(/(?<=\\G.{8})/).map{|v| v.to_i(2).chr}.join\nend"
},
{
"path": "Arcade/Intro/Ruby/palindromeRearranging.rb",
"chars": 215,
"preview": "def palindromeRearranging(inputString)\n abc = Array.new(26, 0)\n inputString.size.times{|i| abc[inputString[i].ord "
},
{
"path": "Arcade/Intro/Ruby/reverseInParentheses.rb",
"chars": 221,
"preview": "def reverseInParentheses(inputString)\n reg = /\\(\\w*\\)/\n\treturn inputString unless reg.match? inputString\n\ts = reg.mat"
},
{
"path": "Arcade/Intro/Ruby/shapeArea.rb",
"chars": 90,
"preview": "def shapeArea(n)\n area = 1\n n.downto(1){|e| area += (e - 1) * 4}\n return area\nend"
}
]
// ... and 350 more files (download for full content)
About this extraction
This page contains the full source code of the neemiassgc/CodeSignal-Solutions GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 550 files (187.2 KB), approximately 70.5k tokens, and a symbol index with 664 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.