#Practice Exercises for Logic and Conditionals

# Solve each of the practice exercises below.

# 1.Write a Python function is_even that takes as input the parameter number (an integer) and

# returns True if number is even and False if number is odd.

# Hint: Apply the remainder operator to n (i.e., number % 2) and compare to zero.

def is_even(number):

    if number % 2 == 0:

        return True

    else:

        return False

res = is_even(93)

print(res)

print('=====')

# 2.Write a Python function is_cool that takes as input the string name and

# returns True if name is either "Joe", "John" or "Stephen" and returns False otherwise.

# (Let's see if Scott manages to catch this. ☺ )

def is_cool(name):

    cool_names = ["Joe", "John", "Stephen"]

    if name in cool_names:

        return True

    else:

        return False

res = is_cool("Scott")

print(res)

print('=====')

# 3.Write a Python function is_lunchtime that takes as input the parameters hour

# (an integer in the range [1,12]) and is_am (a Boolean “flag” that represents whether the hour is before noon).

# The function should return True when the input corresponds to 11am or 12pm (noon) and False otherwise.

# If the problem specification is unclear, look at the test cases in the provided template.

# Our solution does not use conditional statements.

def is_lunchtime(hour, is_am):

    if hour == 11 and is_am:

        return True

    else:

        return False

res = is_lunchtime(11, True)

print(res)

print('=====')

# 4.Write a Python function is_leap_year that take as input the parameter year and

# returns True if year (an integer) is a leap year according to the Gregorian calendar and False otherwise.

# The Wikipedia entry for leap yearscontains a simple algorithmic rule for

# determining whether a year is a leap year. Your main task will be to translate this rule into Python.

def is_leap_year(year):

    if year % 400 == 0:

        is_leap = True

    elif year % 100 == 0:

        is_leap = False

    elif year % 4 == 0:

        is_leap = True

    else:

        is_leap = False

    return is_leap

res = is_leap_year(2016)

print(res)

print('=====')

# 5.Write a Python function interval_intersect that takes parameters a, b, c, and d and

# returns True if the intervals [a,b] and [c,d] intersect and False otherwise.

# While this test may seem tricky, the solution is actually very simple and consists of one line of Python code.

# (You may assume that a≤b and c≤d.)

def interval_intersect(a, b, c, d):

    if a > d or b < c:

        return False

    else:

        return True

res = interval_intersect(1,2,3,4)

print(res)

print('=====')

# 6.Write a Python function name_and_age that take as input the parameters name (a string) and age (a number) and

# returns a string of the form "% is % years old." where the percents are the string forms of name and age.

# The function should include an error check for the case when age is less than zero.

# In this case, the function should return the string "Error: Invalid age".

def name_and_age(name, age):

    if age >= 0:

        form = "%s is %d years old." % (name, age)

    else:

        form = "Error: Invalid age"

    return form

res = name_and_age("John", -25)

print(res)

print('=====')

# 7.Write a Python function print_digits that takes an integer number in the range [0,100) and

# prints the message "The tens digit is %, and the ones digit is %." where the percents should be replaced

# with the appropriate values. The function should include an error check for the case when number is

# negative or greater than or equal to 100. In those cases,

# the function should instead print "Error: Input is not a two-digit number.".

def print_digits(number):

    if number in range(100):

        tens, ones = number // 10, number % 10

        message = "The tens digit is %d, and the ones digit is %d." % (tens, ones)

    else:

        message = "Error: Input is not a two-digit number."

    print(message)

print_digits(49)

print_digits(-10)

print('=====')

# 8.Write a Python function name_lookup that takes a string first_name that corresponds to

# one of ("Joe", "Scott", "John" or "Stephen") and then

# returns their corresponding last name ("Warren", "Rixner", "Greiner" or "Wong").

# If first_name doesn't match any of those strings, return the string "Error: Not an instructor".

def name_lookup(first_name):

    first_names = ("Joe", "Scott", "John", "Stephen")

    last_names = ("Warren", "Rixner", "Greiner", "Wong")

    if first_name in first_names:

        return last_names[first_names.index(first_name)]

    else:

        return "Error: Not an instructor"

res = name_lookup("Scott")

print(res)

print('=====')

# 9.Pig Latin is a language game that involves altering words via a simple set of rules.

# Write a Python function pig_latin that takes a string word and

# applies the following rules to generate a new word in Pig Latin.

# If the first letter in word is a consonant, append the consonant plus "ay" to the end

# of the remainder of the word. For example, pig_latin("pig") would return "igpay".

# If the first letter in word is a vowel, append "way" to the end of the word.

# For example, pig_latin("owl") returns "owlway". You can assume that word is in lower case.

# The provided template includes code to extract the first letter and the rest of word in Python.

# Note that, in full Pig Latin, the leading consonant cluster is moved to the end of the word.

# However, we don't know enough Python to implement full Pig Latin just yet.

def pig_latin(word):

    if word[0] in "aeoui":

        return word + "way"

    else:

        return word[1:] + word[0] + "ay"

res = pig_latin("owl")

print(res)

print('=====')

# 10.Challenge: Given numbers a, b, and c, the quadratic equation ax2+bx+c=0 can

# have zero, one or two real solutions (i.e; values for x that satisfy the equation).

# The quadratic formula x=−b±b2−4ac2a can be used to compute these solutions.

# The expression b2−4ac is the discriminant associated with the equation.

# If the discriminant is positive, the equation has two solutions.

# If the discriminant is zero, the equation has one solution.

# Finally, if the discriminant is negative, the equation has no solutions.

# Write a Python function smaller_root that takes an input the numbers a, b and c and

# returns the smaller solution to this equation if one exists.

# If the equation has no real solution, print the message "Error: No real solutions" and simply return.

# Note that, in this case, the function will actually return the special Python value None.

def smaller_root(a, b, c):

    discriminant = b ** 2 - 4 * a * c

    if discriminant > 0:

        return (-b - math.sqrt(discriminant)) / (2.0 * a)

    elif discriminant == 0:

        return -b / (2.0 * a)

    else:

        print("Error: No real solutions")

        return 

res = smaller_root(1.0, -2.0, 1.0)

print(res)

print('=====')