代写program、代做Java设计编程

日期：2023-10-06 11:31

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.