4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim


class Solution:
    def maxScore(self, cardPoints: List[int], k: int) -> int:


class Solution:
    def profitableSchemes(self, G: int, P: int, group: List[int], profit: List[int]) -> int:


class Solution:
    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:


class Solution:
    def numRescueBoats(self, people: List[int], limit: int) -> int:


class Solution:
    def decodeString(self, s: str) -> str:


class Solution:
    def strongPasswordChecker(self, s: str) -> int:


class Solution:
    def isMatch(self, s: str, p: str) -> bool:


class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:


class Solution:
    def canConstruct(self, s: str, k: int) -> bool:


class Solution:
    def canArrange(self, arr: List[int], k: int) -> bool:


class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:


class Solution:
    def hasAllCodes(self, s: str, k: int) -> bool:


class Solution:
    def atMostNGivenDigitSet(self, digits: List[str], n: int) -> int:


class Solution:
    def maxSubarraySumCircular(self, A: List[int]) -> int:


class Solution:
    def numTrees(self, n: int) -> int:


class Solution:
    def largestNumber(self, nums: List[int]) -> str:


class Solution:
    def numFactoredBinaryTrees(self, A: List[int]) -> int:


class Solution:
    def orderlyQueue(self, S: str, K: int) -> str:


class Solution:
    def hIndex(self, citations: List[int]) -> int:


class Solution:
    def maxVowels(self, s: str, k: int) -> int:


class Solution:
    def numberOfArithmeticSlices(self, A: List[int]) -> int:


class Solution:
    def isRobotBounded(self, instructions: str) -> bool:


class Solution:
    def minSumOfLengths(self, arr: List[int], target: int) -> int:


class Solution:
    def countNumbersWithUniqueDigits(self, n: int) -> int:


class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:


class Solution:
    def numSplits(self, s: str) -> int:


class Solution:
    def maxCandies(self, status: List[int], candies: List[int], keys: List[List[int]], containedBoxes: List[List[int]], initialBoxes: List[int]) -> int:


class Solution:
    def numTimesAllBlue(self, light: List[int]) -> int:


class Solution:
    def smallestDistancePair(self, nums: List[int], k: int) -> int:


class Solution:
    def flipLights(self, n: int, m: int) -> int:


class Solution:
    def totalNQueens(self, n: int) -> int:


class Solution:
    def maxUncrossedLines(self, A: List[int], B: List[int]) -> int:


class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:


class Solution:
    def shortestSubarray(self, A: List[int], K: int) -> int:


class Solution:
    def maxSizeSlices(self, slices: List[int]) -> int:


class Solution:
    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:


class Solution:
    def isNumber(self, s: str) -> bool:


class Solution:
    def tallestBillboard(self, rods: List[int]) -> int:


class Solution:
    def nthUglyNumber(self, n: int) -> int:


class Solution:
    def maximumSum(self, arr: List[int]) -> int:


class Solution:
    def numSubseq(self, nums: List[int], target: int) -> int:


class Solution:
    def findReplaceString(self, S: str, indexes: List[int], sources: List[str], targets: List[str]) -> str:


class Solution:
    def uniqueLetterString(self, s: str) -> int:


class Solution:
    def isMatch(self, s: str, p: str) -> bool:


class Solution:
    def nthMagicalNumber(self, N: int, A: int, B: int) -> int:


class Solution:
    def findPeakElement(self, nums: List[int]) -> int:


class Solution:
    def splitArraySameAverage(self, A: List[int]) -> bool:


class Solution:
    def minMoves2(self, nums: List[int]) -> int:


class Solution:
    def largestRectangleArea(self, heights: List[int]) -> int:


class Solution:
    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:


class Solution:
    def numRollsToTarget(self, d: int, f: int, target: int) -> int:


class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:


class Solution:
    def longestPalindrome(self, s: str) -> str:


class Solution:
    def shortestPathAllKeys(self, grid: List[str]) -> int:


class Solution:
    def numOfSubarrays(self, arr: List[int], k: int, threshold: int) -> int:


class Solution:
    def findLatestStep(self, arr: List[int], m: int) -> int:


class Solution:
    def nthPersonGetsNthSeat(self, n: int) -> float:


class Solution:
    def findMin(self, nums: List[int]) -> int:


class Solution:
    def canCross(self, stones: List[int]) -> bool:


class Solution:
    def numOfMinutes(self, n: int, headID: int, manager: List[int], informTime: List[int]) -> int:


class Solution:
    def sumFourDivisors(self, nums: List[int]) -> int:


class Solution:
    def countTriplets(self, arr: List[int]) -> int:


class Solution:
    def leastBricks(self, wall: List[List[int]]) -> int:


class Solution:
    def primePalindrome(self, N: int) -> int:


class Solution:
    def canVisitAllRooms(self, rooms: List[List[int]]) -> bool:


class Solution:
    def jobScheduling(self, startTime: List[int], endTime: List[int], profit: List[int]) -> int:


class Solution:
    def reverseParentheses(self, s: str) -> str:


5
1 1
R
2 3
LLRU
3 2
LLRU
4 3
ULURUDRDLD
3 6
RURUR


Truly Happy
Poor Chef
Poor Chef
Truly Happy


3
4 2
abcb
7 1
aayzbaa
12 80123123
abzbabzbazab


2 4
RowAdd 1 3
ColAdd 2 1
ColAdd 1 4
RowAdd 2 1


4
5 1
frauD
5 1
FRAUD
4 4
Life
10 4
sTRAWBerry


2
2 3
3 3
————————————————————————————————————————


3
gandhi
mahatma gandhI
Mohndas KaramChand gandhi


4
helowrd 0
background 0
abcdefghijklmnopqrstuvwxyz 0
b 1


2 4
1 2
1 1 WhoDoesntLoveChefBook
2 2 WinterIsComing
3 10 TheseViolentDelightsHaveViolentEnds
4 3 ComeAtTheKingBestNotMiss

WinterIsComing
WhoDoesntLoveChefBook
TheseViolentDelightsHaveViolentEnds
ComeAtTheKingBestNotMiss


3
Government clg Berhampore
SeRaMporE textile college
Girls college Kolkata


3
abcd
4
a b c d
aabbbcccdddd
4
a b c d
acd
3
a b d


class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:


class Solution:
    def peakIndexInMountainArray(self, arr: List[int]) -> int:


class Solution:
    def thirdMax(self, nums: List[int]) -> int:


class Solution:
    def isPerfectSquare(self, num: int) -> bool:


class Solution:
    def minStartValue(self, nums: List[int]) -> int:


class Solution:
    def hasAlternatingBits(self, n: int) -> bool:


class Solution:
    def isPalindrome(self, s: str) -> bool:


class Solution:
    def makeGood(self, s: str) -> str:


class Solution:
    def findLHS(self, nums: List[int]) -> int:


class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:


class Solution:
    def backspaceCompare(self, S: str, T: str) -> bool:


class Solution:
    def isPowerOfTwo(self, n: int) -> bool:


class Solution:
    def tictactoe(self, moves: List[List[int]]) -> str:


class Solution:
    def mySqrt(self, x: int) -> int:


class Solution:
    def judgeCircle(self, moves: str) -> bool:


class Solution:
    def gcdOfStrings(self, str1: str, str2: str) -> str:


class Solution:
    def maxProfit(self, prices: List[int]) -> int:


class Solution:
    def defangIPaddr(self, address: str) -> str:


class Solution:
    def hasGroupsSizeX(self, deck: List[int]) -> bool:


class Solution:
    def sumOddLengthSubarrays(self, arr: List[int]) -> int:


class Solution:
    def minMoves(self, nums: List[int]) -> int:


class Solution:
    def findTheDistanceValue(self, arr1: List[int], arr2: List[int], d: int) -> int:


class Solution:
    def isPrefixOfWord(self, sentence: str, searchWord: str) -> int:


class Solution:
    def hammingDistance(self, x: int, y: int) -> int:


class Solution:
    def findUnsortedSubarray(self, nums: List[int]) -> int:


class Solution:
    def findLucky(self, arr: List[int]) -> int:


class Solution:
    def isPowerOfFour(self, num: int) -> bool:


class Solution:
    def countNegatives(self, grid: List[List[int]]) -> int:


class Solution:
    def findSpecialInteger(self, arr: List[int]) -> int:


7
UK
China
USA
France
New Zealand
UK
France


def is_leap(year):
    leap = False

    # Write your logic here

    return leap

year = int(input())
print(is_leap(year))


12
insert 0 5
insert 1 10
insert 0 6
print
remove 6
append 9
append 1
sort
print
pop
reverse
print


2
<title>HTML Parser - I</title>

HackerRank

Start : html
Start : head
Start : title
End   : title
End   : head
Start : body
-> data-modal-target > None
-> class > 1
Start : h1
End   : h1
Empty : br
End   : body
End   : html


def zero_fuel(distance_to_pump, mpg, fuel_left):


def passer_rating(att, yds, comp, td, ints):


The Fox asked the stork, 'How is the soup?'

Suddenly he stopped, and glanced up at the houses

Zebras evolved among the Old World horses within the last four million years.

Although zebra species may have overlapping ranges, they do not interbreed.

Now and then, however, he is horribly thoughtless, and seems to take a real delight in giving me pain.


Joe listened to the noise and it was an onamonapia

Joe listened to the noises and there were some onamonapias