Download
problem solving with loops n.
Skip this Video
Loading SlideShow in 5 Seconds..
Problem Solving with Loops PowerPoint Presentation
Download Presentation
Problem Solving with Loops

Problem Solving with Loops

173 Vues Download Presentation
Télécharger la présentation

Problem Solving with Loops

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Problem Solving with Loops Lesson 7 COP1000

  2. Overview • Flowchart Symbols • The Loop Logic Structure • Incrementing/Decrementing • Accumulating • While/EndWhile • Repeat/Until • Automatic-Counter Loop (For) • Nested Loops • Indicators • Algorithm Instructions • Recursion COP1000

  3. Flowchart Symbols • Decision • True/False/Else • Process • Assign Decision Process Assign COP1000

  4. Repetition Structure Logic • Allows the programmer to specify that an action is to be repeated based on the truth or falsity of some condition. While there are more timecards to be processed Obtain time from each card and calculate pay As long as there are items still remaining on the list the loop will continue. • Otherwise known as iteration. • Two types of Iteration • Definite • Indefinite COP1000

  5. Definite Repetition • Known as definitebecause the number of iterations to be performed at runtime is known. • Also known as Counter-controlled Repetition • Uses a variable called a counter to control the number of times a set of statements should execute. COP1000

  6. Indefinite Repetition • Known as indefinite because the number of iterations at runtime is not known before the loop begins executing. • Uses a sentinel value (signal value, a flag value, or a dummy value) to indicate “end of data entry.” • When using a sentinel • Choose a sentinel that will not naturally exist within the range of data being used. • Ex. 999-99-9999 for Social Security Numbers COP1000

  7. The Looping Logic Structure • one of the three types of program control structures • Sequence • Selection (Decision) • Repetition (Looping or Iteration) COP1000

  8. The Looping Process • Is made up of: • Initialization • Condition (the test) • Increment (or Decrement) • The Accumulator, although used in frequently in loops, is NOT part of the looping process COP1000

  9. Looping Process • The Initialization • set to an initial value • usually zero but not all the time • Examples: • Count = 0 • Count = 1 • Count = 100 COP1000

  10. Looping Process • The Test or Condition • tested before the start of each loop repetition, called the iteration or pass. • Examples: • Count < 3 Count = 10 • Count <= 3 Count <> 10 • Count > 5 • Count >= 5 COP1000

  11. Looping Process • The Increment (or Decrement) • updates the variable during each iteration • must be part of the loop body (usually the last line) • Examples: • Count = Count + 1 increment • Count = Count – 1 decrement COP1000

  12. The Accumulator • Variables used to store values being computed in increments during the execution of a loop. • Not part of the Looping Process • But quite often an integral addition to the process • Very often looks like an increment, which is part of the looping process • Examples: • Sum = Sum + 1 • TotalGrade = TotalGrade + CurrentGrade COP1000

  13. Common Forms of Loops • The Three Most Common Loop-control statements: • the While/End While, • the For/Next, and • the Repeat/Until • But there are lots of other loop variations dependent on the language. COP1000

  14. While/End While • The While/End Whilestatement • The most versatile of the loops • The loop body contains the instructions to be repeated. • The loop-repetition condition is the Boolean expression after the reserved word while which is evaluated before each repetition of the loop body. COP1000

  15. While Structure Set counter To 0 While counter < final_value statements Increment counter by 1 End While Init ? true Stmt false Stmt Pseudocode Example COP1000

  16. While Example X = 3; How many times does the Count = 0; loop execute? while Count < 3 do begin What is displayed? X = X * 2; 6 Print (X); 12 Count = Count + 1 24 end; {while Count} Pascal Code Example COP1000

  17. Another While Example Dim X as Integer Dim Count as Integer X = 3 Count = 0 While Count < 3 X = X * 2 Print X Count = Count + 1 End While VB Code Example COP1000

  18. Another While Example int X = 3; intCount = 0; While (Count < 3) { X = X * 2; cout << X << endl; Print statement Count = Count + 1; } C++ Code Example COP1000

  19. Looping Examples • Two computer language examples: COP1000

  20. Indefinite Examples • A Sentinel-Controlled Loop • Controlled by a sentinel value. • Examples end-of-file marker (EOF) end-of-line marker (EOL) 999999999 for SSN 999999 for date** **Be careful with this one! COP1000

  21. Indefinite Examples • A Sentinel-Controlled Loop Pseudocode Template Initialize Sum to 0 Read the first value into counter variable While counter variable is not sentinel do Add counter variable to Sum Read next value into counter variable While-end; {while} COP1000

  22. Another Indefinite Example • Boolean Flag-Controlled Loops • Executes until the event being monitored occurs. • A program flag, or flag, is a Boolean variable whole value (True or False) signals whether a particular event occurs. • The flag should initially be set to False and reset to True when the event occurs. • Primarily used when interfacing with devices. COP1000

  23. Another Indefinite Example • Boolean Flag-Controlled Loops • Pseudocode Template Initialize flag to False while not flag statements.. Reset flag to True if the event being monitored occurs while-end; {while} COP1000

  24. Do/Until • Logical Opposite of the While Loop • Unlike the While/While-End, the Do/Until tests for falsity. • Should be used when the question being asked is more naturally asked in the negative. Init Counter < 5 false Stmt true Stmt COP1000

  25. Do/Until Example x = 3 Count = 3 Do Until Count < 1 X = X * 2 Print X Count = Count – 1 ‘Decrement Loop VB Code COP1000

  26. Repeat/Until Structure • Similar to the While/While-End structure • In the While Loop • loop-continuation is tested at the beginning of the loop before the body of the loop is performed. • In the Repeat/Until Loop • loop-continuation is tested after the loop body is performed, thus executing the loop body at least once. COP1000

  27. counter = 1 Action occurs before Test statements counter < 5 True False Repeat Until Loop • Pseudocode Template Repeat statements increment counterVariable Until testCondition • Notice that the statements are executed before thecondition to end the loop COP1000

  28. The For/Next Loop • Combines all of the Loop Process components into one statement. • Notes on the Counter: • Can be used non-destructively but must not be modified (destructively) within the loop body. • Should be a local variable. • The loop body will not be executed if initial is greater than the final value, unless the increment value is negative. COP1000

  29. The For/Next Loop • Pseudocode Example For counter = initialvalue To finalvalueStep 1 statements… ‘to increment Next counter For counter = finalvalue To initialvalue Step -1 statements… ‘to decrement Next counter COP1000

  30. For Loop Flowchart • Note that the “To” is equivalent to “while less than or equal to” For counter = 1 to 5 Step 1 Print counter Next counter counter = 1 (implicit) counter <= 5 True Print counter counter = counter + 1 (implicit) (implicit) False COP1000

  31. Nested Loops • Loops can be nested just as IF statements. • Cannot use the same counter-control variable for the inner loop as is used for the outer loop. True True y x False False COP1000

  32. Nested Loop Template Initialize outer loop While outer loop test {while} statements... Initialize inner loop While inner loop test {while} Inner loop processing and Update inner loop variable End While {inner while} statements... Update outer loop variable End While {outer while} Pseudocode Example COP1000

  33. Nested Loop Code Example Dim outercounter As Integer Dim innercounter As Integer outercounter = 1 While outercounter <= 3 innercounter = 1 While innercounter <= 3 innercounter = innercounter + 1 End While ‘innercounter outercounter = outercounter + 1 End While ‘outercounter VB Code COP1000

  34. Nested Loop Code Example Dim OC As Integer Dim IC As Integer OC= 1 While OC <= 3 Print OC IC = 1 While IC<= 3 Print IC IC = IC+ 1 End While ‘IC OC = OC + 1 End While ‘OC VB Code True True IC OC Print OC Print IC False False Outercounter = OC Innercounter = IC COP1000

  35. Loop Invariants • Assertions about the characteristics of a loop that always must be true for a loop to execute properly. • The assertions are true on loop entry, at the start of each loop iteration, and on exit from the loop. • They are not necessarily true at each point within the body of the loop. COP1000

  36. Four Special Cases of Loops • When the loop is skipped entirely (zero iteration loop) • When the loop body is executed just once • When the loop executes some normal number of times • When the loop fails to exit (infinite loop) COP1000

  37. Watch out for… • Beware of infinite loops • Beware of off-by-one Loop Errors • Executes the loop one too many times • Executes the loop one too few times COP1000

  38. Loop Testing Strategy • Verify the Algorithm • Test the value of the algorithm • before the loop • during the loop, and • after the loop. COP1000

  39. Recursion Or a case of twisted tails COP1000

  40. Recursion • Occurs when a function calls itself from within the body of the function • Also known as “procedural iteration” • Classic Examples of Recursion • Factorial • Fibonacci COP1000

  41. Factorial x! • How it works: If X = 3, the chain of recursive calls would be as follows: Factorial(3) 3 * Factorial(2) 3 * (2 * Factorial(1) ) Precondition x  0 Postcondition Returns the product 1 * 2 * 3 * …* x for x > 1 Returns 1 when X is 0 or 1. COP1000

  42. VB Factorial Example Private Function Factorial(ByRef y As Double) _ As Double ‘2nd double defines Factorial If y <= 1 Then Factorial = 1 ' Base case Else Factorial = y * Factorial(y - 1) ' Recursive step End If End Function The Base Case is also known as the Stopping Case. Call Pop 5 120 4 24 3 6 2 2 1 COP1000

  43. The Original Fibonacci Problem • Investigated (in the year 1202) was about how fast rabbits could breed in ideal circumstances. • Suppose a newly-born pair of rabbits, one male, one female, are put in a field. Rabbits are able to mate at the age of one month so that at the end of its second month a female can produce another pair of rabbits. Suppose that our rabbits never die and that the female always produces one new pair (one male, one female) every month from the second month on. • The puzzle that Fibonacci posed was... • How many pairs will there be in one year? • At the end of the first month, they mate, but there is still one only 1 pair. • At the end of the second month the female produces a new pair, so now there are 2 pairs of rabbits in the field. • At the end of the third month, the original female produces a second pair, making 3 pairs. • At the end of the fourth month, the original female has produced yet another new pair, the female born two months ago produces her first pair also, making 5 pairs. COP1000

  44. Fibonacci Tree of Rabbits Female Male COP1000

  45. Fibonacci Shells • We can make another picture showing the Fibonacci numbers 1,1,2,3,5,8,13,21 • If we start with two small squares of size 1 next to each other. • On top of both of these draw a square of size 2 (=1+1). COP1000

  46. The Fibonacci Sequence • The number of clockwise spirals and the number of counterclockwise spirals formed by the seeds of certain varieties of flowers COP1000

  47. Sunflower Spirals COP1000

  48. Fibonacci Sequence • Fibonacci Numbers Each Fibonacci number is the sum of the two preceding Fibonacci numbers. • The Fibonacci series defined recursively: Fibonacci(0) = 0 Fibonacci(1) = 1 Fibonacci(2) = 1 Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n - 2) Fib(3) = Fib(2) + Fib(1) = 1 + 1 = 2 Fib(4) = Fib(3) + Fib(2) = 2 + 1 = 3 Fib(5) = Fib(4) + Fib(3) = 3 + 2 = 5 Fib(6) = Fib(5) + Fib(4) = 5 + 3 = 8 A Shortened Form: Fib (1) = 1 Fib (2) = 1 Fib (n) = Fib (n - 1) + Fib (n - 2) COP1000

  49. Next? Arrays COP1000