1 Gentle Introduction to Programming Session 6: Lists, Course Summary
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
1
Gentle Introduction to Programming
Session 6: Lists, Course Summary
2
Review• Sorting, searching and time-complexity analysis • Scala memory model• Guest lecture by Prof. Ronitt Rubinfeld• Object-oriented programming (OOP)
• Classes and Objects• Functional Objects (Rational Numbers example)
3
Todayהפתעה! (+ משובים) •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP (inheritance, hierarchy, polymorphism)
• Go home!
4
Object-Oriented Programming (OOP)
• Represent problem-domain entities using a computer language
• When building a software in a specific domain, describe the different components of the domain as types and variables
• Thus we can take another step up in abstraction
5
Class as a BlueprintA class is a blueprint of objects
6
Car Example
• Members: 4 wheels, steering wheel, horn, color,…
• Every car instance has its own
• Methods: drive, turn left, honk, repaint,…
• Constructors: Car(String color), Car(Array[Wheels], Engine,…), …
7
Rational Numbers
• A ration number is a number that can be expressed as a ration n/d (n,d integers, d not 0)
• Examples: 1/2, 2/3, 112/239, 2/1
• Not an approximation
8
Specification• Add, subtract, multiply, divide
• println should work smoothly• Immutable (result of an operation is a new rational number)
• It should feel like native language support
9
Constructing a Rational
• How client programmer will create a new Rational object?
Class parameters
10
Constructing a Rational• The Scala compiler will compile any code placed in
the class body, which isn’t part of a field or a method definition, into the primary constructor
?
11
Reimplementing toString
• toString method• A more useful implementation of toString would
print out the values of the Rational’s numerator and denominator
• override the default implementation
12
Usage
• Now we can remove the debug println…
13
Checking Preconditions
• Ensure the data is valid when the object is constructed
• Use require
14
Define “add” Method
• Immutable• Define add:
15
Add Fields• n, d are in scope in the add method• Access then only on the object on which add
was invoked
16
Test Add, Access Fields
17
Self Reference (this)
• Define method lessThan:
• Define method max:
18
Auxiliary Constructors• Constructors other then the primary
• Example: a rational number with a denominator of 1 (e.g., 5/1 5)
• We would like to do: new Rational(5)• Auxiliary constructor first action: invoke
another constructor of the same class
• The primary constructor is thus the single point of entry of a class
19
Revised Rational
20
Private Fields and Methods
• 66/42 = 11/7• To normalize divide the numerator and
denominator by their greatest common divisor (gcd)• gcd(66,42) = 6 (66/6)/(42/6) = 11/7• No need for Rational clients to be aware of this• Encapsulation
21
Off Topic: Calculate gcd• gcd(a,b) = g
• a = n * g• b = m * g• gcd(n,m)=1(otherwise g is not the gcd)• a = t * b + r = t * m * g + r g is a divisor of r
• gcd(a,b) = gcd(b,a%b)• The Euclidean algorithm: repeat iteratively:
if (b == 0) return aelse repeat using a b, b a%b
• http://en.wikipedia.org/wiki/Euclidean_algorithm
22
Correctness• Example:
gcd(40,24) gcd(24,16) gcd(16,8) gcd(8,0) 8
• Prove: g = gcd(a,b) = gcd(b,a%b)= g1• g1 is a divisor of a ( g1 ≤ g)• There is no larger divisor of a ( g1 ≥ g)
• ≤ : a = t * b + r a = t * h * g1 + v * g1 g1 is a divisor of a
• ≥ : assume g > g1 a = t * b + r g is a divisor of b and r contradiction
23
Implementation
24
Revised Rational
25
Defining Operators• Why not use natural arithmetic operators?
• Replace add by the usual mathematical symbol
• Operator precedence will be kept
• All operations are method calls
26
Revised Rational
27
Usage
28
Method Overloading• Now we can add and multiply rational numbers!• What about mixed arithmetic?
• r * 2 won’t work • r * new Rational(2) is not nice
• Add new methods for mixed addition and multiplication
• Method overloading• The compiler picks the correct overloaded
method
29
Usage
• The * method invoked is determined in each case by the type of the right operand
30
Revised Rational
31
Implicit Conversions
• 2 * r 2.*(r) method call on 2 (Int) Int class contains no multiplication method that takes a Rational argument
• Create an implicit conversion that automatically converts integers to rational numbers when needed
32
Companion Object
33
Revised Rational
• Define implicit conversion in Rational.scala, after defining object Rational
34
In Eclipse
• In Rational.scala:• Companion object
(object Rational)• Rational class (class
Rational)
• Place the main method in another file
35
Summary• Customize classes so that they are natural
to use• fields, methods, primary constructor• Method overriding• Self reference (this)• Define several constructors• Encapsulation• Define operators as method• Method overloading• Implicit conversions, companion object
36
Complete HomeWork• Implement class Complex so it is natural to use
complex numbers• Examples:
37
Todayהפתעה! )+ משובים( •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP (inheritance, hierarchy, polymorphism)
• Go home!
38
Course Description
This course will provide a gentle introduction to programming
using Scala for highly motivated students with little or no prior experience in programming
39
Objective
Bridge the gap for students without prior programming knowledge
40
Course Description
Lectures will be interactive featuring in-class exercises with lots of support
You are expected to work hard!
41
Course PlanSession Material
1 Basic concepts in CS and programming, basic Scala
2 Basic Scala (cont.), Functions
3 Recursion
4 Arrays
5 Sort, Complexity, Object Oriented Programming
6 Summary, Lists, more OOP
42
Why Scala?
• Semester A: Scheme• Semester B: Java• Scala language has some features similar to
Scheme and some to Java• Scala is cool!
43
Summary
• General introduction to CS and programming• Basic Scala• Development tools:
• Interpreter• Eclipse (+ debugger)
• Compiler, Interpreter
44
Compiler
45
Interpreter
46
How it works in Scala
47
Higher Order Functions
101
,1
2
oddk
k
100
1k
k
100
1
2
k
k
49
Recursion and Efficiency
• The recursive form, however elegant, may be much less efficient
• The number of redundant calls grow exponentially!
Fib(5)
Fib(4) Fib(3)
Fib(3) Fib(2) Fib(2) Fib(1)
Fib(2)
Fib(1)
Fib(6)
Fib(4)
50
Recursive Vs. Iterative Process
Operation pending
No pending operations
51
“Tail” Recursion in Scala
• Scala compiler translate tail-recursion to iterative execution
• Thus, the functions-stack is not growing
52
Arrays
• Array: sequential block of memory that holds variables of the same type
• Array can be declared for any type
• The array variable itself holds the address in memory of beginning of sequence
• foreach, filter, map,…
0 1 2 3 4 5 6 7 8 9
s
……
53
Arrays - Example
54
Stack, Queue
• Stack – מחסנית• Applications: Function’s stack• Implementation ideas
• Queue – תור, First In First Out (FIFO)• Applications: Scheduling, typing• Implementation idea• Cyclic Queue
55
Binary Search• Input:
• A sorted array of integers A• An integer query q
• Output:• The index of q in A if q is a member of A• -1 otherwise
• Algorithm:• Check the middle element of A• If it is equal to q, return its index• If it is >= q, search for q in A[0,…,middle-1]• If it is < q, search for q in A[middle+1,...,end]
56
Time Complexity of BS• Worst case analysis
• Size of the inspected array:
n n/2 n/4 ….. 1
• Each step is very fast (a small constant number of operations)
• There are log2(n) such steps
• So it takes ~ log2(n) steps per search
• Much faster then ~ n
57
Bubble Sort Time ComplexityArray of size n
n iterationsi iterations
constant
(n-1 + n-2 + n-3 + …. + 1) * const ~ ½ * n2
58
Marge Sort• If the array is of length 0 or 1, then it is already sorted. Otherwise:
• Divide the unsorted array into two sub-arrays of about half the size
• Sort each sub-array recursively by re-applying merge sort
• Merge the two sub-arrays back into one sorted array
n + 2 * (n/2) + 22 * n/22 + 23 * n/23 + … + 2log(n) * n/2log(n) =
n + n + … + n = n * log(n)
log(n)
59
Bucket Sort• Linear-time sorting algorithm! • But: restrictions on data – bounded
integers…
60
Quick Sort
• Want to hear about it?
• http://en.wikipedia.org/wiki/Quicksort
61
Scala Memory Model
• Passing arguments to functions, local names
• Objects in memory
• Stack, Heap, Garbage collection
62
Object-Oriented Programming
• Represent problem-domain entities using a computer language
• Abstraction
• Classes as blueprint / data-types• Scala API (and Java’s)
63
Rational Numbers Example• Customize classes so that they are natural
to use• fields, methods, primary constructor• Method overriding• Self reference (this)• Define several constructors• Encapsulation• Define operators as method• Method overloading• Implicit conversions, companion object
64
Guest Lectures
• (soon to be Dr.) Ohad Barzilay• Oded Magger• Prof. Benny Chor• Prof. Ronitt Rubinfeld
65
Todayהפתעה! )+ משובים( •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP (inheritance, hierarchy, polymorphism)
• Go home!
66
Programming in Scala
Chapter 16: Working with Lists Chapter 22: Implementing Lists
67
Problems with Arrays
• Limited in space (static): the size of an array is defined as it is created
• Costly to perform dynamic operations (e.g., add an element)
68
Linked Lists• Built out of links, each link holds:
• Data• Pointer to the next link (tail)
• Pointer to the first element (head)
69
Linked Lists (cont.)• Infinite loop? (linklinklink….)
• Nil – the empty list
• The elements have the same type
70
Lists Vs. Arrays
List Array
Initialization / memory
Economical Wasteful
Insert element Fast Slow
Remove element Fast Slow
Direct access No direct access Direct access
Traverse Linear Linear
71
Functionality• initiate
• isEmpty
• length
• add element
• remove element
• append
• reverse
72
Lists in Scala• List class have a type parameter T (similar
to Arrays…)•
• List operations are based on three basic methods:• isEmpty : Boolean – true iff the list is empty• head : T – first element in list• tail : List[T] – a list consisting of the elements
except the first
73
Initiating Lists
74
Constructing Lists• All lists are build from two fundamental
building blocks:• Nil• :: (cons)
75
Example: Insertion Sort
76
Implementation of ::
77
Implementation of: length, map
78
Concatenating Lists
79
Reverse a List
def rev[T](xs : List[T]) = {
if (xs.isEmpty)
xs
else
rev(xs.tail):::List(xs.head)
}
Complexity?
80
Higher Order Methods
• map• filter• partition• foreach• And more
81
Example - map
map(_+1) map((x:Int)=>x+1)
82
Example – filter, partition
83
Example – filter, partition
84
Example – foreach
85
Example – sort
86
Other Data Structures• Trees• Maps
87
Example
var capital = Map( "US" "Washington", "France" "paris", "Japan" "tokyo" )
capital += ( "Russia" "Moskow" )
for ( (country, city) capital ) capital += ( country city.capitalize )
assert ( capital("Japan") == "Tokyo" )
88
Pattern Matching in Scala
Here's a a set of definitions describing binary trees:
And here's an inorder traversal of binary trees:
This design keeps• purity: all cases are classes or objects• extensibility: you can define more cases elsewhere• encapsulation: only parameters of case classes are revealed
abstract class Tree[T]
case object Empty extends Tree
case class Binary(elem: T, left: Tree[T], right: Tree[T]) extends Tree
def inOrder [T] ( t: Tree[T] ): List[T] = t match { case Empty => List() case Binary(e, l, r) => inOrder(l) ::: List(e) ::: inOrder(r)}
The case modifier of an object or class means you can pattern match on it
89
Todayהפתעה! )+ משובים( •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP (inheritance, hierarchy, polymorphism)
• Go home!
90
More OOP (only talking…)
• Inheritance
• Class Hierarchy
• Polymorphism
91
Scala Hierarchy
92
Todayהפתעה! )+ משובים( •• Finish Functional Objects• Guest lecture by Prof. Ronitt Rubinfeld 10:10 • Course Summary ++• Lists• More OOP )inheritance, hierarchy, polymorphism(
• Go home!
93
Thanks / References• Guest lecturers: Ohad, Oded, Benny,
Amiram, Ronitt
• Administration: Avia, Pnina
• System: Ami, Eitan, Boaz, Eddie
• Initiator: Dr. Lior Wolf
• References:• “Programming in Scala”• Jackie Assa• Scheme Course• Don’t remember
94
חג שמח!תהנו משארית
החופשה!
Related Documents
