Modify it to print the line 100 times (You want to do a loop, check python’s documentation)

One possible solution, using a “while loop”:

n = 1
while n <= 100:
    print("All work and no play makes Jack a dull boy")
    n = n + 1

Another, using a “for loop” and the function range:

for _ in range(100):
    print("All work and no play makes Jack a dull boy")

Modify the program to randomly select a name in the list (John, Jack, Paul, Tim) at each line.

(Hint: import the module “random”)

import random

NAMES = ('John', 'Jack', 'Paul', 'Tim')

for _ in range(100):
    name = random.choice(NAMES)
    print("All work and no play makes " + name +  " a dull boy")

It computes the sum of all integers between 1 and n.

Remark: Freidriech Gauss would probably have written:

def sum2(n):
    """ returns the sum of integers between 1 and n """
    return n * (n + 1) / 2

Answer: 5, 8, 11, 255

4. Write a function that, given the binary representation of a number as a string of ‘0’ and ‘1’, returns its value as a integer.

def todec(s):
    """ convert a string of 0 and 1 representing a binary number into an integer """
    n = 0
    for i in s:
        n = n * 2 + int(i)
    return n

for i in ['101', '1000', '1011', '11111111']:
    print(todec(i))
<<<<<<< HEAD:06_Representation_of_numbers_images_text/representing_numbers_images_text.md

======= ``` #endif >>>>>>> 56025cfc85e9a40663e452f055225e216a22239a:06a_Representation_of_numbers_images_text/representing_numbers_images_text.md

5. Now we will go in the other direction: Our aim is to write a program that, given a number (in decimal), computes its binary representation.

If you have an idea how to program it, please proceed. If not, we propose that you follow the following steps:

6. Study the program below. Execute it with various values of the variable num. Do you understand the last line? Do you see a limitation of this program?

num = 143
d3 = int(num/1000) % 10 # thousands
d2 = int(num/100)  % 10 # hundreds
d1 = int(num/10)   % 10 # dec
d0 =  num % 10
print(str(d3) + str(d2) + str(d1) + str(d0))

7. Adapt the above program to print the binary representation of num

<<<<<<< HEAD:06_Representation_of_numbers_images_text/representing_numbers_images_text.md . . .

python ======= #ifdef ANSWERSpython >>>>>>> 56025cfc85e9a40663e452f055225e216a22239a:06a_Representation_of_numbers_images_text/representing_numbers_images_text.md num = 17 b0 = num % 2 b1 = int(num/2) % 2 b2 = int(num/4) % 2 b3 = int(num/8) % 2 b4 = int(num/16) % 2 b5 = int(num/32) % 2 b6 = int(num/64) % 2 b7 = int(num/128) % 2 b8 = int(num/256) % 2 print(str(b8) + str(b7) + str(b6) + str(b5) + str(b4) + str(b3) + str(b2) + str(b1) + str(b0)) ```

8. Modify the above program to print the binary representations of every number between 0 and 255.

<<<<<<< HEAD:06_Representation_of_numbers_images_text/representing_numbers_images_text.md . . .

python ======= #ifdef ANSWERSpython >>>>>>> 56025cfc85e9a40663e452f055225e216a22239a:06a_Representation_of_numbers_images_text/representing_numbers_images_text.md def tobin(num): b8 = int(num/256) % 2 b7 = int(num/128) % 2 b6 = int(num/64) % 2 b5 = int(num/32) % 2 b4 = int(num/16) % 2 b3 = int(num/8) % 2 b2 = int(num/4) % 2 b1 = int(num/2) % 2 b0 = num % 2 return (str(b8) + str(b7) + str(b6) + str(b5) + str(b4) + str(b3) + str(b2) + str(b1) + str(b0))

for n in range(256): print(n, tobin(n))

```

9. (Advanced) Write an improved version that uses a loop and does not have a limitation in size.

def binary(n):
    if n==0:
        return "0"
    s = ""
    while n > 0:
        b = str(n % 2)
        s = b + s
        n = n / 2
    return s

10. Study the following code. Do you understand why it works?

def binary(num):
    if num == 0:
        return "0"
    if num == 1:
        return "1"
    return(binary(int(num /2)) + binary(num % 2))

print(binary(1234))

Answer: It is a recursive function which calls itself. See http://en.wikipedia.org/wiki/Recursion_%28computer_science%29

Remark: measures of memory size

• 1 byte = 8 bits
• 1 Kilobyte (KB) = 1024 bytes
• 1 Megabyte (MB) = 1024 kbytes = 1048576 bytes
• 1 Gigabytes (GB) = 1024 Mbytes
• Terabyte, Petabyte, Exabyte…

Exercice (advanced): Write a function that return the hexadecimal representation (base 16) of a number.

To go further:

• If you want to know how negative integer numbers are represented, see http://en.wikipedia.org/wiki/Two%27s_complement

• To understand how real numbers are encoded, read What Every Programmer Should Know About Floating-Point Arithmetic and https://docs.python.org/2/tutorial/floatingpoint.html#tut-fp-issues

For example, if you name is ‘ZOE’, you would type:

print(chr(90)+chr(79)+chr(69))

def spot_nsa(filename):
    f = file(filename)
    o = f.read()
    lines = o.split("\n")
    found = False
    for l in lines:
        if "NSA" in l.split(" "):
            found = True
            break
    return found

Answer: 1024*768/8/1024=96 KB

15. Execute the follwoing code (it requires the modules numpy and matplotlib).

import numpy as np
import matplotlib.pyplot as plt

a = np.array([[0, 0, 0, 0, 0, 0, 0],
              [0, 0, 1, 1, 1, 0, 0],
              [0, 0, 1, 1, 1, 0, 0],
              [0, 0, 1, 1, 1, 0, 0],
              [0, 0, 1, 1, 1, 0, 0],
              [0, 0, 1, 1, 1, 0, 0],
              [0, 0, 0, 0, 0, 0, 0]])
plt.imshow(a, cmap=plt.cm.gray, interpolation='nearest')
plt.show()

Numpy’s arrays are a new type of object. There are similar to lists, but optimised for mathematical computations. Notably, they can be multidimensional (i.e. you can use a[i,j] notation). You can learn more about arrays in the documents http://www.pallier.org/cours/AIP2013/python4science.pdf and http://wiki.scipy.org/Tentative_NumPy_Tutorial.

16. Exercice:

1. Create a cross.
2. create a 200x200 bitmap:
   1. add a diagonal
   2. make two crosses imitating the British Flag

a = np.zeros((200,200))
for i in range(200):
    a[i, i] = 1
plt.imshow(a, cmap=plt.cm.gray, interpolation='nearest')
plt.show()
a[0:200:2,] = 1
plt.imshow(a, cmap=plt.cm.gray, interpolation='nearest')
plt.show()