# https://www.hackerrank.com/challenges/default-arguments/problem

class EvenStream(object):
    def __init__(self):
        self.current = 0

    def get_next(self):
        to_return = self.current
        self.current += 2
        return to_return

class OddStream(object):
    def __init__(self):
        self.current = 1

    def get_next(self):
        to_return = self.current
        self.current += 2
        return to_return

# stream.__init__() is added because if we use an object as a default argument in python it's only initialised once when the function is 
# defined and is reused every time there is need for the default argument. hence only the odd function's variable was resetting, While 
# the even's was adding up as the object for even was created at the first use and so the init was only invoked once. so invoking the 
# constructor every time the streams are called will reset the class variable everytime.    
    
def print_from_stream(n, stream=EvenStream()):
    stream.__init__()
    for _ in range(n):
        print(stream.get_next())

queries = int(input())
for _ in range(queries):
    stream_name, n = input().split()
    n = int(n)
    if stream_name == "even":
        print_from_stream(n)
    else:
        print_from_stream(n, OddStream())
                    

# https://www.hackerrank.com/challenges/ginorts/problem

S = str(input())
k = len(S)
m = []
n = []
p = []
q = []
for i in range (0,k):
    if S[i].islower():
        m.append(S[i])
        m.sort()
    if S[i].isupper():
        n.extend(S[i])
        n.sort()
    if S[i].isdecimal():
        e = int(S[i])
        if e % 2 == 1:
            p.extend(S[i])
            p.sort()
    if S[i].isdecimal():
        e = int(S[i])
        if e % 2 == 0:
            q.extend(S[i])
            q.sort() 
t = m + n + p + q            
r = ''.join(t)
print(r)        

# Basic method of setting and getting attributes in Python
class Celsius:
    def __init__(self, temperature=0):
        self.temperature = temperature

    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32


# Create a new object
human = Celsius()

# Set the temperature
human.temperature = 37

# Get the temperature attribute
print(human.temperature)

# Get the to_fahrenheit method
print(human.to_fahrenheit())

# Making Getters and Setter methods
class Celsius:
    def __init__(self, temperature=0):
        self.set_temperature(temperature)

    def to_fahrenheit(self):
        return (self.get_temperature() * 1.8) + 32

    # getter method
    def get_temperature(self):
        return self._temperature

    # setter method
    def set_temperature(self, value):
        if value < -273.15:
            raise ValueError("Temperature below -273.15 is not possible.")
        self._temperature = value
        
# As we can see, the above method introduces two new get_temperature() and set_temperature() methods.Furthermore, temperature was replaced
# with _temperature. An underscore _ at the beginning is used to denote private variables in Python.        

# Create a new object, set_temperature() internally called by __init__
human = Celsius(37)

# Get the temperature attribute via a getter
print(human.get_temperature())

# Get the to_fahrenheit method, get_temperature() called by the method itself
print(human.to_fahrenheit())

# new constraint implementation
human.set_temperature(-300)

# Get the to_fahreheit method
print(human.to_fahrenheit())

# https://www.hackerrank.com/challenges/decorators-2-name-directory/problem

def person_lister(f):
    def inner(people):
        names = []
        people.sort(key=lambda x: int(x[2]))
        for person in people:
            names.append(f(person))
        return names
    return inner
@person_lister
def name_format(person):
    return ("Mr. " if person[3] == "M" else "Ms. ") + person[0] + " " + person[1]
   
if __name__ == '__main__':
    people = [input().split() for i in range(int(input()))]
    print(*name_format(people), sep='\n') 

# https://www.hackerrank.com/challenges/text-alignment/problem


thickness = int(input()) #This must be an odd number
c = 'H'

#Top Cone
for i in range(thickness):
    print((c*i).rjust(thickness-1)+c+(c*i).ljust(thickness-1))

#Top Pillars
for i in range(thickness+1):
    print((c*thickness).center(thickness*2)+(c*thickness).center(thickness*6))

#Middle Belt
for i in range((thickness+1)//2):
    print((c*thickness*5).center(thickness*6))    

#Bottom Pillars
for i in range(thickness+1):
    print((c*thickness).center(thickness*2)+(c*thickness).center(thickness*6))    

#Bottom Cone
for i in range(thickness):
    print(((c*(thickness-i-1)).rjust(thickness)+c+(c*(thickness-i-1)).ljust(thickness)).rjust(thickness*6))

from more_itertools import chunked

list(chunked([1, 2, 3, 4, 5, 6], 3))
list(chunked([1, 2, 3, 4, 'r', 6], 5))

p = peekable(['a', 'b'])
p.peek()

from itertools import count
from more_itertools import ichunked

all_chunks = ichunked(count(), 4)
c_1, c_2, c_3 = next(all_chunks), next(all_chunks), next(all_chunks)
list(c_2) 
list(c_1)
list(c_3)

n = int(input())
width = len("{0:b}".format(n))
for i in range(1,n+1):
  print ("{0:{width}d} {0:{width}o} {0:{width}X} {0:{width}b}".format(i, width=width))

# https://www.hackerrank.com/challenges/python-print/problem

if __name__ == '__main__':
    n = int(input())
    a = 0
    for k in range(1, n+1):
        if k >= 10 and k < 100:
            a = 100 * a + k
        elif k >= 100:
            a = 1000 * a + k
        else:
            a = 10*a + k
print(a)

import math
import os
import random
import re
import sys

def solve(s):
    return ' '.join(map(str.capitalize, s.split(' ')))

if __name__ == '__main__':
    os.environ['OUTPUT_PATH'] = 'output.txt'    
    fptr = open(os.environ['OUTPUT_PATH'], 'w')
    
s = input()
result = solve(s)
fptr.write(result + '\n')
fptr.close()

S, N = input(), int(input()) 
for part in zip(*[iter(S)] * N):
    d = dict()
    print(''.join([ d.setdefault(c, c) for c in part if c not in d ]))

# https://www.hackerrank.com/challenges/write-a-function/problem

def is_leap(year):
    return ((year % 4 == 0 and year % 100 != 0) or (year % 4 == 0 and year % 400 == 0))
year = int(input())
print(is_leap(year))

# https://www.hackerrank.com/challenges/validating-uid/problem

T = int(input())
list = []
for i in range(0,T):
    list.append((input()))
for uid in list:
    u = 0
    d = 0
    a = 0
    r = ''
    for c in uid:
        if c.isalpha() and c.isupper:
            u = u + 1
        if c.isnumeric():
            d = d + 1
        if c.isalnum():        
            a = a + 1
        if c not in r:    
            r = r + c
    if u < 2 or d < 3 or a != len(uid) or len(r) != 10 or len(uid) != 10:
        print("Invalid")
    else:
        print("Valid")

# regex solution 1:
import re

for _ in range(int(input())):
    u = ''.join(sorted(input()))
    try:
        assert re.search(r'[A-Z]{2}', u)
        assert re.search(r'\d\d\d', u)
        assert not re.search(r'[^a-zA-Z0-9]', u)
        assert not re.search(r'(.)\1', u)
        assert len(u) == 10
    except:
        print('Invalid')
    else:
        print('Valid')

# regex solution 2:

import re

checks = {
  "alpha"     : lambda uid: re.match(r".*[A-Z].*[A-Z].*", uid),
  "num"       : lambda uid: re.match(r".*[0-9].*[0-9].*[0-9].*", uid),
  "alpha_num" : lambda uid: re.match(r"[A-Za-z0-9]{10}", uid),
  "repeat"    : lambda uid: not re.match(r".*(.).*\1.*", uid)
}

def main():
  for _ in range(int(input())):
    uid = input()
    print("Valid" if all(checks[check](uid) for check in checks.keys()) else "Invalid")

if __name__ == "__main__":
  main()

# regex solution 3:

import re
for _ in range(int(input())):
    s = input()
    print('Valid' if all([re.search(r, s) for r in [r'[A-Za-z0-9]{10}',r'([A-Z].*){2}',r'([0-9].*){3}']]) and not re.search(r'.*(.).*\1', s) else 'Invalid')

# regex solution 4:

[print('Valid' if all([re.search(r, s) for r in [r'[A-Za-z0-9]{10}',r'([A-Z].*){2}',r'([0-9].*){3}']]) and not re.search(r'.*(.).*\1', s) else 'Invalid') for s in [raw_input() for _ in range(int(raw_input()))]]

# regex solution 5:

import re

MATCH_UPPER = re.compile(r'[A-Z]')
MATCH_DIGIT = re.compile(r'\d')
MATCH_ALPHANUMERIC = re.compile(r'^[a-zA-Z0-9]+$')
MATCH_REPEAT_CHARACTERS = re.compile(r'^.*(.).*(\1).*$')
MATCH_LENGTH_10 = re.compile(r'^.{10}$')


def is_valid(uid):
    validators = [
        # it must contain at least 2 uppercase characters
        contains_match(MATCH_UPPER, count=2, op='>='),

        # it must contain at least 3 digits
        contains_match(MATCH_DIGIT, count=3, op='>='),

        # it should only contain alphanumeric characters
        contains_match(MATCH_ALPHANUMERIC),

        # no character should repeat
        contains_match(MATCH_REPEAT_CHARACTERS, count=0),

        # there must be exactly 10 characters
        contains_match(MATCH_LENGTH_10)
    ]
    return all(validator(uid) for validator in validators)


def contains_match(regex, count=1, op='=='):
    op_def = {
        '>=': lambda a, b: a >= b,
        '==': lambda a, b: a == b,
    }

    def validator(uid):
        op_compare = op_def[op]
        return op_compare(len(regex.findall(uid)), count)

    return validator


def main():
    from fileinput import input

    # get input
    uids = [line.rstrip() for line in input()]
    n = int(uids.pop(0))

    # for each uid ... print (In)Valid
    for i in range(n):
        uid = uids[i]
        print('Valid' if is_valid(uid) else 'Invalid')


if __name__ == '__main__':
    main()

# https://www.hackerrank.com/challenges/word-order/problem

f ={}
N = int(input())
for _ in range(N):
    s = input()
    if s not in f:
        f[s] = 1
    else:
        f[s] = f[s] + 1
print(len(f))
e = ''
for s in f:
    e = e + str(f[s]) + ' ' 
print(e)    

from collections import Counter, OrderedDict
class OrderedCounter(Counter, OrderedDict):
    pass
d = OrderedCounter(input() for _ in range(int(input())))
print(len(d))
print(*d.values())

from collections import OrderedDict
words = OrderedDict()

for _ in range(int(input())):
    word = input()
    words.setdefault(word, 0)
    words[word] += 1
   
print(len(words))
print(*words.values())