Homework 5

General Comments

• For full credit, provide context for each problem, show all calculations, and justify all answers by providing enough comments to explain your reasoning.
• Homework assignments must be very neatly written or typeset (e.g. using Word or OpenOffice).
• You can get up to 50% credit on a problem if you get significant outside assistance. Thus, if you are totally stuck on a problem it might be worth getting help. However, you must indicate any assistance/collaboration (See the Homework Assistance section on the Policies page). Failure to do so could result in a failing grade for the course! Note that getting help from the Help Center or me does not count as significant outside assistance, but talking with your classmates or searching on the Internet does!
  
• If a problem asks for an algorithm, you should give the most efficient algorithm you can find to ensure full credit. You should also specify the complexity of the algorithm with justification, whether or not the problem asks for it.

Details

Analyze Best and Worst Case Running Times

Give tight bounds for the best and worst case running times of each algorithm in terms of input size. Unless noted, assume A.length = n. Do not worry about what the code does; only analyze how long it takes. Use standard asymptotic notation and justify briefly on your own.

1. Early exit on a sentinel value.
   

   int scanUntilZero(int[] A) {
       int s = 0;
       for (int i = 0; i < A.length; i++) {
           s += A[i];
           if (A[i] == 0) break;
       }
       return s;
   }

2. Nested search over the prefix. Early exit on first duplicate.
   

   int hasDuplicatePrefix(int[] A) {
       for (int i = 0; i < A.length; i++) {
           for (int j = 0; j < i; j++) {
               if (A[i] == A[j]) return 1;
           }
       }
       return 0;
   }

3. Pair counting with a break depending on a threshold \(S\).
   

   void countPairsUpToS(int[] A, int S) {
       int c = 0;
       for (int i = 0; i < A.length; i++) {
           for (int j = i + 1; j < A.length; j++) {
               c++;
               if (A[i] + A[j] > S) break;
           }
       }
   }

4. Divide by 2 until zero.
   

   void halfWhile(int n) {
       while (n > 0) {
           n = n / 2;
       }
   }

5. Tricky one!
   

   void sqrtStepper(int n) {
       for (int i = 1; i * i <= n; i++) {
           // O(1) work
       }
   }

6. Changing inner loop.
   

   void doublingInner(int n) {
       for (int i = 1; i <= n; i++) {
           int k = 1;
           while (k < i) {
               k = k * 2;
           }
       }
   }

7. Triangular nested loop with a possible early break based on a changing accumulator.
   

   void triangularPlusBreak(int n) {
       int t = 0;
       for (int i = 0; i < n; i++) {
           for (int j = i; j < n; j++) {
               t += i + j;
               if (t % 1000 == 0) break;
           }
       }
   }

8. Fixed-size inner loop of constant \(M\) iterations.
   

   int fixedInnerConstant(int[] A) {
       int M = 250; // constant
       int s = 0;
       for (int i = 0; i < A.length; i++) {
           for (int j = 0; j < M; j++) {
               s += A[i] + j;
           }
       }
       return s;
   }

9. Two separate parameters: total work depends on both \(n\) and \(m\).
   

   void twoParameters(int n, int m) {
       int x = 0;
       for (int i = 0; i < n; i++) x++;
       for (int j = 0; j < m; j++) x++;
   }

10. Fully nested two-parameter loops.
    

    void nestedTwoParameters(int n, int m) {
        long x = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                x += i + j;
            }
        }
    }

11. Three nested loops with possible immediate return.
    

    void threeNestedWithBreak(int n) {
        long x = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                for (int k = 0; k < j; k++) {
                    x++;
                    if (x == 5) return;
                }
            }
        }
    }

12. Mixed for/while.
    

    void mixedForWhile(int n) {
        int count = 0;
        for (int i = 1; i <= n; i++) {
            int t = i;
            while (t > 0) {
                t = t / 3;
                count++;
            }
        }
    }

13. Early exit when a running sum exceeds a threshold; otherwise full scan.
    

    int sumWithSentinel(int[] A) {
        int s = 0;
        for (int i = 0; i < A.length; i++) {
            s += A[i];
            if (s > 1000000) return s;
        }
        return s;
    }

14. Work per iteration grows with the index: total work is the sum.
    

    void variableWorkPerIter(int n) {
        for (int i = 1; i <= n; i++) {
            for (int t = 0; t < i; t++) {
                // 1 step per t
            }
        }
    }