An Introduction to Interactive Programming in Python (Part 1) -- Week 2_2 练习

#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('=====')