Problem 1: Write a method called grep that takes three arguments: the name an input file, the name of an output file, and a string to search for within the input file. The method should open the input file, create the output file, and copy to the output file every line from the input file that contains the search string. For example, if the input file contains

Joanna: So where do you work, uh, Peter?
Peter: Initech
Joanna: And, uh, what do you do there?

Joanna: So where do you work, uh, Peter?
Peter: Initech

public static void grep(String inname, String outname, String search) throws IOException
{
  BufferedReader in = new BufferedReader(new FileReader(inname));
  PrintWriter out = new PrintWriter(new FileWriter(outname));

  String line;
  while ((line = in.readLine()) != null)
    if (line.indexOf(search) != -1)
      out.println(line);

  out.close();
}

Problem 2: Write a method that takes as its parameter the name of a file containing start and stop times in the form "hh:mm hh:mm" and adds up and returns the total time intervals in minutes. For example, if the input file is

3:15 4:00
10:30 10:40

public int readTimes(String fname) throws IOException
{
  BufferedReader in = new BufferedReader(new FileReader(fname));

  int total = 0;
  String line;
  while ((line = in.readLine()) != null)
  {
    StringTokenizer tok = new StringTokenizer(line, ": ");
    int h1 = Integer.parseInt(tok.nextToken());
    int m1 = Integer.parseInt(tok.nextToken());
    int h2 = Integer.parseInt(tok.nextToken());
    int m2 = Integer.parseInt(tok.nextToken());

    total += computeInterval(h1, m1, h2, m2);
  }

  return total;
}

Problem 3: Redo problem 2, but do the computation in seconds. Assume that you have an appropriate version of the computeInterval method, and that each time in the file may or may not contain the seconds (assume 0 if the seconds are omitted). For example, the input file may contain

3:15 3:17:20
4:00:01 4:00:10

public int readTimes(String fname) throws IOException
{
  BufferedReader in = new BufferedReader(new FileReader(fname));

  int total = 0;
  String line;
  while ((line = in.readLine()) != null)
  {
    StringTokenizer tok = new StringTokenizer(line);
    String start = tok.nextToken();
    String end = tok.nextToken();
    
    tok = new StringTokenizer(start, ":");
    int h1 = Integer.parseInt(tok.nextToken());
    int m1 = Integer.parseInt(tok.nextToken());
    int s1 = 0;
    if (tok.hasMoreTokens())
      s1 = Integer.parseInt(tok.nextToken());

    tok = new StringTokenizer(end, ":");
    int h2 = Integer.parseInt(tok.nextToken());
    int m2 = Integer.parseInt(tok.nextToken());
    int s2 = 0;
    if (tok.hasMoreTokens())
      s2 = Integer.parseInt(tok.nextToken());

    total += computeInterval(h1, m1, s1, h2, m2, s2);
  }

  return total;
}

Problem 4: Write a method called blankCount that, given the name of a file as an argument, returns the number of blank lines in the file. If the file does not exist, blankCount should return 0. If any other error occurs when reading from the file the method should use System.err.println to display an error message and then call System.exit(0) to terminate the program. blankCount must not throw any exceptions back to the caller.

public int blankCount(String fname)
{
  try {
    BufferedReader in = new BufferedReader(new FileReader(fname));

    int count = 0;

    String line;
    while ((line = in.readLine()) != null)
      if (line.length() == 0)
        count++;

    return count;
  }
  catch (FileNotFoundException e)
  {
  }
  catch (IOException e)
  {
    System.err.println("Error reading file " + fname);
    System.exit(0);
  }

  return 0;
}

Problem 5: Consider the following recursive definition of the factorial function.

public static int factorial(int n)
{
  if (n == 0)
    return 1;

 else if (n < 0)
    throw new IllegalArgumentException();

  else
    return n * fact(n - 1);
}

• What happens if we make the call fact(-1)? An infinite recursion that is stopped by a StackOverflowException.
• Modify the code so that if the parameter is negative it throws an IllegalArgumentException. See code above.

Problem 6: Consider the following recursive function.

public static int aCount(int n)
{
  if (n < 2)
    return 0;
  else
    return 1 + aCount(n - 1) + aCount(n - 2);
}

• What value does aCount(1) return? 0
• What value does aCount(2) return? 1
• What value does aCount(10) return? 88

Problem 7: Let w₀ = 2, w₁ = w₂ = w₃ = 1, and, for k > 3, w_k = 2 if w_k-1 = w_k-2 = w_k-3 = 1 and w_k = 1 otherwise. Write a recursive method that computes w_k.

public int w(int k)
{
  if (w == 0)
    return 2;
  else if (w <= 3)
    return 1;
  else if (w(k - 1) == 1 && w(k - 2) == 1 && w(k - 3) == 1)
    return 2;
  else
    return 1;
}

Problem 8: The following code fragment reads lines from a file and then displays those that are of above average length.

String[] file = new String[100];
ArrayList file = new ArrayList();
int lineCount = 0;
int totalLength = 0;

String line;
while ((line = in.readLine()) != null)
{
  file[lineCount] = line;
  file.add(line);
  totalLength += line.length();
  lineCount++;
}

double average = (double)totalLength / lineCountfile.size();

for (int l = 0; l < lineCountfile.size(); l++)
  if (file[l].length() ((String)(file.get(l))).length() > average)
    System.out.println(file[l]file.get(l));

• Rewrite the code to use an ArrayList instead of an array of Strings. Assume that in is a BufferedReader that has been initialized correctly to read from the file. See code above.
• List at least one advantage of using an ArrayList instead of an array of Strings. (Hint: what happens for large files in the original code?) The original code will crash with an ArrayIndexOutOfMoundsException if the input file is over 100 lines long. The new version will work as long as the file will fit in memory..
• Would a LinkedList work just as well as an ArrayList? Explain. A LinkedList would provide faster adds but slower gets. If we used a LinkedList we would want to use an Iterator to go through the lines in the list instead of using get.