def diff (num) :
    return max(num) - min(num)

def munged_password (password) :
    
    # munged character map
    munged_chars = {"a" : "@", 
                    "i": "!", 
                    "o":"0", 
                    "s" : "$"}
    
    # convert the string to a list (since string is immutable)
    password_list = list(password)
    
    # iterate over list and substitute
    for index, char in enumerate(password_list) :
        
        # attempt to get the substitution
        char_sub = munged_chars.get(char)
        
        # if found, do the substitution
        if char_sub != None :
            password_list[index] = char_sub   
    
    # convert the list back to string 
    password_str = "".join(password_list)
    
    return password_str
    

def nth_number (numbers, n, large_small) :
    '''
        Method : Sort list and start counting forward or backward
        based on the value large_small
    '''
    
    
    # counts the occurrence of the nth number
    count = 0
    
    # numbers in the list could repeat. Keep track of repeated numbers
    number_repeat = None
    
    # The actual nth (largest or smallest) number
    nth_number = None
    
    # sorting is a O(n^2) or O(n log(n)) in the worst case.
    if large_small == "large" :
        numbers.sort(reverse=True)
        
    elif large_small == "small" :
        numbers.sort()
    
    for number in numbers :
        
        if number == number_repeat :
            pass
        else :
            number_repeat = number
            count = count + 1
        
        if count == n :
            nth_number = number
            break
        
        
    return nth_number
    
    

def swap_case(text) :
    
    text_list = list(text)
    text_list_converted = []
    
    for char in text_list :
        if char.isupper() :
            text_list_converted.append(char.lower())
        else :
            text_list_converted.append(char.upper())
            
    return "".join(text_list_converted)    
    

def swap_case(text) :
    
    text_converted = "".join(c.lower() if c.isupper() else c.upper() for c in text)
    return text_converted
    

def swap_case(text) :

    return text.swapcase()    
    

# In this program we will learn about
# 1. Functions
# 2. while Loop
# 3. break statement
# 4. if statement
# 5. boolean values
# 6. type conversion
 
secret_num = 59
print ( " Guess a number between 1 and 100")
num = input ()
 
while ( True ):
     
    if   int(num) > secret_num :
        print ( " guess a lower number " )
        num = input ()
 
    if int(num) < secret_num : 
        print ( " guess a higher number" )
        num = input ()
         
    if int(num) == secret_num : 
        print ( " Hurray !! you guessed it ")
        break

numbers = [1,3,4,2,1,4,5,7,5,2]

min = numbers[0]
max = numbers[0]

for number in numbers : 
    if number < min :
        min = number
    if number > max :
        max = number 
        
print ( "max number is ", max)
print ( "min number is ", min)

def compare (str1, str2) :
    if str1.lower() == str2.lower():
        return True
    else : 
        return False

def compare (str1, str2) :
def isspace ( sentence) :
    if " " in sentence or "\t" in sentence : 
        return True
    else :
        return False

def all_substrings(text, letter) :
    '''
        Returns all the possible substrings that start with the
        letter - 'letter' in the text. Assuming that the text has no blanks.
    '''
    
    # will hold the final list of substrings
    words = set()
    
    # loop through each of the letters in the text
    for start in range(len(text)) :
        
        # if the character is equal to 'letter'
        if text[start] == letter :
            
            # start making words (till the end )
            for word_start in range(start-1, len(text)+1) :
                words.add(text[start: word_start])
    
    return words

sentence = input("enter sentence => ")
word = input ("enter word or substring to search => ")

count = 0 

for i in range(len(sentence)) :
    print ( sentence[i : len(word) + i] , word)
    if sentence[i : len(word) + i] == word : 
        
        count = count + 1

print ( count )

def checkKeyValue(key, dictionary) :
    keys = dictionary.keys()
    values = dictionary.values()
    
    if key in keys : 
        return key, dictionary[key]
    if key in values : 
        return list(keys)[list(values).index(key)] , key

# Try it with a simple dictionary like this
dictionary = {"India"             : 1.3, 
              "China"             : 1.4,
              "United States"     : 0.3,
              "Vietnam"           : 0.1 }

checkKeyValue(1.3,dictionary)

def findDigits(num) :
    
    count = 0
    while num> 0 :
        num = num // 10
        count = count + 1
    
    return count

def findDigits(num) :
    
def reverse(li):
    
    i = len(li)
    new_list = []
    
    while i > 0 :
        new_list.append(li[i-1])
        i = i - 1
    
    return new_list

# if you could use the built-in functions, this would be much easier. 
# like 
numbers.reverse() 
# OR get a reverse iterator using 
reversed(numbers)

def us_zip_code ( zip_code ) :
    
    # assume zip_code is a string
    
    if zip_code.isnumeric() and len(zip_code) == 5 :
        return True
    
    if zip_code[0:5].isnumeric() and zip_code[5] == "-" and zip_code[6:10].isnumeric() and len(zip_code) == 10:
        return True
    
    return False

sentence = input("enter sentence => ")

new_sentence = ""

for char in sentence : 
    if char.islower() :
        new_sentence = new_sentence + char.upper()
    if char.isupper() :
        new_sentence = new_sentence + char.lower()
    if char == " " :
        new_sentence = new_sentence + char

text = input("enter string -")
 
i = len(text)
r_text = ""
 
while i > 0  :
    r_text = r_text + text[i-1]
    i = i - 1
 
print ( r_text)

text = input ( "enter string - ")
 
for word in text.split() :
    print ( word.title())

user_input = input ( "Enter your name - ")
print ( user_input.capitalize() )

user_input = input ( "Choose a user id - ")
if user_input.isalnum() == False :
    print ( "Make sure all the characters are either alphabetic or numeric")

card_number = input ("Enter Credit card number > ")
card_number = card_number.replace("-", "").replace("\t","").replace(" ","")

length = len(card_number)
masked_card_number = ""
pretty_card_number = ""

for index,char in enumerate(card_number) :
    if index < length - 4 :
        masked_card_number += char
    else : 
        masked_card_number += "*"

for index, char in enumerate(masked_card_number) :
    pretty_card_number += char
    if ( index + 1 ) % 4 == 0 and index != length-1:
        pretty_card_number += "-"    
        
print ( "Masked Card Number = ", pretty_card_number)

def encode (text ) :
    encoded_text= ""

    for char in text :
        char = char.lower()
        if char.isalpha() and char != " ":        
            encoded_text += morse_code.get(char)
            encoded_text += " "
        
    return encoded_text 

def encode (text ) :

    first_digit = 0
    last_digit  = 0
    digits      = []

    for char in text :

        if char.isnumeric() :
            digits.append(char)
    
    return digits[0], digits [len(digits)-1]

def zip_lists ( list_1, list_2 ) :

    ''' This function is essentially a zip function. 
    '''
    list_3 = []  # return a set of typle in a list.

    # if the length of the lists are unequal, pick the shorter list to iterate.
    list_iter = 0
    
    if len(list_1) >= len(list_2) :
        list_iter = len(list_2)
    else :
        list_iter = len(list_1)
        
    for i in range(list_iter) :
        tup = (list_1[i], list_2[i])
        list_3.append(tup)
       
    return list_3

print ( "Enter 3 numbers - ")
 
first   = int( input ( "Enter first number - ") )
second  = int( input ( "Enter second number - ") )
third   = int( input ( "Enter third number - ") )
 
if first > second :
    greater = first
else :
    greater = second
 
if third > greater :
    print ("The largest number is - ", third)
else :
    print ( "The largest number is - ", greater)

s = input ( "Enter the string to be searched - ").upper()
a = input ( "Enter the alphabet to be searched - ").upper()
 
counter = 0
 
for i in range(len(s)) :
    if a == s[i] :
        counter = counter + 1
 
print ("The character ",a," occurs ", counter, " number of times")
 
# Using the count() function - This becomes just a one liner.
# print ("The character ",a," occurs ", s.count(a), " number of times")

s = input ( "Enter the string to be searched - ")
 
counter_l = 0   # counter for lower case
counter_u = 0   # counter for upper case
 
for i in range(len(s)) :
    if s[i].islower() == True :
        counter_l = counter_l + 1
    elif s[i].isupper() == True:
        counter_u = counter_u + 1
 
print ( "The number of upper case characters is ", counter_u)
print ( "The number of lower case characters is ", counter_l)

from string import ascii_letters

def swap (string, number) :
    letters = ""
    new_string = ""
    small_letters = ascii_letters[0:26]
    capital_letters = ascii_letters[26:52]
    
    for char in string :
        if char in small_letters :
            letters = small_letters
        elif char in capital_letters :
            letters = capital_letters
        
        if char in letters :
            curr_index = letters.index(char)
            required_index = curr_index + number
        
        if required_index > 25 :
            required_index = (required_index % 25) - 1
        
        print ( required_index)
        new_string = new_string + letters[required_index]
        
    return new_string

#sample list
persons = [["Ajay", 23, "Hyderabad"],
           ["Stacy", 25, "Los Angeles"],
           ["Xing", 21, "Shanghai"]]

# function to return the second element in the list element
def sort_age (element) :
    return element[1]

# Use python's sorted function and set the key parameter to the custom function defined above.
sorted(persons, key = sort_age)

def alternate_odd (n) :
    sum = 0
    alternate = True

    for number in range(n+1) :
        if number % 2 == 0 :
            continue

        if alternate == True :
            sum = sum + number
            alternate = False
            continue

        alternate = True
        
    return sum

# characteristics of a probable candidate for a job opening
age = 21
qualification = "Bachelors"
experience = 2

# Let the variable "hired" be a Logical variable. So, it takes a True or False.
# Write an if statement such that based on the following conditions the program should determine if the 
# candidate is can be considered for a job interview or not. 
# 1. candidates with at least an age of 21 and 
# 2. a qualification of either "Bachelors" or "Masters"  
# 3. and at least an experience of 2 years.

match = True

if age == 21 and ( qualification == "Bachelors" or qualification == "Masters" ) and experience >= 2 :
    match = True
else : 
    match = False