# Attempt at solving Think Python exercises

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[0] == 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[0] < t[1]
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
```