SAMPLE written problems in Python for midterm in PSCB57
_________________________________________________________________________
During preparation we encourage the use of computer, to check if your 
solution works correctly. In the exam the computer will not be used, 
but the good thing is that we will not subtract many points for trivial mistakes
like typos, as opposed to essential algorithmic and coding mistakes, such as disregarding proper indentation, using meaningless lines of code such as: 
0 < x < 1, or confused use of lists in places where only arrays can be used, 
for instance 3*array_name has a completely different result than 3*list_name,
even if they initially hold the same numbers.  
_________________________________________________________________________

Remember that your program(s) need to be richly commented in actual exam.
_________________________________________________________________________


Problem 1.

Print a three-column table of conversion of meters to miles (statute US miles) 
and to nautical miles. The first column should be meters = 0,100,200,300,...
10000. The table should have a header stating what the columns mean in words:
" meters    mi    nm".


Problem 2.

Write an interactive program that asks for the weight in ounces and 
returns the corresponding number of grams. The program needs to detect
the wrong negative input, and ask again. It should not print irrelevant 
distant decimals - round the result to reasonable accuracy before printing. 

For more experienced Pythonistas: find how many digits the user has entered,
limit the output to the same number of digits + 1.


Problem 3. 

Input from keyboard a floating point value of V, prompted by a message that 
it is expected to be in units of m/s. 

Create a table of angles alpha in degrees (from 1 to 90) and the corresponding 
distance (range) that a stone  will land at, on an planet identical 
to Earth, except for the fact that it has no atmosphere. Stone is thrown 
at initial speed V, and the angle w.r.t. horizon given in the table.
In the loop creating the table, detect and store the maximum range and the 
angle, and print them with some explanation immediately under the table.  



Problem 4. 

Write a program that reads from the keyboard integers N and M, makes sure that
 0<M<N, and then evaluates the number of combinations of M items out of N 
possible items, or the mathematical symbol (N M) 
[this symbol is pronounced "N choose M" & should be written vertically, 
not horizontally...]

(N M) := N! / (M! (N-M)!)

The program should not use any standard library functions. Evaluate the 
expression by iteration in a loop. 

Comment: This way of calculation also often extends the range of N and M values
that can be used successfully. For example: take N=200 & M=100. While 
100! can be computed with Numpy function factorial(), it will not work for
200! The result is too large for Numpy, it exceeds the allowed variables in 
the language used by source code of Numpy.

Meanwhile, 200!/100!/100! can be evaluated as (101*102*....*200)/(1*2*...100) = 
(101/1)*(102/2)*...*(199/99)*(200/100) without any overflow problem. 



Problem 5. 

Write the solution of the quadratic equation 
 a x**2 + b x + c  = 0
on paper and implement the formulae in Python. 
Print a range of result, allowing real or complex solutions, for a=2, b=3/2 and 
c= 0.1,0.2,0.3,....,5.0. 
(in a listing with 50 rows stating the value of c and the solution(s) obtained
by the algorithm. 
 

Problem 6. 

Create in a Numpy array M the table of multiplication of numbers 
0,1,2,....9. Print it as a 10x10 table of integers, which looks good, 
i.e., has columns that line up neatly. 
In one line of Python code, extract a section of array M that contains 
a multiplication table of integers from 0 to 4, calling it M4. 



Problem 7. 

Use M4 from problem 6 to print a table of values of exp(-M4) 
[exp(- each element in M4)] as a 5x5 table of floats in the engineering
format like for instance 123.28, with two digits after the decimal point. 



Problem 8. 

A random number generated by 
x = np.random.rand() 
is uniformly distributed between 0 and 1, and contains lots of random 
decimals in its decimal expansion. 
Display those digit. Write a short code to extract and separately print 
pairs of digits. Example output should look like:

x = 0.1234875691234587
consists of:
12
34
87
56
91
23
45
87

(Those numbers could be used as random numbers in range 0..99. If you only need 
a range from 0 to 9, one good random number will be able to generate about 16 
such random numbers, and if {0,1} values are required, then )


Problem 9.

Write a code to perform an integer (or rather, whole number)
random walk starting from value x=0 and increasing or decreasing that number in 
every step by +-1, using numpy random number generator 
r = np.ranmod.choice([-1,1])
which randomly chooses between -1 and 1. 

Write a code that performs 100 such random walks and display in 100 rows 
the numer of the walk and its ending position. 
 

Problem 10. 

Modify the algorithm from problem 9, to perform N=50000 random walks up to 
1 million steps long (without displaying anything), breaking off walks 
if and when they leave the interval -10 < x < 10, at step number n. Store n's.  

Make a histogram of the length n of those N walks, and comment (if actually 
done on a computer) whether the distribution looks like a normal distribution 
or not. 


Problem 11. 

Do the same for a N 2D walks on the square grid of integers (x,y) ranging
from -10 to +10 each. Stop each walk when it exceeds the Cartesian distance
10 (i.e. when x*x+y*y > 10**2) from the starting (0,0) point. 

Problem 12. 

Write a code to find by the simplest method possible the area under 
the curve 
y = sin(x)**2/(1 + (7/8)*cos(x) )**3
from x = 0 to x = pi = 3.1415...,
by dividing the x range into N=100000 intervals. 


Problem 13. 

Input from a file the two-column data representing an arbitrary number N of
(x,y) pairs. The program should treat each (x,y) pair as a vertex position 
of a planar polygon. Compute the area of an arbitrary N-lateral polygon using:

A = (1/2) *( x1*y2-x2*y1 + x2*y3-x3*y2 + x3*y4-x4*y3 + ...+ 
	x[N-1]*y[N]-x[N]*y[N-1] ) 
Test the program on some simple triangle and a simple rectangle of your choice, 
whose area is very easy to calculate, e.g. because they contain one right angle
(90 degrees).   


Problem 14. 

The rules for determining whether or not a year is a leap year are:
(i) Any year that is divisible by 400 is a leap year.
(ii) Of the remaining years, any year that is divisible by 100 is not a leap year.
(iii) Of the remaining years, any year that is divisible by 4 is a leap year.
(iv) All other years are not leap years.
Write a program that lists all the years in the current century and for each 
calls a function called leap(year) that returns the value 0 or 1, depending on 
whether year is a leap year (1) or not (0), and displays the result as 
two columns, the first column the years, the second containing either a blank 
for non-leap years, or the text "leap year" for leap years.   


Problem 15.

The value of π can be approximated by the following infinite series:
π ≈ 3+ 4*[ 1/(2×3×4) + 1/(4×5×6) + 1/(6×7×8) + 1/(8×9×10) +  1/(10×11×12) +...]

Write a program that displays the first 16 consecutive approximations of π. 
If N is the number of terms in square brackets, what is the order of convergence, 
that is the asymptotic value of constant q in:  

 |π_approx - π_true| = const./N**q

without doing any graphics. 

Hint: Without actually doing the plot, *imagine* doing a log-log plot of the 
consecutive approximations for N=1,2,3,...15, and print the slope that would 
exist on such graph between the third or forth and the N-th point (for N>4). 
Use the numpy's  np.log10() function for the calculation.