1

Gentle Introduction to Programming

Session 4: Arrays

2

Review• Review on Functions

• Higher order functions• Recursion

• Solving big instances using the solution to smaller instances• Solving directly the base cases

• Tower of Hanoi• Recursion and efficiency (Fibonacci)• Importance of correct base-cases (Odd-Even)

3

Today• Home work review • Recursive vs. Iterative • Arrays

• Arrays in memory• Initialization and usage• foreach, filter • Arrays as functions arguments• Multi-dimensional arrays• References to array

• Sorting, searching and time-complexity analysis• Binary search• Bubble sort, Merge sort

• Home work

4

Exercise 1

• Write a program that receives two non-negative integers and computes their product recursively

• Hint: Notice that the product a*b is actually a+a+…+a (b times). How does this help us define the problem recursively?

5

SolutionProduct.scala

6

Exercise 2

• Given the following iterative version of sum-of-digits calculation

Write the recursive definition

7

SolutionSumDigits.scala

8

Exercise 3

• Write a function that simulates print on positive integers

• The function should print one digit at time• Example:

• printRec(1234) 1234

9

SolutionPrint.scala

10

Today• Home work review • Recursive vs. Iterative • Arrays

• Arrays in memory• Initialization and usage• foreach, filter • Arrays as functions arguments• Multi-dimensional arrays• References to array

• Sorting, searching and time-complexity analysis• Binary search• Bubble sort, Merge sort

• Home work

1111

Compute ab Iteratively

• Operationally:

• Halting condition:

product product * a

counter counter - 1

counter = 0

ab = a2 *a*…*a = a3 *…*a• Which is:

ab = a * a * a*…*a

b

12

Compute ab Iteratively

13

Compute ab (Recursive Approach)

• Recursive call: ab = a * a(b-1)

• Base case: a0 = 1

14

Compute ab (Iterative Approach)

How then, do the two procedures differ?

15

Recursive Process

powRec(3,4)

3 * powRec(3,3)

3 * (3 * powRec(3,2))

3 * (3 * (3 * powRec(3,1)))

3 * (3 * (3 * (3 * powRec(3,0))))

3 * (3 * (3 * (3 * 1)))

3 * (3 * (3 * 3))

3 * (3 * 9)

a * 27

81

16

Iterative Process

powTailRec(3,4)

pow1(3,4,1)

pow1(3,3,3)

pow1(3,2,9)

pow1(3,1,27)

pow1(3,0,81)

81

17

powRec(3,4)

3 * powRec(3,3)

3 * (3 * powRec(3,2))

3 * (3 * (3 * powRec(3,1)))

3 * (3 * (3 * (3 * powRec(3,0))))

3 * (3 * (3 * (3 * 1)))

3 * (3 * (3 * 3))

3 * (3 * 9)

a * 27

81

The DifferenceGrowing amount of space

Constant amount of space

powTailRec(3,4)

pow1(3,4,1)

pow1(3,3,3)

pow1(3,2,9)

pow1(3,1,27)

pow1(3,0,81)

81

18

Why More Space?

Operation pending

No pending operations

19

Summary

• Recursive process num of deferred operations “grows proportional to b”

• Iterative process num of deferred operations stays “constant” (actually it’s zero)

Can we better quantify these observations?

20

Order of Growth: Recursive ProcesspowRec(3,5)

3 * powRec(3,4)

3 * (3 * powRec(3,3))

3 * (3 * (3 * powRec(3,2)))

3 * (3 * (3 * (3 * powRec(3,1))))

3 * (3 * (3 * (3 * (3 * powRec(3,0)))))

3 * (3 * (3 * (3 * (3 * 1))))

3 * (3 * (3 * (3 * 3)))

3 * (3 * (3 * 9))

3 * (3 * 27)

a * 81

243

powRec(3,4)

3 * powRec(3,3)

3 * (3 * powRec(3,2))

3 * (3 * (3 * powRec(3,1)))

3 * (3 * (3 * (3 * powRec(3,0))))

3 * (3 * (3 * (3 * 1)))

3 * (3 * (3 * 3))

3 * (3 * 9)

a * 27

815

4

Dependent on b

21

Order of Growth: Iterative Process

powTailRec(3,5)

pow1(3,5,1)

pow1(3,4,3)

pow1(3,3,9)

pow1(3,2,27)

pow1(3,1,81)

pow1(3,0,243)

243

powTailRec(3,4)

pow1(3,4,1)

pow1(3,3,3)

pow1(3,2,9)

pow1(3,1,27)

pow1(3,0,81)

81

Same constant, independent of b

22

“Tail” Recursion in Scala

• Scala compiler translate tail-recursion to iterative execution

• Thus, the functions-stack is not growing

23

Today• Home work review • Recursive vs. Iterative • Arrays

• Arrays in memory• Initialization and usage• foreach, filter • Arrays as functions arguments• Multi-dimensional arrays• References to array

• Sorting, searching and time-complexity analysis• Binary search• Bubble sort, Merge sort

• Home work

24

Arrays

• Array: sequential block of memory that holds variables of the same type

• Array can be declared for any type• Example: new Array[Int](3)

• Examples:• list of students’ marks• series of numbers entered by user• vectors• matrices

25

Arrays in Memory

• Sequence of variables of specified type• The array variable itself holds the address in

memory of beginning of sequence• Example: val s = new Array[Double](10)

• The k-th element of array A is specified by A[k-1] (0 based)

0 1 2 3 4 5 6 7 8 9

s

……

26

Example - Initialization

27

Arrays in Memory

• Access array’s content

• Change array’s content

28

Example

Array.scala

29

foreach, filter

• Iterates over arrays (and other containers)

• foreach – for each element apply a given function

• filter – create a new container containing only elements that pass the given Boolean-function

30

Example – Print Arrays PrintArray.scala

31

Example – filter

32

Example – Find MinimumFindMin.scala

33

Arrays as Function Arguments

• Functions can accept arrays as arguments

• Example:

• Within the function, arr is accessed in the usual way

• Changes to the array in the function change the original array! (why?)

34

ExampleArraySum.scala

35

ExampleMultAll.scala

36

Efficient Factorial

• Write a program that repeatedly receives a natural number as its input and returns its factorial

• The maximal number that will be given is known to be 1000

• The program should be efficient:• Do not calculate 1*2*…*n for every n from the

beginning on every input• Do not calculate values that were not requested

37

Solution: Main Idea

• We can keep in an array the results

• When given a new n• If calculated before – return it• Otherwise, get a better start

38

SolutionEfficientFact.scala

39

Solution (main)

EfficientFact.scala

40

Multi-Dimensional Arrays

• Array of arrays:val arr = Array[Array[Int]](3,2)

• Means an array of 3 integer arrays, each of length 2• Access: jth element of the ith array is a[i][j]

41

References to Arrays

What is going on here?

42

In Memory

321x1

x2

100

43

Today• Home work review • Recursive vs. Iterative • Arrays

• Arrays in memory• Initialization and usage• foreach, filter • Arrays as functions arguments• Multi-dimensional arrays• References to array

• Sorting, searching and time-complexity analysis• Binary search• Bubble sort, Merge sort

• Home work

44

Sort

• We would like to sort the elements in an array in an ascending order

7 2 8 5 4 2 4 5 7 8sort

45

What is Sorting Good For?

• Remember exercise 4 (find number)?• Now we have a large array (of length n) and have

multiple queries on whether a given number exists in the array (and what is its position in it)

• Naive solution: given a number, traverse the array and search for it• Not efficient ~ n/2 steps for each search operation

• Can we do better?• Sort the array as a preliminary step. Now search can be

performed much faster!

46

Today• Home work review • Recursive vs. Iterative • Arrays

• Arrays in memory• Initialization and usage• foreach, filter • Arrays as functions arguments• Multi-dimensional arrays• References to array

• Sorting, searching and time-complexity analysis• Binary search• Bubble sort, Merge sort (rest on Thursaday)

• Home work

47

Exercise 1

Write a program that gets 10 numbers from the user.It then accepts another number and checks to see ifthat number was one of the previous ones.

Example 1:Please enter 10 numbers:1 2 3 4 5 6 7 8 9 10Please enter a number to search for: 8Found it!

Example 2:Please enter 10 numbers:1 2 3 4 5 6 7 8 9 10Please enter a number to search for: 30Sorry, it’s not there

48

Exercise 2

• Implement a function that accepts two integer arrays and returns true if they are equal, false otherwise. The arrays are of the same size

• Write a program that accepts two arrays of integers from the user and checks for equality