Document Sample
Algorithm Powered By Docstoc
					           Algorithms IV


CMSC 104                   1
        Pseudocode and Then Some
        We can write an algorithm for finding the
         average of two integers:
         Get an integer, num1, from the user
         Get an integer, num2, from the user
         sum = num1 + num2
         average = sum / 2
         Print “The average of “ num1 “ and ” num2
         “ is ” average.
      Steps 1, 2 & 5 will make use of code found
CMSC 104 in the run-time library.                    2
                Investigating Steps 1 & 5
       Get an integer, num1, from the user
       Print “The average = “ average.
      Are these really single steps?
      Each of them is really a sequence of
       steps, a subprogram. Two kinds of
           o Functions - an answer is returned to the
             main program.
           o Procedures - no answer returned to the
CMSC 104     main program                               3
           Functions and Procedures

      In our example, the function that gets a
       value from the user and the procedure
       that prints out the answer were already
      Many times it is necessary for us to
       write our own procedures or functions.

CMSC 104                                          4
                 More Problem Solving
      If we look at the problem as a whole; it
       may seem impossible, because it is so
      Complex problems can be solved using
       a Top-Down approach aka Stepwise
           o Break the problem into parts
           o Then break the parts into parts
           o Soon each of the parts will be easy to do
CMSC 104                                                 5
           Advantages of Top-down Design
          Breaking the problem down into parts
           helps us to clarify what needs to be done.
          At each step of refinement, the new parts
           become less complicated and therefore
           easier to figure out.
          What if you’ve broken a problem down as
           much as you can and you still don’t know?
            o Missing information
            o More detail is needed
CMSC 104                                                6
                   A Practical Example

          Scenario:
           o We own a home improvement company
           o We do painting, roofing and basement
           o A section of town has recently had flooding
           o We want to send out waterproofing
             pamphlets to our customers in that area

CMSC 104                                                   7
                  Our Algorithm

      Get the customer list from a file
      Sort the list according to zipcode
      Make a new file of only the customers
       with the zipcode 21222 from the sorted
       customer list
      Print an envelope for each customer in
       the new file

CMSC 104                                        8
                  Single steps ?

      None of our steps are single steps
      Employ Top-Down Design
      Start with the large idea and break into
       large parts
      Each part will end up being a function or
       a procedure

CMSC 104                                           9
           Pseudocode for our Main Program

      Call Get Customer List
      Call Sort on customer list by zipcode
      Call Make Target List from customer list
       using only zipcode 21222
      Call Print Envelopes using target list

CMSC 104                                          10
                 The Next Step
      Write algorithms for each of the
       functions or procedures.
      These may include steps that are really
       several steps, too.
      Give names to these new functions and
      Write algorithms for them.
      Continue this process until done.

CMSC 104                                         11
                   Structured Programs
          Top-down design will be used for all of our
           programming projects
          This is the standard way of writing programs.
          Programs produced using this method and
           using only the 3 kinds of structures,
           sequential, selection and repetition are called
           structured programs.
          Structured programs are easier to modify
           later and also easier for other programmers
           to understand.
CMSC 104                                                     12
                   Another Example

          Problem: Write a program that draws
           this picture of a house.

CMSC 104                                         13
                  The Algorithm

      Draw the outline of the house
      Draw the chimney
      Draw the door and doorknob
      Draw the windows

CMSC 104                               14
      All three windows are identical.
      They are simply in different positions.
      We can write a function called
       DrawWindow that will draw one window
       at a position we specify and call it 3
       times with the three different positions.
      Another benefit of Top-down design is
       reuseability. We are reusing the code
       for DrawWindow.
CMSC 104                                           15
                The Pseudocode

      Call DrawHouseOutline giving a position
      Call DrawChimney giving position
      Call DrawDoor giving position
      Call DrawWindow giving position #1
      Call DrawWindow giving position #2
      Call DrawWindow giving position #3

CMSC 104                                         16
             Problem Solving Techniques

          We have investigated three problem
           solving techniques:
           • Multiple attacks
           • Working backwards
           • Top-down design

CMSC 104                                        17

Shared By: