Problem Solving 4 Algorithms Problem Solving and Recursion

Problem Solving 4 Algorithms, Problem Solving and Recursion ICS-201 Introduction to Computing II Semester 071

Problem Solving l Consider the following problem: Given a list of elements (as an array), find and print all elements that are repeated at least two or more times in the list. In other words find all elements that are not unique in the list.

Solution – Think of all possibilities Before we start forming solutions of the problem, let us think what possible lists can we be asked to look into. 4 5 elements. 6 7 0 Case I: An array 2 with 3 no repeated 3 7 repeated 3 6 two or more Case II: An array 1 with 3 one 4 element times.

Solution (contd. ) Case III: An array with multiple elements repeated multiple number of times. 3 3 3 5 1 5 4 3 After having a look at these cases, we can suggest see that the form of the solution will be an array of frequencies of repeated elements, for example for the above array. The above solution is of course, not 4 perfect, 4 but 4 just 2 a first 1 attempt. 2 1 4

Algorithm – Pseudo code Outline Hence we can formulate an outline of our algorithm. Let us call it Algorithm count. Frequency: Input: An array a[] of integers with possibly repeated integers Output: An array of b[] of integers which contains all frequencies of all elements appearing at least two or more times in a[]. Steps: ? ? ?

Solution (contd. ) What are the possible steps of the algorithm? An obvious approach would be to count the frequency of each element in the array using another auxiliary array. l l This can be done using two for-loops through the array. So, for each element in a[ ], let us scan through all of a[ ] again, and if we find that element at another position in a[ ], let us increment the frequency of that element in b[ ]. l

Algorithm Pseudo-code Algorithm count. Frequency: Input: An array a[] of integers with possibly repeated integers Output: An array of b[] of integers which contains all frequencies of all elements appearing at least two or more times in a[]. Steps: 1. for each element in a[ ], 2. scan through all of a[ ] again, 3. if we find that element at another position in a[ ], 4. Increment the frequency of that element in b[ ].

Algorithm count. Frequency This approach is summarized as the following program: 1. 2. 3. 4. 5. 6. 7. public class Count. Frequency { public static void main(String[] args) { int[] a = {1, 3, 1, 5, 6, 3, 2, 2, 7, 8}; int[] b = new int[a. length]; int val; 8. 9. //Initialize b to 1 for each element 10. for(int i = 0; i < a. length; i++) b[i] = 1; 11. 12.

Solution (contd. ) 13. //Search for each element of a in the rest of a 14. for(int i = 0; i < a. length; i++) { val = a[i]; for(int j = 0; j < a. length; j++) if(val == a[j]) b[i]++; } 15. 16. 17. 18. 19. 20. //Print frequencies 21. System. out. println("valt. Frequency"); for(int i = 0; i < b. length; i++) if(b[i] > 0) System. out. println(a[i] + "t" + b[i]); }} 22. 23. 24. 25.

The Output It can be seen that the program repeats output. So for example, in the array {1, 3, 3, 3, 2, 2, 7, 8} • 3 appears 4 times, so in the output also 3 appears 4 times. • 2 appears 2 times, so in the output also 2 appears 2 times. • How can we improve this scenario?

Refining the Program l l l Can you think of other approaches to the count. Frequency problem? Can we use linear search or binary search to refine the output so that non-unique elements appear exactly once in the program? Can we use sorting techniques to speed up our algorithm, so that we can count non-unique elements much faster in a sorted array?

Recursion: Finding Length of A String l Problem: Find a recursive algorithm for computing the length of a string. For example length. String(“Work”) should return 4.

Solution – Possible Approach l How can we recursively find the length of a string, for example “solution” recursively? l Recall that recursive solution consists of two steps: – – l A Base Case A Recursive Step What will be the base case here and what will be the inductive step?

Base and Recursive Cases l The Base Case: An empty string has length 0. – length. String(“”) = 0. l The Recursive Step: The length of a string of n characters is equal to 1 + the length of the string of remaining n – 1 characters. Hence – length. String(“Alpha”) = 1 + length. String(“lpha”). – length. String(“lpha”) = 1 + length. String(“pha”) – length. String(“pha”) = 1 + length. String(“ha”) – length. String(“ha”) = 1 + length. String(“a”) – length. String(“a”) = 1 + length. String(“”) – we reach the base case

Combining the solutions l So we can trace our steps backward and yield – length. String(“a”) = 1 + length. String(“”) = 1 + 0 = 1 – length. String(“ha”) = 1 + length. String(“a”) = 1 + 1 = 2 – length. String(“pha”) = 1 + length. String(“ha”) = 1 + 2 = 3 – length. String(“lpha”) = 1 + length. String(“pha”) = 1 + 3 = 4 – length. String(“Alpha”) = 1 + length. String(“lpha”) = 1 + 4 = 5

Solution The following program shows the code for recursive length. String. 1. 2. 3. 4. 5. 6. 7. public static int length. String(String s) { if(s. equals(“”)) return 0; else return 1 + length. String(s. substring(1)); }}

Iterative Version Of length. String l Consider converting length. String to an iterative algorithm. l We need to replace the selection structure (the “if” statement) with a loop. l We also need to use a variable to store partial result of length of the String.

Iterative Version The following program implements iterativelength. String. 1. 2. 3. 4. 5. 6. 7. 8. 9. public static String iterativelength. String(String s) { int length = 0; //base case for(int i = 0; !(s. substring(i). equals(“”)); i++) { length++; } return length; }

Output 1. 2. 3. 4. 5. 6. public static void main(String[] args) { System. out. println("Length of "Alpha" Recursively = " + length. String("Alpha")); System. out. println("Length of "Alpha" Iteratively = " + iterativelength. String("Alpha")); }

Recursive power example l l Write method pow that takes integers x and y as parameters and returns xy. xy = x * x *. . . * x (y times, in total) An iterative solution: // not recursive public static int pow(int x, int y) { int product = 1; for (int i = 0; i < y; i++) { product = product * x; } return product; } 20

Recursive power function l Another way to define the power function: pow(x, 0) = 1 pow(x, y) = x * pow(x, y-1), // recursive public static int pow(int x, int y) { if (y == 0) { return 1; } else { return x * pow(x, y - 1); } } y > 0

How recursion works l Each call sets up a new instance of all the parameters and the local variables l As always, when the method completes, control returns to the method that invoked it (which might be another invocation of the same method) pow(4, 3) = = = 4 * 4 * 64 pow(4, 2) 4 * pow(4, 1) 4 * pow(4, 0) 4 * 1 22

Infinite recursion l a definition with a missing or badly written base causes infinite recursion, similar to an infinite loop – avoided by making sure that the recursive call gets closer to the solution (moving toward the base case) public static int pow(int x, int y) { return x * pow(x, y - 1); // Oops! Forgot base case } pow(4, 3) = = = 4 * 4 * 4 *. . . pow(4, 2) 4 * pow(4, 1) 4 * pow(4, 0) 4 * 4 * pow(4, -1) 4 * 4 * pow(4, -2) crashes: Stack Overflow Error! 23

Activation records l activation record: memory that Java allocates to store information about each running method – return point ("RP"), argument values, local variable values – Java stacks up the records as methods are called; a method's activation record exists until it returns – drawing the act. records helps us trace the behavior of a recursive method | | | | | x RP = = = = [ 4 ] [pow(4, 1)] [ 4 ] [pow(4, 2)] [ 4 ] [pow(4, 3)] [ 4 ] [main] y = [ 0 ] y = [ 1 ] y = [ 2 ] y = [ 3 ] 24 _ | | | | | pow(4, 0) pow(4, 1) pow(4, 2) pow(4, 3) main

Tracing recursive methods Consider the following method: public static int mystery 1(int x, int y) { if (x < y) { return x; } else { return mystery 1(x - y, y); } } For each call below, indicate what value is returned: mystery 1(6, 13) ______ mystery 1(14, 10) ______ mystery 1(37, 10) ______ mystery 1(8, 2) ______ mystery 1(50, 7) ______ 25

Tracing recursive methods public static void mystery 2(int n) { if (n <= 1) { System. out. print(n); } else { mystery 2(n / 2); System. out. print(", " + n); } } For each call below, indicate what output is printed: mystery 2(1) ______ mystery 2(2) ______ mystery 2(3) ______ mystery 2(4) ______ mystery 2(16) ______ mystery 2(30) ______ mystery 2(100) ______

Tracing recursive methods public static int mystery 3(int n) { if (n < 0) { return -mystery 3(-n); } else if (n < 10) { return n; } else { return mystery 3(n/10 + n % 10); } } For each call below, indicate what value is returned: mystery 3(6) ______ mystery 3(17) ______ mystery 3(259) ______ mystery 3(977) ______ mystery 3(-479) ______ 27

Tracing recursive methods public static void mystery 4(String s) { if (s. length() > 0) { System. out. print(s. char. At(0)); if (s. length() % 2 == 0) { mystery 4(s. substring(0, s. length() - 1)); } else { mystery 4(s. substring(1, s. length())); } System. out. print(s. char. At(s. length() - 1)); } } For each call below, indicate what output is printed: mystery 4("") ____________ mystery 4("ab") ______ mystery 4("bc") ______ mystery 4("abcd") ______

Recursive numeric problems l Problem: Given a decimal integer n and a base b, print n in base b. (Hint: consider the / and % operators to divide n. ) l Problem: Given integers a and b where a >= b, find their greatest common divisor ("GCD"), which is the largest number that is a factor of both a and b. Use Euclid's formula, which states that: GCD(a, b) = GCD(b, a MOD b) GCD(a, 0) = a (Hint: What should the base case be? ) 29

Recursive printing problem l Problem: Write a method star. String that takes an integer n as an argument and returns a string of stars (asterisks) 2 n long (i. e. , 2 to the nth power). For example: star. String(0) should return "*" (because 2^0 == 1) star. String(1) should return "**" (because 2^1 == 2) star. String(2) should return "****" (because 2^2 == 4) star. String(3) should return "****" (because 2^3 == 8) star. String(4) should return "********" (2^4 == 16) 30

Recursive string problems l Problem: Write a recursive method is. Palindrome that takes a string and returns whether the string is the same forwards as backwards. (Hint: examine the end letters. ) l Problem: Write a recursive method are. Anagrams that takes two strings w 1 and w 2 and returns whether they are anagrams of each other; that is, whether the letters of w 1 can be rearranged to form the word w 2. 31

Recursion can perform badly l The Fibonacci numbers are a sequence of numbers F 0, F 1, . . . Fn such that: F 0 = F 1 = 1 Fi = Fi-1 + Fi-2 for any i > 1 l Problem: Write a method fib that, when given an integer i, computes the i th Fibonacci number. l Why might a recursive solution to this problem be a bad idea? (Let's write it. . . ) – Can we fix it? If so, how? 32

Revisiting Fibonacci. . . l recursive Fibonacci was expensive because it made many, many recursive calls – fibonacci(n) recomputed fibonacci(n - 1. . . 1) many times in finding its answer! – this is a common case of "overlapping subproblems" or "divide poorly and reconquer", where the subtasks handled by the recursion are redundant with each other and get recomputed 33

Recursive graphics reading: 12. 4 34

Fractal images l fractal: A mathematically generated, selfsimilar image. – – Created by B. Mandelbrot in 1975 Many can be drawn elegantly using recursive algorithms 35

Sample Fractals

Fractal levels l A fractal can be drawn at many different levels. – – Each level is another layer of self-similarity. The larger figure is decomposed into smaller occurrences of the same figure. The smaller figures can themselves be decomposed, and so on. Let's write a program to draw the fractal below, an image called the Sierpinski Triangle. 37

How to generate a Sierpinski Triangle

Fractal code l We can write a recursive method to draw the triangle figure at a certain level. public static void draw. Figure(int level, Graphics g) {. . . } – – The recursive aspect is that draw. Figure for a given level should call itself for other levels as part of its work. But these smaller levels appear at different positions, so we should require the triangle's 3 corner points as parameters. public static void draw. Figure(int level, Graphics g, Point p 1, Point p 2, Point p 3) {. . . } 39

The base case l As usual, we begin with the base case. – The easiest figure to draw is a triangle at level 1. – We can use the fill. Polygon method of Graphics g to do this. public static void draw. Figure(int level, Graphics g, Point p 1, Point p 2, Point p 3) { if (level == 1) { // base case: simple triangle Polygon p = new Polygon(); p. add. Point(p 1. x, p 1. y); p. add. Point(p 2. x, p 2. y); p. add. Point(p 3. x, p 3. y); g. fill. Polygon(p); } else { // recursive case, split into 3 triangles. . . } } 40

Thinking recursively l A key observation: The end points needed to draw the smaller triangles (p 4, p 5, p 6) are the midpoints between the larger triangle's endpoints (p 1, p 2, p 3). – We can write a method to compute the midpoint between two Point objects. // returns the point halfway between p 1 and p 2 public static Point midpoint(Point p 1, Point p 2) { return new Point( (p 1. x + p 2. x) / 2, (p 1. y + p 2. y) / 2); } 41

Complete solution method l public static void draw. Figure(int level, Graphics g, Point p 1, Point p 2, Point p 3) { if (level == 1) { // base case: simple triangle Polygon p = new Polygon(); p. add. Point(p 1. x, p 1. y); p. add. Point(p 2. x, p 2. y); p. add. Point(p 3. x, p 3. y); g. fill. Polygon(p); } else { // recursive case, split into 3 triangles Point p 4 = midpoint(p 1, p 2); Point p 5 = midpoint(p 2, p 3); Point p 6 = midpoint(p 1, p 3); // recurse on 3 triangular areas draw. Figure(level - 1, g, p 1, p 4, p 6); draw. Figure(level - 1, g, p 4, p 2, p 5); draw. Figure(level - 1, g, p 6, p 5, p 3); }} 42