I was really bored today. Since I had nothing better to do and I have been meaning to attempt these exercises for a while, I thought why not spend some time. I know they are not top notch solutions.

## Exercise 3.3

Write a function named `right_justify` that takes a string named `s` as a parameter and prints the string with enough leading spaces so that the last letter of the string is in column 70 of the display.

### Solution

``````def right_justify(s):
lspace = 70-len(s)
s = ' '*lspace+s
return s

t='hello'
print right_justify(t)
``````

### Output

``````                                                                     hello
``````

## Exercise 3.5

Write a function that draws a grid like the following:

``````+ - - - - + - - - - +
|         |         |
|         |         |
|         |         |
|         |         |
+ - - - - + - - - - +
|         |         |
|         |         |
|         |         |
|         |         |
+ - - - - + - - - - +
``````

### Solution

``````def two_times(f):
f()
f()

def four_times(f):
two_times(f)
two_times(f)

def print_space_n_beam():
i=0
while(i<2):
print '|'+' '*8,
i=i+1

print '|'

def print_plus_n_hyphen():
i=0
while(i<2):
print '+'+' -'*4,
i=i+1

print '+'

print_plus_n_hyphen()
four_times(print_space_n_beam)
print_plus_n_hyphen()
four_times(print_space_n_beam)
print_plus_n_hyphen()
``````

## Exercise 5.1.1

Write a function named `check_fermat` that takes four parameters—`a`, `b`, `c` and `n`—and that checks to see if Fermat's theorem holds. If `n` is greater than 2 and it turns out to be true that `a``n` + `b``n` = `c``n`, the program should print, "Holy smokes, Fermat was wrong!" Otherwise the program should print, "No, that doesn't work."

### Solution

``````def check_fermat(a,b,c,n):
if n <= 2:
print "n has to greater than 2"

else:
if a**n+b**n == c**n:
print 'Holy smokes, Fermat was wrong!'

else:
print 'No, that doesn\'t work.'

check_fermat(3,5,3,3)
``````

### Output

``````No, that doesn't work.
``````

## Exercise 5.1.2

Write a function that prompts the user to input values for `a`, `b`, `c` and `n`, converts them to integers, and uses `check_fermat` to check whether they violate Fermat's theorem.

### Solution

``````def check_fermat(a,b,c,n):
if n <= 2:
print "n has to greater than 2"

else:
if a**n+b**n == c**n:
print 'Holy smokes, Fermat was wrong!'

else:
print 'No, that doesn\'t work.'

a = raw_input("a: ")
b = raw_input("b: ")
c = raw_input("c: ")
n = raw_input("n: ")
a,b,c,n = int(a),int(b),int(c),int(n)
check_fermat(a,b,c,n)
``````

## Exercise 5.2.1

Write a function named `is_triangle` that takes three integers as arguments, and that prints either "Yes" or "No," depending on whether you can or cannot form a triangle from sticks with the given lengths.

### Solution

``````def is_triangle(a,b,c):
if c == 0 or b == 0 or a == 0:
print "A side cannot be of zero length!"

else:
if c > a+b or b > c+a or a > b+c:
print "No"
else:
print "Yes"

is_triangle(1,2,3)
is_triangle(1,2,0)
is_triangle(1,2,6)
``````

### Output

``````Yes
A side cannot be of zero length!
No
``````

## Exercise 6.3

Write a function `is_between(x, y, z)` that returns `True` if `x = y = z` or `False` otherwise.

### Solution

``````def is_between(x,y,z):
return x <= y <= z

print is_between(1,2,3)
print is_between(1,3,2)
print is_between(3,2,1)
``````

### Output

``````True
False
False
``````

## Exercise 6.5

The Ackermann function, `A(m, n)`, is defined as

``````            ⎧ n+1   if  m = 0
⎪
A(m, n) =   ⎨ A(m−1, 1) if  m > 0  and  n = 0
⎪
⎩ A(m−1, A(m, n−1)) if  m > 0  and  n > 0.
``````

Write a function named `ack` that evaluates Ackerman’s function. Use your function to evaluate `ack(3, 4)`, which should be 125. What happens for larger values of `m` and `n`?

### Solution

``````def ack(m,n):
if m == 0:
return n+1

elif m > 0 and n == 0:
return ack(m-1,1)

elif m > 0 and n > 0:
return ack(m-1,ack(m,n-1))

print ack(3,4)
``````

### Output

125

Results for values of m,n from 0,0 to 4,4

``````ack(m,n)    Output
==================
ack(0,0)    1
ack(0,1)    2
ack(0,2)    3
ack(0,3)    4
ack(0,4)    5
ack(1,0)    2
ack(1,1)    3
ack(1,2)    4
ack(1,3)    5
ack(1,4)    6
ack(2,0)    3
ack(2,1)    5
ack(2,2)    7
ack(2,3)    9
ack(2,4)    11
ack(3,0)    5
ack(3,1)    13
ack(3,2)    29
ack(3,3)    61
ack(3,4)    125
ack(4,0)    13
ack(4,1)    max recursion depth exceeded
ack(4,2)    max recursion depth exceeded
ack(4,3)    max recursion depth exceeded
ack(4,4)    max recursion depth exceeded
``````

## Exercise 6.6.2

Write a function called `is_palindrome` that takes a string argument and returns `True` if it is a palindrome and `False` otherwise. Remember that you can use the built-in function `len` to check the length of a string.

### Solution

``````def is_palindrome(w):
if not isinstance(w, str):
return "ERROR: input is not a string."

elif len(w) > 2:
if w == w[-1]:
while len(w) > 2:
w = w[1:-1]
is_palindrome(w)

if len(w) == 1:
return True

else:
return False

else:
return "ERROR: input contains two or less characters."

print is_palindrome('aibohphobia')
print is_palindrome('definitely')
``````

## Output

``````True
False
``````

## Exercise 10.1

Write a function that takes a list of numbers and returns the cumulative sum; that is, a new list where the ith element is the sum of the first i+1 elements from the original list. For example, the cumulative sum of [1, 2, 3] is [1, 3, 6].

### Solution

``````def cumul_sum(t):
u=[]
s=0

for i in range(len(t)):
s += t[i]
u.append(s)

return u

lst = [1,2,3,4]
print cumul_sum(lst)
``````

### Output

``````[1,3,6,10]
``````

## Exercise 10.2

Write a function called chop that takes a list and modifies it, removing the first and last elements, and returns None. Then write a function called middle that takes a list and returns a new list that contains all but the first and last elements.

### Solution

``````def chop(t):
t[:] = t[1:-1]

def middle(t):
return t[1:-1]

lst = [1,'a',3,4,5,6,7,8,'b']

chop(lst)
print lst
print middle(lst)
``````

### Output

``````['a', 3, 4, 5, 6, 7, 8]
[3, 4, 5, 6, 7]
``````

## Exercise 10.3

Write a function called `is_sorted` that takes a list as a parameter and returns `True` if the list is sorted in ascending order and `False` otherwise. You can assume (as a precondition) that the elements of the list can be compared with the relational operators <, >, etc.

For example, `is_sorted([1,2,2])` should return `True` and is_sorted(['b','a']) should return False.

### Solution

``````def is_sorted(t):
return t < t

t1 = [1,2,3]
t2 = [5,4,3]
t3 = ['a','b']
t4 = ['z','t']

print is_sorted(t1)
print is_sorted(t2)
print is_sorted(t3)
print is_sorted(t4)
``````

### Output

``````True
False
True
False
``````