代做Program Description

Program Description:
This assignment focuses on arrays, strings, loops, and methods. Complete the method stubs
found in the file named Plates.java. You will also need to use the text file
plates.txt to test your work. This assignment is intended to test your knowledge of
basic array manipulation, Character methods (isDigit, isLetter, etc.), and
String object methods (substring, charAt, indexOf, replace, toUpperCase, and
toLowerCase, etc.). You are not allowed to use more advanced/specialized collections
or imported classes.
You should limit yourself to the Java features covered in class so far (lecture 7).
Modularity in your code is very important, YOU MUST USE STATIC METHODS.
Background Information:
You have just been hired as a programmer for the Massachusetts
Registry of Motor Vehicles (RMV). The RMV is responsible for
issuing license plates, which uniquely identify all vehicles legally
allowed to drive on public roads. There are a number of tasks the
RMV would like you to automate. But first, get ready to learn
more about license plates than you ever wanted to know!
PROGRAMMING ASSIGNMENT
Serial Formats
The serial format is an important feature of license plate issuance.
Serial formats are alphanumeric strings denoting the position and
number of characters to be printed on the plate. For example, one
basic format is ABC123 — denoting that the first three characters
of the plate must be uppercase letters, and the last three must be
numbers. To the right is an example of a Massachusetts license
plate with the serial format 123AB4.
One unique feature of Massachusetts license plates is that the very last number is coded to
correspond with the month that the vehicle expires. So, you can see that the plate above,
which ends with a 2, also must expire in the month of February. This trick allows police
officers to quickly identify whether a vehicle’s registration is expired by comparing the last
digit on the plate with the color of the year sticker. A final digit of 0 corresponds to
registration in the month of October. Passenger vehicles registered in November and
December typically will be assigned plates from manufacturing overruns of other months.
(In Massachusetts, vanity plates expire in November, while commercial plates expire in
December.)
When a new serial number is adopted, the very first plate in the series is issued according
to the following rule: (1) The first number is a 1, (2) all other numbers are set to 0, and (3)
all letters are set to A. For example, the very first plate of the 123AB4 serial format would
be 100AA0. To issue new plates in an orderly fashion, the current plate number is
incremented. The very last plate in the 123AB4 serial format then would be 999ZZ9. Once
every number in the serial format has been used, a new serial format must be adopted.
For this assignment, you will be working with four different serial formats used in
Massachusetts since 1993: 12AB34, 123AB4,,1AB234, and 1ABC23.
Vanity Plates
There are specific rules regarding vanity plates in
Massachusetts:
1. All vanity plates must start with at least two
letters.
2. Vanity plates may contain a maximum of six
characters (letters or numbers) and a minimum of
two characters.
3. Numbers cannot be used in the middle of a plate;
they must come at the end. For example, AAA222
would be an acceptable Passenger vanity plate;
AAA22A would not be acceptable. The first number used cannot be a "0."
4. No periods, spaces, or punctuation marks are allowed.
Tasks:
To complete this assignment, implement the method stubs in plates.java according
to the specification given below. Unless otherwise noted, assume that you are dealing
with passenger plates with serial formats of exactly six characters.
public static String createRandomPlate(String serial, int
month) — Given a string representing a serial format and an integer corresponding to
the month of vehicle expiration, return a randomly generated plate adhering to the serial
format.
• Assume that the input consists of a legal serial format string.
• Output strings must contain only numbers and capital letters, i.e., characters in the 0-9
and A-Z range.
• The first character cannot be a zero.
createRandomPlate("123AB4", 9); // returns, for example, "319ZB9"
public static String nextPlate(String plate) — Given a string
representing a license plate, return a new string representing the incremented, next plate in
the series.
• Assume that the input consists of a legal and correctly formatted plate string.
• If the input represents the very last plate in the series, and cannot be legally
incremented, return the following string: "error".
nextPlate("215BG2"); // returns "215BG3"
nextPlate("399ZZ9"); // returns "400AA0"
nextPlate("999ZZ9"); // returns "error"
public static String getSerial(String plate) — Given a plate string,
return a string corresponding to the serial format of that plate.
getSerial("215BG2"); // returns "123AB4"
public static boolean isLegalVanityPlate(String plate) — Given
a plate string, return a boolean value denoting whether the plate is a legal vanity plate
according the rules given above.
• The rule must be case sensitive; inputs with characters other than A-Z or 0-9 should
not be considered legal.
String plate1 = "LOBSTA";
String plate2 = "AAA22A";
isLegalVanityPlate(plate1); // true
isLegalVanityPlate(plate2); // false
public static float[] getMonthStats(String[] plates) — Given
an array of plate strings, return an array of floats corresponding to the frequency
percentage of each expiration month.
• Test your work using the provided readPlatesfromFile method, along with
the plates.txt file. Assume that all inputs are legal and correctly formatted.
• The output should be a size-ten array of floats. The zero-index position of the array
corresponds to the month of October. The rest of the indices, 1-9, correspond to
January through September. The values should sum to 1.0.
String[] plates = new String[] {"215BG2","399ZZ2","399ZZ3","1ABC21"};
getMonthStats(plates);
// returns [0.0, 0.25, 0.5, 0.25, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
public static float[] getSerialStats(String[] plates,
String[] serials) — Given an array of plate strings and an array of serial format
strings, return an array of floats corresponding to the frequency percentage of each serial
format.
• Test your work using the provided readPlatesfromFile method, along with the
plates.txt file. Assume that all inputs are legal and correctly formatted.
• plates.txt contains plates adhering to the following serial formats: 12AB34,
123AB4,,1AB234, and 1ABC23.
• The output array should be the same length as the input array of serial format strings.
The values of the output should be the same order as the serial format input. The values
should sum to 1.0.
String[] plates = new String[] {"215BG2","399ZZ2","399ZZ3","1LLC21"};
String[] serials = new String[] {"12AB34","123AB4","1AB234","1ABC23"};
getSerialStats(plates, serials); // returns [0.0, 0.75, 0.0, 0.25]
public static String[] matchPlate(String partial, String[]
plates) — One very practical use of software is for license plate matching. Image
that someone has seen a person in a car commit some crime, such as a hit-and-run. As the
car drives off, the witness is able to catch a part of it, but not the entire plate. (“It began
with a 39, and ended with Z3.”) Your task here is to use this information to identify likely
offenders by searching an array of license plates.
In this case, the partial string is represented such that each substring is separated by a
dash. (E.g., "39-Z3"). Assume no more than two partial substrings. Given a partial string
and an array of plate strings, return an array of strings corresponding to the plates that
match.
• The output array should consist only of valid plate strings—null values are not
allowed.
• “Overlapping” substrings should not be counted. For example, a partial string input of
39-9A should not return a license plate of 39AF65.
• Test your work using the provided readPlatesfromFile method, along with
the plates.txt file. Assume that all inputs are legal and correctly formatted.
String partial = "39-Z3";
String[] plates = new String[] {"215BG2","399ZZ2","399ZZ3","1LLC21"};
matchPlate(partial, plates); // returns ["399ZZ3"]
partial = "39-ZZ";
matchPlate(partial, plates); // returns ["399ZZ2", "399ZZ3"]
Grading:
You will be graded on
• External Correctness: The output of your program should match exactly what is expected.
Programs that do not compile will not receive points for external correctness.
• Internal Correctness: Your source code should follow the stylistic guidelines linked in
LATTE. Also, remember to include the comment header at the beginning of your program.
Submission:
You are required to use the Eclipse IDE. Use Eclipse (Refactor > Rename) to name your project
Lastname_FirstnamePAX (please make sure to use exactly this file name, including identical
capitalization). Then use Eclipse’s export procedure; otherwise, a penalty will be applied, as our
automated tests will fail to function.

Java Docs
Before every one of your Classes and methods, you add a Java Doc comment. This is a very easy
way to quickly comment your code while keeping everything neat.
• The way to create a Java Doc is to type:
/** + return/enter
• This should create:
/**
*
*/
• Depending on your method, the Java Doc may also create additional things, such as @param,
@throws, or @return. These are autogenerated, depending on if your method has parameters,
throw conditions, or returns something. You should fill out each of those tags with information
on parameter, exception, or return value. If you want to read more on Java Docs, you can find
that here, or also refer to the end of Recitation 1 slides. Also, add line specific comments to the
more complicated parts of your code, or where you think is necessary. Remember, you should
always try to write code so that someone else can easily understand it.