113105 Software development 1

Q:

In Figure 432, “Example: int array of primes ” a final variable primes is being declared. Despite the final modifier denoting constant values we see a whole bunch of assignments i.e. primes[0] = 2. Give an explanation.

Q:

Consider an array of strings. As an example we provide a list of country names:

final String[] countries = {
        "England"
        ,"France"
        ,"Germany"
};

An application is supposed to generate the following output:

<ul>
  <li>England</li>
  <li>France</li>
  <li>Germany</li>
</ul>

Implement A class method strings2html(final String [] strings) as in:

public class Stringarray2Html {

  /**
   * Create an unordered ...
   *  ...
   */
  static public String strings2html(final String [] strings) {
    ...
    return ...;
  }
}

Do not forget to provide appropriate Javadoc™ method and class documentation. You may want to reconsider Figure 296, “Maven javadoc:javadoc ”.

Generating Javadoc™ HTML documentation from your project should yield a result like:

Provide appropriate unit tests covering at least:

Q:

We want to estimate the amount of time being required driving a particular route. Consider the following example:

The route above may be dissected into several legs:

Each leg may have a different speed limit. We thus define:

public class Segment {

   /**
    * Indication a segment does not have any speed limit.
    */
   static public final int NO_SPEED_LIMIT = 0;

   /**
    * The distance of the current leg in km.
    */
   public final double distance;

   /**
    * The current leg's speed limit in km / h.
    */
   public final int speedLimit;

   /**
    * Creating an (immutable) leg
    * @param distance {@link #distance}
    * @param speedLimit {@link #speedLimit}
    */
   public Segment(final double distance, final int speedLimit) {
      this.distance = distance;
      this.speedLimit = speedLimit;
   }
}

A given route will be defined by an array of segments:

final Segment[] route = new Segment[] {
   new Segment(2.4, 50)
  ,new Segment(5, 100)
  ,new Segment(3.1, 50)
  ,new Segment(0.8, 30)
};

Implement a method duration(...) which allows for calculation the minimum expected time required with respect to speed limits along a given route.

/**
 * Minimal time required when consequently traveling with the minimum of
 * official speed limits and the driver's personal maximum speed. If a
 * leg does not have any speed limit the value of personalSpeedLimit will
 * be used for calculation instead.
 *
 * @param route The array of segments composing a route.
 *
 * @param personalSpeedLimit The drivers personal speed limit whether or
 *        not official limits apply. Must be greater than 0.
 *
 * @return The minimal duration in (rounded) minutes with respect to all
 *         speed limits. Must be a positive (non-zero) value.
*/
static public long duration(Segment[] route, int personalSpeedLimit) {
  return 0; // TODO
}

Write Junit tests to cover different situations.

public class Driver {
   /**
    * @param args unused
    */
   public static void main(String[] args) {

      final Segment[] route = new Segment[] {
            new Segment(2.4, 50)
            ,new Segment(5, 100)
            ,new Segment(3.1, 50)
            ,new Segment(0.8, 30)
      };
      ...

      final long fullMinutes = ...;

      System.out.println("Minimal duration:" + fullMinutes);
}

Q:

Consider an examination resulting in the following list of marks:

You may represent this examination result by:

final int[] marks = {2,1,3,3,5,4,1,2,2,4,3,2,3,3,1,5,3,4};

Lecturers and participants may be interested in the distribution of marks i.e. their frequencies. Thus having marks in a range from 1 to 5 in the given example we'd like to create the following overview of marks:

Write a Java™ application turning an array of participants' marks into the above table of marks among with their respective frequencies. For the given example the intended terminal output reads:

Mark|frequency
————+—————————
   1|3
   2|4
   3|6
   4|3
   5|2

Your application shall work for other marking schemes (i.e. marks ranging from -2 to 10) as well. Define a suitable class like:

public class MarkFrequencies {

  public final int[] frequencyByMark;
  public final int lowestMarkValue;

  public MarkFrequencies(final int[] markValues) {
    ...
  }
}

The constructor assigning values to both lowestMarkValue and frequencyByMark and is not yet implemented. Upon completion you may use class MarkFrequencies for producing the previously detailed terminal output:

final MarkFrequencies markFrequencies =
    new MarkFrequencies(new int[]{2,1,3,3,5,4,1,2,2,4,3,2,3,3,1,5,3,4});

// Create overview of marks:
//
System.out.println("Mark|frequency");
System.out.println("————+—————————");

for (int i = 0; i < markFrequencies.frequencyByMark.length ; i++) {
  System.out.println("   " + (markFrequencies.lowestMark + i) + "|" +
    markFrequencies.frequencyByMark[i]);
}

Provide appropriate unit tests beforehand.

After implementing your method extend your application to allow for being called from the command line like:

marking> mvn package
  ....
marking> java -jar target/marking-0.9.jar 2 1 3 3 5 4 1 2 2 4 3 2 3 3 1 5 3 4

Mark|frequency
————+—————————
   1|3
   2|4
   3|6
   4|3
   5|2

This requires evaluating the args parameter from your main(String[] args) method.

Q:

A pangram is a string containing all letters of a given alphabet at least once. As an example we consider the alphabet of ASCII letters {'a', 'b', ..., 'z'} ignoring case. Then the following string is a pangram: