# Provided simple test() function
def test(got, expected):
    if got == expected:
        prefix = ' OK '
    else:
        prefix = '  X '
    print '%s got: %s expected: %s' % (prefix, repr(got), repr(expected))

"""
Explanation: String exercises
End of explanation
"""


def doughnuts(count):
    # +++your code here+++
    return

test(doughnuts(4), 'Number of doughnuts: 4')
test(doughnuts(9), 'Number of doughnuts: 9')
test(doughnuts(10), 'Number of doughnuts: many')
test(doughnuts(99), 'Number of doughnuts: many')

"""
Explanation: Fill in the code for the functions below. main() is already set up
to call the functions with a few different inputs,
printing 'OK' when each function is correct.
The starter code for each function includes a 'return'
which is just a placeholder for your code.
A. doughnuts
Given an int count of a number of doughnuts, return a string
of the form 'Number of doughnuts: <count>', where <count> is the number
passed in. However, if the count is 10 or more, then use the word 'many'
instead of the actual count.
So doughnuts(5) returns 'Number of doughnuts: 5'
and doughnuts(23) returns 'Number of doughnuts: many'
End of explanation
"""


def both_ends(s):
    # +++your code here+++
    return

test(both_ends('spring'), 'spng')
test(both_ends('Hello'), 'Helo')
test(both_ends('a'), '')
test(both_ends('xyz'), 'xyyz')

"""
Explanation: B. both_ends
Given a string s, return a string made of the first 2
and the last 2 chars of the original string,
so 'spring' yields 'spng'. However, if the string length
is less than 2, return instead the empty string.
End of explanation
"""


def fix_start(s):
    # +++your code here+++
    return

test(fix_start('babble'), 'ba**le')
test(fix_start('aardvark'), 'a*rdv*rk')
test(fix_start('google'), 'goo*le')
test(fix_start('doughnut'), 'doughnut')

"""
Explanation: C. fix_start
Given a string s, return a string
where all occurences of its first char have
been changed to '*', except do not change
the first char itself.
e.g. 'babble' yields 
ba**le
Assume that the string is length 1 or more.
Hint: s.replace(stra, strb) returns a version of string s
where all instances of stra have been replaced by strb.
End of explanation
"""


def mix_up(a, b):
    # +++your code here+++
    return

test(mix_up('mix', 'pod'), 'pox mid')
test(mix_up('dog', 'dinner'), 'dig donner')
test(mix_up('gnash', 'sport'), 'spash gnort')
test(mix_up('pezzy', 'firm'), 'fizzy perm')

"""
Explanation: D. mix_up
Given strings a and b, return a single string with a and b separated
by a space ' ', except swap the first 2 chars of each string.
Assume a and b are length 2 or more.
End of explanation
"""


def verbing(s):
    # +++your code here+++
    return

test(verbing('hail'), 'hailing')
test(verbing('swimming'), 'swimmingly')
test(verbing('do'), 'do')

"""
Explanation: E. verbing
Given a string, if its length is at least 3,
add 'ing' to its end.
Unless it already ends in 'ing', in which case
add 'ly' instead.
If the string length is less than 3, leave it unchanged.
Return the resulting string.
End of explanation
"""


def not_bad(s):
    # +++your code here+++
    return

test(not_bad('This movie is not so bad'), 'This movie is good')
test(not_bad('This dinner is not that bad!'), 'This dinner is good!')
test(not_bad('This tea is not hot'), 'This tea is not hot')
test(not_bad("It's bad yet not"), "It's bad yet not")

"""
Explanation: F. not_bad
Given a string, find the first appearance of the
substring 'not' and 'bad'. If the 'bad' follows
the 'not', replace the whole 'not'...'bad' substring
with 'good'.
Return the resulting string.
So 'This dinner is not that bad!' yields:
This dinner is good!
End of explanation
"""


def front_back(a, b):
    # +++your code here+++
    return

test(front_back('abcd', 'xy'), 'abxcdy')
test(front_back('abcde', 'xyz'), 'abcxydez')
test(front_back('Kitten', 'Donut'), 'KitDontenut')

"""
Explanation: G. front_back
Consider dividing a string into two halves.
If the length is even, the front and back halves are the same length.
If the length is odd, we'll say that the extra char goes in the front half.
e.g. 'abcde', the front half is 'abc', the back half 'de'.
Given 2 strings, a and b, return a string of the form
a-front + b-front + a-back + b-back
End of explanation
"""


