Design and write pseudocode using a repetition structure
Design and write Java for a class, including attributes, accessors, mutators, and
va for a class, including attributes, accessors, mutators, and constructors.
Design and write Java for an application program that instantiates and uses objects of a user-defined class.
Use the repetition structure in class methods and application program modules.
Perform error checking.
Use a graphical drawing program (ArgoUML) to create class diagrams.
Directions for completing and submitting the homework:
You will be submitting the following files:
Pseudocode written with Word, Notepad++, or similar application
The application class created in 3b below
The UML class diagram created in ArgoUML, Raptor, or similar application
Write the pseudocode needed to complete Chapter 5, number 9 – Pennies for Pay.
Implement Pennies for Pay in Java.
The Secondhand Rose Resale Shop is having a seven-day sale during which the price of any unsold item drops 10 percent each day. Design a class diagram showing the class, the application program, the relationship between the two, and multiplicity. Then write the Java code as described below. Be sure to follow the CSI 117 Style Criteria (Links to an external site.) for naming conventions, class diagrams, pseudocode, keywords, and operators.
An Inventory class that contains:
an item number and the original price of the item. Include the following:
A default constructor that initializes each attribute to some reasonable default value for a non-existent inventory item.
Another constructor method that has a parameter for each data member, called the overloaded constructor. This constructor initializes each attribute to the value provided when an object of this type is instantiated. Be sure to incorporate adequate error checking for all numeric attributes.
Accessor and mutator methods for each attribute. Be sure to incorporate adequate error checking for all numeric attributes.
Extra credit for including Javadoc comments.
An application program that contains two methods: the main() module and the printSaleData()module.
The main()module must do the following:
create an Inventory object using the default constructor
use a loop to get inventory items from the user. The user should enter the item number and the original price of the item. This loop should continue until the user indicates that they have no more items to enter. For each item entered by the user, the code inside the loop should do the following 2 items:
set the attributes of the Inventory object by calling the appropriate method in the Inventory class for each item entered by the user
send the Inventory items, one at a time, to the printSaleData() module for processing
Extra credit for including Javadoc comments.
The printSaleData()module must accept an Inventory object and produce a report that shows the item number and the price of an inventory item on each day of the sale, one through seven, using a loop. For example, an item with an original price of $10.00 costs 10 percent less, or $9.00, on the first day of the sale. On the second day of the sale, the same item is 10 percent less than $9.00, or $8.10.
2.You will implement a version of the cuckoo hash table. Your cuckoo hash will operate as follows
You will use
You will use a single backing array(instead of two) and two hash functions (both MultiplicativeHashFunction objects), h1 and h2.
The z values for your hash functions (and all subsequent hash functions needed when resizing or rehashing) will be taken from an array of integers passed to the CuckooHashTable constructor. The first value in the array will be used for the first incarnation of h1, the second value for the first incarnation of h2, the next two values will be used for the next incarnations of h1 and h2, etc.
Note: be careful to follow this. We will be checking your array (via toString()) and correctness will depend on using the same values of z as we do when generating the test code. The MultiplicativeHashFunction objects you will use also have a getParams() method to show the value of z,w,d when that hash function is used.
When adding an item, x, that is not in the hash table already, always add it to t[h1(x)] (even if t[h1(x)] is already taken and t[h2(x)] is available).
The load factor must always satisfy α=n/t.length≤1/2. If adding an item will violate this then resize the table (doubling its size) and rehash everything (before doing the add).
After removing an item, if the load factor satisfies α=n/t.length<1/8 AND the dimension satisfies d≥5 then resize by reducing the size of the bucket table by a factor 2 and rehash everything.
Each time you resize you will create two new hash functions using the next two z values (that were initially passed to the constructor).
Your constructor should initialize an empty bucket array of size 16 (i.e., d=4). This is the minimum size your bucket array should ever be. Never let the dimension be smaller then 4.