Assignment on Analysis of Nonrecursive Algorithms

Summary

This assignment focuses upon:

• computing the time required for each line of code within a procedure—counting each instruction separately,
• using one or more Common Computational Formulae, when appropriate, to obtain a relatively simple algebraic expression for the total time,
• comparing the formal analysis with actual instruction counts determined during program execution.

For reference and study, this assignment also contains reasonably-detailed analyses and discussion of two C++ functions.

In analyzing code throughout this assignment, you should use the following constants for the time it takes a machine to do specific operations:

• A — one assignment
• B — one evaluation of a Boolean (e.g., a comparison)
• S — one addition or subtraction (e.g., + or -)
• M — one multiplication or division (e.g., *, / or %)
• P — one increment (e.g., ++) [since the line x++ is largely equal to x = x + 1, P is roughly equal to A + S]

Note Looking Ahead: Although much of the course will use code analysis to study how well an algorithm will scale according to a size n, this assignment focuses only on analysis basics. Uses of analysis to predict scaling and run times will be examined in later assignments.

Preparation

Download the file analysis.tar.gz, and decompress it with the line

     tar -xvf analysis.tar.gz

Upon decompression, a new directory analysis should have been created containing these files organized into three groups:

• C++ base code for the exercises in this assignment; this code forms the basis for each question which asks you to analysis a specific code segment.
  • header file loop.hpp
  • main program TestAnalysis.cpp
  • files with separate functions for each exercise (run1.cpp, ... run5.cpp)
• C++ code for the exercises, expanded to count each operation analyzed within this assignment
  • header file loopCount.hpp
  • main program TestAnalysisCount.cpp
  • files with separate expanded functions for each exercise (run1Count.cpp, ... run5Count.cpp)
• a Makefile that allows easy compiling and linking of the files to yield either of two complete programs.

To compile either program TestAnalysis.cpp or TestAnalysisCount.cpp, use the corresponding line below:

  make TestAnalysis
  make TestAnalysisCount

To run this code, either program uses command-line input with two arguments.

• The first command line argument is the exercise number.
• The second command line argument is a value for n.

For example, to run the TestAnalysis program for Exercise 0 with n=100, you would type

 ./TestAnalysis 0 100

Exercise 0: Getting Started

To illustrate how you are expected to write up code analysis within this assignment, the following narrative presents sample assignment instructions and expected student answers for the Exercises that follow.

(Note: Although answers to typical questions/instructions are already given, a separate section at the end of this Exercise 0 presents additional questions for you to answer.)

#include "loop.hpp"

long run0(int n) {
  
  long sum = 0;                             /* line 1 */

  for (int i=0 ; i < n ; i++)  {            /* line 2 */
      
      sum++;                                /* line 3 */

  }

  return sum;
}

Sample Assignment Instructions and Expected Answers

1. Perform a careful micro-analysis of the time required for each line of this code (ignore both the function call itself and the return).
   
   Note: In your answer, be sure to give a separate time required for each line of the code. Likely, the amount of time for a line will involve some expression involving at least some of the variables n, A, B, S, M, and P.

   Proposed Answer

   • line 1: assignment: A
   • line 2:
     • assignment(s): A
     • Boolean condition: effectively i starts at 0 and increases 1 at a time until it reaches n, so there are n+1 Boolean checks: (n+1)(B)
     • update(s): i starts at 0 and increases by 1, with the last increment starting when i is n-1: so there are n increments: (n)(P)
   • line 3: program execution repeats the loop n times, so there are n increments: (n)(P)
2. After computing the time for each line in Step a, add to obtain the total time needed.

   Proposed Answer
   Adding the results from part a:
   total time = A + A + (n+1)(B) + (n)(P) + (n)(P)
   combining constants and factors of n yields:
   total time = (2A+B) + n((B+2P)

3. Use your result for the total time to determine the Big-O, Big-Ω, and Big-Θ running times for run1, and explain your conclusions. For example, you likely will want to highlight which terms will dominate for large n and which will have minimal impact on the total time.

   Proposed Answer
   Big-O, Big-Ω, and Big-Θ all focus on the highest degree term in a micro-analysis.
   In this case, that term is n(B+2P)
   In this expression, B and P are all constants, so adding them might give a new constant Q = B+2P
   Since one normally ignores constants in writing Big-O, Big-Ω, and Big-Θ, any of the following would be correct): O(Qn), O(n), Ω(Qn), Ω(n), Θ(Qn), Θ(n).

4. If instead of a time computation, we could ask many assignments, how many Boolean operations, how many additions, and how many multiplications are performed in this code?

   Proposed Answer
   From above we have total time = (2A+B) + n((B+2P)
   To count the number of assignments, we could consider the total time expression, with A=1 and B=P=0. That is A being 1 counts the number of assignments and the other constants being 0 ignore those counts. Thus, to answer this question:

   • assignment count: 2+n(0) = 2
   • Boolean operations: 1+n(1) = n+1
   • increments: 0+n(2) = 2n

5. From above we have total time = (2A+B) + n((B+2P)
   As an experimental check of the counts in the previous step, consider the number of assignments, Boolean operators, and increments,  when n = 100. Substitute 100 for n in the answers in the previous step. Then compile and run TestAnalysisCount.cpp for this exercise 0 and n=100:

         make TestAnalysisCount
         ./TestAnalysisCount 0 100
       

   Proposed Answer
   Running this program yields these results:

         Program to run loop-based code segments
         Running Exercise 0 with time iterations = 100
         operation couts
              assignments: 2
              Bool.ops:    101
              + or - ops:  0
              *, /, % ops: 0
              increments:  200
         sum returned:     100
         

6. Compare the counts from your analysis with the values obtained from the program. To what extent are they the same or different?

   Proposed Answer
   These numbers correspond exactly to the results in the previous exercise step.

Answer these Questions for Exercise 0 (no need to comment on the above sample questions or answers)

7. In function run0, how does the value of sum relate to the execution of the loop body?

8. In Step a, line 2, above, why is the count for Boolean comparisons is one more than the number of increments?

9. Examine the augmented function: run0Count.cpp,  which includes variables to count the number of assignments,  Boolean comparisons, etc. For example, at the start of the function. all count variables are initialized to 0, and the statement ++(*ACt) increments the count of assignments (A's) by 1.

   • Why do you think all of these counter parameters are declared of type int *?
   • Line 2 of the code contains the expression

     (++(*BCt))&&(i < n)

     Another possibility might reverse the order of these two conditions:

     (i < n&&(++(*BCt)))

     Would either of these statements work, or might one give an incorrect answer? Explain.
   • The overall driver program for this counting program is TestAnalysisCount.cpp. Much of the middle of this program is devoted to a detailed and extended try---catch block. What is the purpose of this extended block, and why are there two catch blocks?
     Note in this code, the actual calling and running the desired function and printing results takes up only a small code segment of the overall program

Exercise 1

#include "loop.hpp"

long run1(int n) {

  long sum = 0;                             /* line 1 */

  for (int i=0 ; i < 6*n ; i+=2)            /* line 2 */
      
      sum++;                                /* line 3 */

  return sum;
}

Answer these Questions for Exercise 1

As in Exercise 0, note that no Common Computational Formulae are required for this exercise.

1. Following the approach in Exercise 0, Step a, perform a careful micro-analysis of the time required for each line of this code.

   Note: In your answer, be sure to give a separate time required for each line of the code. Likely, the amount of time for a line will involve some expression involving at least some of the variables n, A, B, S, M, and P.

2. Once time is determined for each line, add to obtain the total time needed.

3. Use your result for the total time to determine the Big-O,  Big-Ω, and Big-Θ running times for run1, and explain your conclusions. For example, you likely will want to highlight which terms will dominate for large n and which will have minimal impact on the total time.

4. If instead of a time computation, use your answer in Step c to determine how many assignments, how many Boolean operations, how many additions, and how many multiplications are performed in this code, based on the number n?

5. As an experimental check of the counts in the previous step,  consider the number of assignments, Boolean operators, and increments, when n = 100. Substitute 100 for n in the answers in the previous step. Then compile and run TestAnalysisCount.cpp for this exercise 0 and n=100:

         make TestAnalysisCount
         ./TestAnalysisCount 1 100
       

6. Compare the counts from your analysis with the values obtained from the program. To what extent are they the same or different?

Exercise 2

#include "loop.hpp"

long run2(int n) {

  long sum = 0;                             /* line 1 */

  for (int i=0 ; i < n ; i++)    {          /* line 2 */
      
    sum++;                                  /* line 3 */
    
  }
  
  for (int j=n ; j < 2*n ; j++)  {          /* line 4 */
      
    sum++;                                  /* line 5 */
    
  }
  
  return sum;
}

Answer these Questions for Exercise 2

The questions for Exercise 2 are the same as for Exercise 1, except you need to analyze function run2. Also, as in Exercises 0 and 1, note that no Common Computational Formulae are required for this exercise.

Exercise 3

#include "loop.hpp"

long run3(int n) {

   long sum = 0;                             /* line 1 */

   for (int i = 1 ; i <= n*n ; i++ )  {      /* line 2 */
       
       for (int j = 1; j <= i*i*i; j++)  {   /* line 3 */
          
         sum++;                              /* line 4 */

       }
       
   }
         
   return sum;
 }

Sample Assignment Instructions and Expected Answers

This function contains two elements that are quite different from the previous examples.

• The function contains a nested loop.
• The work performed in the inner loop depends upon the loop control variable i from the outer loop.

Even with these substantial differences between this function and the previous functions, the analysis that follows utilizes the same overall structure as Exercise 0: first, this a narrative presents questions/instructions with answers, and a separate section of questions is given at the end for your responses.

As you will see, the questions here are analogous to those earlier in this assignment, but parts of the answers are quite different.

1. Following the approach in Exercise 0, Step a, perform a careful micro-analysis of the time required for each line of this code.

   Note: In your answer, be sure to give a separate time required for each line of the code. Likely, the amount of time for a line will involve some expression involving at least some of the variables n, A, B, S, M, and P.

   Proposed Answer

   • line 1: assignment: A
   • line 2: Outer for loop
     • assignment(s): A
     • Boolean condition: effectively i starts at 1 and increases 1 at a time until it reaches n²+1, so there are n²+1 Boolean checks and n²+1 multiplications: (n²+1)(B+M)
     • update(s): i starts at 1 and increases by 1, with the last increment starting when i is n²: so there are n increments: (n²)(P)
   • lines 3 and 4: Inner for loop
     Each time program execution begins the inner loop, the amount of work depends upon the variable i
     • Work for a given i
       • line 3
         • assignment(s): A
         • Boolean condition: effectively j starts at 1 and increases 1 at a time until it reaches i³+1, so there are i³+1 Boolean checks, each with 2 multiplications: (i³+1)(B+2M)
         • update(s): j starts at 1 and increases by 1, with the last increment starting when j is i³: so there are i³ increments of j: (i³)(P)
       • line 4: sum is incremented in line 4 each time j is updated in line 3, so the time for line 4 is (i³)(P)

       Altogether for a given i, the amount of work is A + (i³+1)(B+2M+P) + (i³)(P)
       Grouping the constants (no i's) and the powers of i,  the total time is (A+B+2M) + (i³)(B+2M+2P)

     • Work overall i's.

       • From the outer loop, the loop body ia executed n² times, with i taking on the values 1, . . , (n²) within that loop.

       • For each i, the constant term (A+B+2M) is performed once, so the total amount of time corresponding to that term over all i's is (n²)(A+B+2M).

       • As i takes on values 1, . . , (n²), the term containing i for the inner loop yields the amount
         ((1³)(B+2M+2P) + (2³)(B+2M+2P) + (3³)(B+2M+2P) + . . . + ((n²)³)(B+2M+2P).

       • Overall, combining the constant term and the terms involving i, the total time for lines 3 and 4 is
         (n²)(A+B+2M) + {[(1³)(B+2M+2P) + (2³)(B+2M+2P) + (3³)(B+2M+2P) + . . . +  (n²)³](B+2M+2P)}

       • Factoring out (B+2M+2P) in the above sum yields (n²)(A+B+2M) + {[(1³) + (2³) + (3³)  + . . . +  ((n²)³)](B+2M+2P)}

       • Yes, this looks messy!
         But the sum of cubes can be simplified with one of the Common Computational Formulae (where the sum goes from 1 to (n² rather than from 1 to n). Using the formula for the sum of cubes, the total time is
         (n²)(A+B+2M) + [(n²)²((n²+1)² / 4)](B+2M+2P)

2. Once time is determined for each line, add to obtain the total time needed.

   Proposed Answer
   Adding the results from part a:
   total time = A + A + (n²+1)(B+M)) + (n²)(P) + (n²)(A+B+2M) + (n²)(P) + [(n²)²(n²+1)² / 4] (B+2M+2P)
   
   multiplying out the squaring operation in the last term yields:
   total time = A + A + (n²+1)(B+M)) + (n²)(P) + (n²)(A+B+2M) + (n⁸)(B+2M+2P)/4) + (n⁶(2(B+2M+2P)/4) + (n⁴)((B+2M+2P) / 4)
   
   
   Combining constants and powers of n yields:
   (2A+B+M) + (n²)(A+2B+3M+P)+ (n⁴)((B+2M+2P) / 4) + (n⁶)((B+2M+2P)/2) + (n⁸)((B+2M+2P) / 4)

3. Use your result for the total time to determine the Big-O,  Big-Ω, and Big-Θ running times for run3, and explain your conclusions. For example, you likely will want to highlight which terms will dominate for large n and which will have minimal impact on the total time.

   Proposed Answer
   In reviewing this algebraic formula, the highest or dominant power of n is (n⁸), so this function has O(n⁸), Ω(n⁸), and Θ(n⁸).

4. If instead of a time computation, we could ask now many assignments, how many Boolean operations, how many additions,  and how many multiplications are performed in this code? Give both a general count and the count when n = 10.

   Proposed Answer
   From above we have total time
   = (2A+B+M) + (n²)(A+2B+3M+P)+ (n⁴)((B+2M+2P) / 4) + (n⁶)((B+2M+2P)/2) + (n⁸)((B+2M+2P) / 4)
   
   To count the number of assignments, we could consider the total time expression, with A=1 and B=P=0. That is A being 1 counts the number of assignments and the other constants being 0 ignore those counts. Thus, to answer this question:

   Category	General Count	Count when n = 10
   assignments (A)	2 + n2	2+100 = 102
   Boolean ops (B)	1 + 2n2 + n4/4 + n6/2 + n8/4	1 + 200 + 10000/4 + 1000000/2 + 100000000/4 = 25502701
   Additions (S)	0	0
   Multiplications (M)	1 + 3n2 + 2n4/4 + 2n6/2 + 2n8/4	1 + 300 + 5000 + 1000000 + 50000000 = 51005301
   increments (P)	n2 + 2n4/4 + 2n6/2 + 2n8/4	100 + 5000 + 1000000 + 50000000 = 51005100

5. Compare your computations from the previous Step with the counts actually given by running TestAnalysisCount.cpp for this function when n = 10. To what extent do the counts agree, or do they differ by a litle, or by a lot? Explain briefly.

   Proposed Answer
   Running this program yields these results:

            Program to run loop-based code segments
            Running Exercise 3 with time iterations = 10
            operation couts
                 assignments: 102
                 Bool.ops:    25502701
                 + or - ops:  0
                 *, /, % ops: 51005301
                 increments:  51005100
            sum returned:     25502500
   

   These numbers correspond exactly to the results in the previous exercise step.

Answer these Questions for Exercise 3 (no need to comment on the above sample questions or answers)

6. Explain in your own words how the analysis in this code is determined. In particular,  

   • In analyzing line 3 of the code, why is timing first computed for i^th iteration, where i represents an arbitrary value from the outer loop?
   • In line 3 for a given i value, why is the assignment time constant, while the timing of the Boolean and the update depends upon i?
   • When determining the overall time for line 3 of the code,  why is the constant term multiplied by n² while the other terms appear as a long sum (sometimes called a series), and no n² factor is included?
   • Why do you think the work for the overall time involves the algebraic step of factoring?
   • Which common computation formula is used, and why is n² substituted into the computational formula rather than n (which is as the formula is stated)?
   • Write at least 3 sentences explaining how the General Count for multiplications is determined, given the expression for the overall time of this function from part b.
   • Why do you think steps d and e consider counts with n = 10, whereas earlier exercises considered counts with n = 100.

7. Step c indicates that this function has O(n⁸),  Ωn⁸), and Θn⁸). Write in your own words why this conclusion follows from the expression for the overall time determined in Step b.

Observation/Warning about Results from Claude and ChatGPT

On December 11, 2024, I gave this question (but not my naswers) to both Claude and ChatGPT. Both recognized that the inner loop involved a series. However,

• Both made initial errors working with the series (Claude largely tried to ignore the series; ChatGPT identified the right summation formula, but applied it incorrectly.)
• In each case, I pointed out the mistake, and they both gave [different] erroneous answers. (Claude used the wrong summation formula for the sum of cubes; ChaptGPT corrected part of the algebra, but made a different algebraic error.)
• Again I pointed out the error, and their resulting answer had yet another error. (Claude changed the fomula being summed in line 3; ChatGPT incorretly adjusted their summation formula and then made yet another algebra error.)

Exercise 4

#include "loop.hpp"

long run4(int n) {

  long sum = 0;                             /* line 1 */
         
  for (int i=1 ; i <= n*n ; i++)   {        /* line 2 */
      
      for (int j=1 ; j <= n*n*n ; j++)   {  /* line 3 */
        
      sum++;                                /* line 4 */

      }
      
  }
  
  return sum;
}

Answer these Questions for Exercise 4

While questions for this exercise mostly are similar to those in Exercises 1 and 2, note there are a few changes.

1. Following the approach in Exercise 0, Step a, perform a careful micro-analysis of the time required for each line of this code.

   Notes:

   • In your answer, be sure to give a separate time required for each line of the code. Likely, the amount of time for a line will involve some expression involving at least some of the variables n, A, B, S, M, and P.
   • In this computation, explain why this analysis does not require the same type of series that was needed in Exercise 3.

2. Once time is determined for each line, add to obtain the total time needed. As part of this answer, explain why no special common computational formulae are needed here. That is why is the analysis of this exercise rather different than that of Exercise 3?

3. Use your result for the total time to determine the Big-O,  Big-Ω, and Big-Θ running times for run4, and explain your conclusions. For example, you likely will want to highlight which terms will dominate for large n and which will have minimal impact on the total time.

4. Instead of a time computation, determine how many assignments,  how many Boolean operations, how many additions, and how many multiplications are performed in this code, based on the number n?

5. Extra Credit Option: As an experimental check of the counts in the previous step,  consider the number of assignments, Boolean operators, and increments, when n = 10. Substitute 10 for n in the answers in the previous step. Then compile and run TestAnalysisCount.cpp for this exercise 4 and n=10:

         make TestAnalysisCount
         ./TestAnalysisCount 4 10
       

   Compare the counts from your analysis with the values obtained from the program. To what extent are they the same or different?

Exercise 5

#include "loop.hpp"

long run5(int n) {

   long sum = 0;                             /* line 1 */

   for (int i = 1 ; i <= n ; i++ )   {       /* line 2 */
       
       for (int j = i-1; j <= i+3; j++)  {   /* line 3 */
          
         sum++;                              /* line 4 */

       }
       
   }
   
   return sum;

}

Answer these Questions for Exercise 5

1. Following the approach in Exercise 0, Step a, perform a careful micro-analysis of the time required for each line of this code.
   Does this computation require the same type of series as Exercise 3? Explain your answer.

2. Once time is determined for each line, add to obtain the total time needed. Does this answer require the use of a common computational formula? Explain briefly.

3. Use your result for the total time to determine the Big-O,  Big-Ω, and Big-Θ running times for run5, and explain your conclusions. For example, you likely will want to highlight which terms will dominate for large n and which will have minimal impact on the total time.

4. Extra Credit Option: Instead of a time computation, determine how many assignments, how many Boolean operations, how many additions, and how many multiplications are performed in this code, based on the number n?

5. Extra Credit Option: As an experimental check of the counts in the previous step,  consider the number of assignments, Boolean operators, and increments, when n = 10. Substitute 10 for n in the answers in the previous step. Then compile and run TestAnalysisCount.cpp for this exercise 5 and n=10:

         make TestAnalysisCount
         ./TestAnalysisCount 5 10
       

   Compare the counts from your analysis with the values obtained from the program. To what extent are they the same or different?

created December 21, 2021 revised December-January 2021 revised Summer 2022 revised 1-2 January 2023 typos corrected 27 January 2023 updated Summer 2023 typo corrected 28 January 2024 largely rethought and rewritten 12-16 November 2024
For more information, please contact Henry M. Walker at walker@cs.grinnell.edu.

Copyright © 2011-2025 by Henry M. Walker. Selected materials copyright by Marge Coahran, Samuel A. Rebelsky, John David Stone, and Henry Walker and used by permission. This page and other materials developed for this course are under development. This and all laboratory exercises for this course are licensed under a Creative Commons Attribution-NonCommercial-Share Alike 4.0 International License.