D. Do this online reading: Counted Loops Your First Programs, Part 4: Functions, doing the next set of questions while you do so. 1. Choose the correct lines to make a loop that prints 'funny' 40,000 times. M. Line 1->for k in range(40000): M. Line 2->    print('funny') M. ->for k in range(40001) M. ->for k in range(n) M. ->    return 'funny' M. ->    print 'funny' 30. Choose the correct lines to make a loop that prints the cubes of the numbers from 0 to m, inclusive (where m is some integer bigger than 35). For example, if m were 37, then this loop should print:

42875

46656

50653

These are 35 cubed, 36 cubed, and 37 cubed. M. Line 1->for i in range(m+1) M. ->for i in range(m) M. ->for i in range(0) M. Line 2->    print(i**3) M. ->    print(35**3) M. ->    print(m**3) D. Watch Video: The Accumulator Pattern - Summing D. Watch the video: Your First Programs, Part 4: Functions, doing the next set of questions while you do so. 11. Trace the snippet of code shown to below by hand (no fair typing it into a program), and show what gets printed: 

total = 0
for k in range(5):
    total = total + (k + 10)
    print(k, total)

print('The sum 10 + 11 + 12 + 13 + 14 is')
print(total)
M. Line 1 -> 0 10 M. Line 2 -> 1 21 M. Line 3 -> 2 33 M. Line 4 -> 3 46 M. Line 5 -> 4 60 M. Line 6 -> The sum 10 + 11 + 12 + 13 + 14 is M. Line 7 -> 60 M. -> 0 10 M. -> 1 11 M. -> 2 12 M. -> 3 13 M. -> 4 14 M. -> 5 15 M. -> 75 12. Write a snippet of code that calculates: 
math.sin(3)+math.sin(4)+math.sin(5)+...+math.sin(500)
Assume that there is already an import math that executed previously in the code. M. Line 1 -> total = 0 M. Line 2 -> for k in range(408): M. Line 3 ->     total = total + math.sin(k+3) M. -> for k in range(500): M. -> for k in range(3): M. -> total = 500 M. -> total = math.sin(k+3) M. ->     total = math.sin(k+3) D. Online Reading: Functions with Parameters and Returned Values.
Textbook Reading: Section 5.3 - Parameter Passing (pages 226 - 228) D. Watch the video: Your First Programs, Part 4: Functions, doing the next set of questions while you do so. 13. Consider the function call 
round(3.14159, 2)
, which rounds 3.14159 to 2 decimal places. What are the arguments? a. 3.14159 and 2~ b. 3.14159 c. 2 d. 3.14 e. round 14. Consider the function call 
round(3.14159, 2)
, which rounds 3.14159 to 2 decimal places. What is the return value? a. 3.14159 and 2 b. 3.14159 c. 2 d. 3.14~ e. round 15. As a user of a function (that is, as someone who will call the function), you don't need to know how the function is implemented; you just need to know the specification of the function. a. True~ b. False D. Consider the cubeVolume function defined below. 
def cubeVolume(sideLength):
    volume = sideLength ** 3
    return volume
16. What is the value of cubeVolume(3)? a. 9 b. 27~ c. 81 d. 256 e. 512 17. What is the value of cubeVolume(cubeVolume(2))? a. 9 b. 27 c. 81 d. 256 e. 512~ 18. Provide an alternate implementation of the body of the cubeVolume that does not use the exponent operator. M. Line 1 ->     volume = sideLength * sideLength * sideLength M. Line 2 ->     return volume M. ->     volume = sideLength * 3 M. ->     volume = sideLength ^ 3 D. Consider the mystery function defined below. 
def mystery(x, y):
    result = (x + y) / (y - x)
    return result
19. What is the value of mystery(2,3)? ANS. 5 20. What is the value of mystery(3,2)? ANS. -5 D. Online Reading: Namespaces and Variables' Scope. 21. What gets printed when main is called in the program shown below? (Pay close attention to the order in which the statements are executed.) 
def main():
    hello()
    goodbye()
    hello_and_goodbye()
    goodbye()
   
def hello():
    print('Hello!')
    return 'Hello!'
    print('Hello Again!')
   
def goodbye():
    print('Ciao!')
   
def hello_and_goodbye():
    print('Here is stuff!')
    goodbye()
    hello()
    hello()
    print('Here is more!')
    hello()
    goodbye()
M. Line 1 -> Hello! M. Line 2 -> Ciao! M. Line 3 -> Here is stuff! M. Line 4 -> Ciao! M. Line 5 -> Hello! M. Line 6 -> Hello! M. Line 7 -> Here is more! M. Line 8 -> Hello! M. Line 9 -> Ciao! M. Line 10 -> Ciao! M. -> Hello Again! M. -> Hello Again! 22. What gets printed when main is called in the program shown below?

def main():
    a = 4
    answer = mystery(a + 1)
    print(answer)

def mystery(x):
    y = x * x
    return y
ANS. 25 23. What gets printed when main is called in the program shown below?

def main():
    big()
    bigger()
    biggest()
    big()

def big():
    print('basketball')

def bigger():
    print('truck')
    big()

def biggest():
    print('house')
    bigger()
    big()
M. Line 1 -> basketball M. Line 2 -> truck M. Line 3 -> basketball M. Line 4 -> house M. Line 5 -> truck M. Line 6 -> basketball M. Line 7 -> basketball M. Line 8 -> basketball 24. What gets printed when main is called in the program shown below?
def main():
    a = 4
    print(mystery(a + 1))
   
def mystery(x):
    return x * x
ANS. 25 25. Consider the totalCents function shown below. This function correctly calculates and returns the number of cents that is equivalent to a given number of dollars and cents.

def totalCents(dollars, cents):
    cents = (dollars * 100) + cents
    return cents
For example, totalCents(3, 71) correctly returns 371. However, this function violates a style rule: Do Not Modify Parameter Values (in a function's body). This style rule is a good rule because modifying parameter values: a. Yields ugly code. b. Is an error-prone practice.~ c. Causes the sky to fall. d. Makes Pointy-Headed Managers unhappy. 26. Show how one could write totalCents without violating the Do Not Modify Parameter Values rule. M. Line 1 -> change = (dollars * 100) + cents M. Line 2 -> return change M. -> dollars = (dollars * 100) + cents M. -> cents = (dollars * 100) + cents M. -> return dollars M. -> return cents D. The boxString function takes a string as its argument and displays that string "in a box":

def boxString(contents):
    n = len(contents)
    print('-' * (n + 2))
    print('!' + contents + '!')
    print('-' * (n + 2))
Calling boxString with 'Hello Moon' as its argument yields the following: 
------------
!Hello Moon!
------------
27. Consider the following (silly!) statement: 
print(boxString('Hello'))
What, exactly, does the above statement cause to appear on the Console? M. Line 1 -> ------- M. Line 2 -> !Hello! M. Line 3 -> ------- M. Line 4 -> None M. -> !Hello Moon! M. -> ------------ M. -> ------------ M. -> (nothing appears on this line) 28. How should the above statement been written, to be sensible? a. boxString('Hello')~ a. print(boxString('Hello')) b. print(boxString('Hello')) - None c. print(boxString('Hello') - None) d. boxString('!Hello!') 29. Write statements that would use boxString to produce on the Console the output shown below.

-------
!Hello!
-------
------
!Moon!
------
M. Line 1 -> boxString('Hello') M. Line 2 -> boxString('Moon') M. -> print(boxString('Hello')) M. -> print(boxString('Moon')) D. For each of the following boxes: For this and all subsequent problems, assume that no global variables have been defined. 30. 
def main():
    x = foo()
    print(x)

def foo(m):
    return m ** 3
a. Correct, prints x**3 b. Correct, prints m**3 c. Incorrect because the call to foo is missing a parameter~ d. Incorrect because m is undefined e. Incorrect because x is undefined f. Incorrect because the value of m can't be cubed 31. 
def main():
    x = foo(m)
    print(x)

def foo(m):
    return m ** 3
a. Correct, prints x**3 b. Correct, prints m**3 c. Incorrect because the call to foo is missing a parameter d. Incorrect because m is undefined~ e. Incorrect because x is undefined f. Incorrect because the value of m can't be cubed 32. 
def main():
    x = foo('help')
    print(x)

def foo(m):
    return m ** 3
a. Correct, prints helphelphelp a. Correct, prints m**3 c. Incorrect because the call to foo is missing a parameter d. Incorrect because m is undefined e. Incorrect because x is undefined f. Incorrect because the value of m can't be cubed~ 33. The code in the box below has syntax errors: it causes big red X error message(s). Check all lines that will have red X error message(s) beside them. 
def main():
    foo()
    print(n)
    print(m)

def foo():
    n = 3
    m = 1
    return m
a. def main(): b. foo() c. print(n)~ d. print(m)~ e. def foo(): f. n = 3 g. m = 1 h. return m 34. Suppose you want to write a function called distance that has two rg.Point objects sent to it and returns the distance between them. What would be the best "header" line of distance? a. def distance(start, end)~ b. def distance(a, b) c. def distance(x, y) d. def foo(a, b) 35. Suppose you want to write a function called drawPoint that takes a rg.Point object and a rg.RoseWindow object (in that order) and draws the point on the window. What would be the best "header" line of drawPoint? a. def drawPoint(point, window)~ b. def drawPoint(p, w) c. def drawPoint(a, b) d. def drawPoint(x, y) 36. What gets printed when main is called in the program shown below?
def main():
    a = 2
    b = 3

    m = do_it(a, b)
    print(m)

    m = do_it(b, a)
    print(m)

    m = do_it(a, a)
    print(m)

    m = do_it(b, b)
    print(m)

    c = do_it(b, a)
    m = do_it(c, a)
    print(m)

    b = do_it(b, a)
    m = do_it(b, a)
    print(m)

def do_it(x, y):
    return x ** y
M. Line 1 -> 8 M. Line 2 -> 9 M. Line 3 -> 4 M. Line 4 -> 27 M. Line 5 -> 81 M. Line 6 -> 81 M. -> 6561 37. What gets printed when main is called in the program shown below? 
def main():
    a = 2
    b = 3

    foo1()
    print(a, b)

    foo2(a, b)
    print(a, b)

    foo3(a, b)
    print(a, b)

def foo1():
    a = 88
    b = 99

def foo2(a, b):
    a = 400
    b = 500

def foo3(x, y):
    x = 44
    y = 55
M. Line 1 -> 2 3 M. Line 2 -> 2 3 M. Line 3 -> 2 3 M. -> 88 99 M. -> 400 500 M. -> 44 55