1. 1 Gentle Introduction to Programming Session 4: Arrays

2. 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. 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. 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. 5 Solution Product.scala

6. 6 Exercise 2 Given the following iterative version of sum- of-digits calculation Write the recursive definition

7. 7 Solution SumDigits.scala

8. 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. 9 Solution Print.scala

10. 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

11. 11 Compute a b Iteratively Operationally: Halting condition: product  product * a counter  counter - 1 counter = 0 a b = a 2 *a*…*a = a 3 *…*a Which is: a b = a * a * a*…*a b

12. 12 Compute a b Iteratively

13. 13 Compute a b (Recursive Approach) Recursive call: a b = a * a (b-1) Base case: a 0 = 1

14. 14 Compute a b (Iterative Approach) How then, do the two procedures differ?

15. 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. 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. 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 Difference Growing 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. 18 Why More Space? Operation pending No pending operations

19. 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. 20 Order of Growth: Recursive Process powRec(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 81 5 4 Dependent on b

21. 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. 22 “Tail” Recursion in Scala Scala compiler translate tail-recursion to iterative execution Thus, the functions-stack is not growing

23. 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. 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. 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) 0123456789 s ……

26. 26 Example - Initialization

27. 27 Arrays in Memory Access array’s content Change array’s content

28. 28 Example Array.scala

29. 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. 30 Example – Print Arrays PrintArray.scala

31. 31 Example – filter

32. 32 Example – Find Minimum FindMin.scala

33. 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. 34 Example ArraySum.scala

35. 35 Example MultAll.scala

36. 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. 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. 38 Solution EfficientFact.scala

39. 39 Solution (main) EfficientFact.scala

40. 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: j th element of the i th array is a[i][j]

41. 41 References to Arrays What is going on here?

42. 42 In Memory 321 x1 x2 100

43. 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. 44 Sort We would like to sort the elements in an array in an ascending order 7 2854 2 4578 sort

45. 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. 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. 47 Exercise 1 Write a program that gets 10 numbers from the user. It then accepts another number and checks to see if that number was one of the previous ones. Example 1: Please enter 10 numbers: 1 2 3 4 5 6 7 8 9 10 Please enter a number to search for: 8 Found it! Example 2: Please enter 10 numbers: 1 2 3 4 5 6 7 8 9 10 Please enter a number to search for: 30 Sorry, it’s not there

48. 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