NPTEL MOOC
PROGRAMMING,
DATA STRUCTURES AND
ALGORITHMS IN PYTHON
Week 1, Lecture 1
Madhavan Mukund, Chennai Mathematical Institute
http://www.cmi.ac.in/~madhavan
Algorithms, programming
Algorithm: how to systematically perform a task
Write down as a sequence of steps
“Recipe”, or program
Programming language describes the steps
What is a step? Degrees of detail
“Arrange the chairs” vs “Make 8 rows with 10
chairs in each row”
Our focus
Algorithms that manipulate information
Compute numerical functions — f(x,y) = xy
Reorganize data — arrange in ascending order
Optimization — find the shortest route
And more …
Solve Sudoku, play chess, correct spelling …
Greatest common divisor
gcd(m,n)
Largest k such that k divides m and k divides n
gcd(8,12) = 4
gcd(18,25) = 1
1 divides every number
At least one common divisor for every m, n
Computing gcd(m,n)
List out factors of m
List out factors of n
Report the largest number that appears on both lists
Is this a valid algorithm?
Finite presentation of the “recipe”
Terminates after a finite number of steps
Computing gcd(m,n)
Factors of m must be between 1 and m
Test each number in this range
If it divides m without a remainder, add it to list of
factors
Example: gcd(14,63)
Factors of 14
1 2 3 4 5 6
1 7
2 8 14
7 9 10 11 12 13 14
Computing gcd(14,63)
Factors of 14 1 2 7 14
Factors of 63 1 2
3 3
7 …
9 21
7 63
… 9 … 21 … 63
Construct list of common factors
For each factor of 14, check if it is a factor of 63
1 7
Return largest factor in this list: 7
An algorithm for gcd(m,n)
Use fm, fn for list of factors of m, n, respectively
For each i from 1 to m, add i to fm if i divides m
For each j from 1 to n, add j to fn if j divides n
Use cf for list of common factors
For each f in fm, add f to cf if f also appears in fn
Return largest (rightmost) value in cf
Our first Python program
def gcd(m,n):
fm = []
for i in range(1,m+1):
if (m%i) == 0:
fm.append(i)
fn = []
for j in range(1,n+1):
if (n%j) == 0:
fn.append(j)
cf = []
for f in fm:
if f in fn:
cf.append(f)
return(cf[-1])
Some points to note
Use names to remember intermediate values
m, n, fm, fn, cf, i, j, f
Values can be single items or collections
m, n, i, j, f are single numbers
fm, fn, cf are lists of numbers
Assign values to names
Explicitly, fn = [], and implicitly, for f in cf:
Update them, fn.append(i)
Some points to note …
Program is a sequence of steps
Some steps are repeated
Do the same thing for each item in a list
Some steps are executed conditionally
Do something if a value meets some
requirement
NPTEL MOOC
PROGRAMMING,
DATA STRUCTURES AND
ALGORITHMS IN PYTHON
Week 1, Lecture 2
Madhavan Mukund, Chennai Mathematical Institute
http://www.cmi.ac.in/~madhavan
An algorithm for gcd(m,n)
Use fm, fn for list of factors of m, n, respectively
For each i from 1 to m, add i to fm if i divides m
For each j from 1 to n, add j to fn if j divides n
Use cf for list of common factors
For each f in fm, add f to cf if f also appears in fn
Return largest (rightmost) value in cf
Can we do better?
We scan from 1 to m to compute fm and again from
1 to n to compute fn
Why not a single scan from 1 to max(m,n)?
For each i in 1 to max(m,n), add i to fm if i
divides m and add i to fn if i divides n
Even better?
Why compute two lists and then compare them to
compute common factors cf? Do it in one shot.
For each i in 1 to max(m,n), if i divides m and i
also divides n, then add i to cf
Actually, any common factor must be less than
min(m,n)
For each i in 1 to min(m,n), if i divides m and i
also divides n, then add i to cf
A shorter Python program
def gcd(m,n):
cf = []
for i in range(1,min(m,n)+1):
if (m%i) == 0 and (n%i) == 0:
cf.append(i)
return(cf[-1])
Do we need lists at all?
We only need the largest common factor
1 will always be a common factor
Each time we find a larger common factor, discard
the previous one
Remember the largest common factor seen so far
and return it
mrcf — most recent common factor
No lists!
def gcd(m,n):
for i in range(1,min(m,n)+1):
if (m%i) == 0 and (n%i) == 0:
mrcf = i
return(mrcf)
Scan backwards?
To find the largest common factor, start at the end
and work backwards
Let i run from min(m,n) to 1
First common factor that we find will be gcd!
No lists!
def gcd(m,n):
i = min(m,n)
while i > 0:
if (m%i) == 0 and (n%i) == 0:
return(i)
else:
i = i-1
A new kind of repetition
while condition:
step 1
step 2
. . .
step k
Don’t know in advance how many times we will
repeat the steps
Should be careful to ensure the loop terminates—
eventually the condition should become false!
Summary
With a little thought, we have dramatically
simplified our naive algorithm
Though the newer versions are simpler, they still
take time proportional to the values m and n
A much more efficient approach is possible
NPTEL MOOC
PROGRAMMING,
DATA STRUCTURES AND
ALGORITHMS IN PYTHON
Week 1, Lecture 3
Madhavan Mukund, Chennai Mathematical Institute
http://www.cmi.ac.in/~madhavan
Algorithm for gcd(m,n)
To find the largest common factor, start at the end
and work backwards
Let i run from min(m,n) to 1
First common factor that we find will be gcd!
Euclid’s algorithm
Suppose d divides both m and n, and m > n
Then m = ad, n = bd
So m-n = ad - bd = (a-b)d
d divides m-n as well!
So gcd(m,n) = gcd(n,m-n)
Euclid’s algorithm
Consider gcd(m,n) with m > n
If n divides m, return n
Otherwise, compute gcd(n,m-n) and return that
value
Euclid’s algorithm
def gcd(m,n):
# Assume m >= n
if m < n:
(m,n) = (n,m)
if (m%n) == 0:
return(n)
else:
diff = m-n
# diff > n? Possible!
return(gcd(max(n,diff),min(n,diff))
Euclid’s algorithm, again
def gcd(m,n):
if m < n: # Assume m >= n
(m,n) = (n,m)
while (m%n) != 0:
diff = m-n
# diff > n? Possible!
(m,n) = (max(n,diff),min(n,diff))
return(n)
Even better
Suppose n does not divide m
Then m = qn + r, where q is the quotient, r is the
remainder when we divide m by n
Assume d divides both m and n
Then m = ad, n = bd
So ad = q(bd) + r
It follows that r = cd, so d divides r as well
Euclid’s algorithm
Consider gcd(m,n) with m > n
If n divides m, return n
Otherwise, let r = m%n
Return gcd(n,r)
Euclid’s algorithm
def gcd(m,n):
if m < n: # Assume m >= n
(m,n) = (n,m)
if (m%n) == 0:
return(n)
else:
return(gcd(n,m%n)) # m%n < n, always!
Euclid’s algorithm, revisited
def gcd(m,n):
if m < n: # Assume m >= n
(m,n) = (n,m)
while (m%n) != 0:
(m,n) = (n,m%n) # m%n < n, always!
return(n)
Efficiency
Can show that the second version of Euclid’s
algorithm takes time proportional to the number of
digits in m
If m is 1 billion (109), the naive algorithm takes
billions of steps, but this algorithm takes tens of
steps
NPTEL MOOC
PROGRAMMING,
DATA STRUCTURES AND
ALGORITHMS IN PYTHON
Week 1, Lecture 4
Madhavan Mukund, Chennai Mathematical Institute
http://www.cmi.ac.in/~madhavan
Installing Python
Python is available on all platforms: Linux, MacOS
and Windows
Two main flavours of Python
Python 2.7
Python 3+ (currently 3.5.x)
We will work with Python 3+
Python 2.7 vs Python 3
Python 2.7 is a “static” older version
Many libraries for scientific and statistical
computing are still in Python 2.7, hence still
“alive”
Python 3 is mostly identical to Python 2.7
Designed to better incorporate new features
Will highlight some differences as we go along
Downloading Python 3.5
Any Python 3 version should be fine, but the latest
is 3.5.x
On Linux, it should normally be installed by
default, else use the package manager
For MacOS and Windows, download and install
from https://www.python.org/downloads/release/
python-350/
If you have problems installing Python, search
online or ask someone!
Interpreters vs compilers
Programming languages are “high level”, for
humans to understand
Computers need “lower level” instructions
Compiler: Translates high level programming
language to machine level instructions, generates
“executable” code
Interpreter: Itself a program that runs and directly
“understands” high level programming language
Python interpreter
Python is basically an interpreted language
Load the Python interpreter
Send Python commands to the interpreter to be
executed
Easy to interactively explore language features
Can load complex programs from files
>>> from filename import *
Practical demo
Some resources
The online Python tutorial is a good place to start:
https://docs.python.org/3/tutorial/index.html
Here are some books, again available online:
Dive into Python 3, Mark Pilgrim
http://www.diveintopython3.net/
Think Python, 2nd Edition, Allen B. Downey
http://greenteapress.com/wp/think-python-2e/
Learning programming
Programming cannot be learnt theoretically
Must write and execute your code to fully
appreciate the subject
Python syntax is light and is relatively easy to learn
Go for it!
