Results 1 to 6 of 6
  1. #1

    Complete a easy JAVA assignment for $500

    Hi,
    I am reprsenting a group of business students. We are having difficulities completeing a school java programming assignment. 7 of us chipped in $500 USD, to pay for anyone who can complete this assignment for us.

    Please PM me for more details, we are desprate, and willing to negociate.

    Attached is a zip file that contains required java files.

    Must be completed before Sept 28th 11:00pm.

    Thanks.


    #########################################
    Specifications

    Undoable Sorted Arrays
    In this assignment, you will write another dynamic array, but with two major differences from the previous assignment. First, this array will always be in (ascending) sorted order, and may not contain any duplicates. Second, you will use a stack to implement an undo feature. Any destructive operation that you do to this array can be undone. This undo feature might be useful in applications that allow the user to undo changes they've made.

    Object methods can be classified as either mutating, or non-mutating. A mutating method (sometimes called a mutator) alters the state of the object, while a non-mutating method does not change the object's state in any way. For example, deleting a slice is a mutating operation because it changes the values that are in the array, while binary search is a non-mutating method since it doesn't change the array it's searching. For this assignment, you will implement the SortedArray interface that has both mutating and non-mutating methods. You will also be asked to implement the undo function in the Undoable interface.

    The Undoable interface has only one method, called rollback(), that restores the array to the state it was in just before the most recent call of one of its mutator methods. The array will track every change that is made to it, so if you call undo enough times you can return the array to its original state just after it was created.

    To implement the undo functionality, use a stack to save the relevant state of the object. Essentially, every mutating method must be modified to first push the current state (e.g. the values of all the private variables) onto a stack. It's vital that this be done before the mutator makes any changes to the state of the object. To undo a change, replace the current state of the object with the state popped from the top of the stack.

    What to Hand In
    For this assignment, you are asked to do the following:

    Write a dynamic array class that implements the SortedArray interface in the file SortedArray.java. The underlying implementation of this array must be an array of Comparable. Do not use any collection or list classes from Java (or any other source), or the class you implement in the previous assignment.

    In addition to the SortedArray interface, your class must also implement the Undoable interface found in the file Undoable.java. This contains a single method signature called rollback() that is used to undo the most recent mutating method call to the object.

    Write a stack class that implements the StackInterface class in the file Stack.java. Use this stack to implement the undo functionality of rollback().

    In addition to implementing all the methods of the two interfaces, your array must have a constructor that takes one int parameter, as shown below. Your class should look like this:
    public class MyDynamicArray implements SortedArray, Undoable {

    // PRE: n >= 0
    // POST: creates a SortedArray of length n, with initial
    // values 0 to n - 1, i.e. the first item is 0, the second
    // item is 1, the third item is 2, etc.
    // EXAMPLE:
    // MyDynamicArray p = new MyDynamicArray(5);
    // System.out.println("" + p);
    // // prints "[0,1,2,3,4]"
    // NOTE: If n is 0, then an empty object is created, i.e. a DynamicArray
    // of length 0.
    public MyDynamicArray(int n)
    {
    }

    // ...
    } // class MyDynamicArray

    As always, make your source code should be well-commented, and extremely easy to read. Please use self-descriptive variable names, reasonable and consistent indenting, in-line comments, etc.

    Please, only submit .java files. Do not put them in a folder, or a zip archive. Just submit plain text files.


    Marking Scheme
    10%: source code style, and following all implementation instructions

    10%: for providing a test class that thoroughly tests all the SortedArray methods

    10%: the program has no major inefficiencies, i.e. its memory use and running time are minimal

    10%: for writing a stack class that implements the Stack interface

    40%: for writing a dynamic array class that correctly implements the SortedArray interface

    20%: for correctly implementing the Undoable interface in your dynamic array class

    Marking Scheme Notes
    The SortedArray and Stack classes you submit should not print anything to the screen. However, you may find it useful to print debugging messages while you are writing the program, but all print statements should be removed in your final version.

    Your program will be tested on a variety of test cases, including invalid input. Whenever a method's input does not meet its PRE-condition, then the method should throw a RuntimeException (see the Java documentation for more details). Your method will be considered incorrect if, for instance, it merely exits or prints and error message.

    Your SortedArray should store only Comparable objects, i.e. objects that implement Java's Comparable interface. This is necessary to allow it to be sorted.

    If your program does not compile, then that is an automatic deduction of at least 50%. The marker may briefly try to fix your program. If the marker can't get your program to compile, then you will only be eligible for source style and documentation marks (i.e. things unrelated to whether or not your souce code compiles). However, keep in mind that it is not the markers job to debug your program.

    If two or more people submit what appears to be substantially identical code, then each will get 0. The marker will not waste time trying to figure out who copied and who didn't.

    Due Date
    The exact due date for this assignment is listed on-line. Please submit it on-line. Late assignments will not be marked.

    Extensions will only be granted in special circumstances. Normally, a doctors note, or the equivalent, must be shown.

    Hints
    Use assertions, loop invariants, and pictures.

    Build new functions out of old ones.

    Do lots of testing as you go. Test the functions one at a time, and don't start the next function until all the currently implemented ones work correctly. This may sound like a lot of work, but it tends to save time overall, and it produces higher-quality code with fewer bugs. Save your testing code in a test class so that you can submit it with your assignment.

    Feel free to add your own favourite functions to your dynamic array class. Just make sure you still properly implement the interfaces requested in this assignment. We will only test and mark methods in the SortedArray and Undoable interfaces.

    The method described in this assignment for making an undoable object is simple and general, but it can be quite wasteful of memory for large arrays. We will just live with this inefficiency for now, but it is possible to make undoing operations more space-efficient by saving the sequence of operations, as opposed to the different version of the objects themselves.

    Notice that Undoable is not tied in any way to the SortedArray interface, so any class at all could implement it.
    Attached Files Attached Files

  2. #2
    Join Date
    Aug 2002
    Location
    Australia
    Posts
    297
    try posting this at kasamba.com .. you'll save yourself a few hundreds...and they are professionals.
    Banner Design - Professional Designs - 24hr Turn-Around Guaranteed - 20DollarBanners.com

    Online Photo Editor
    Retouch or Add effects to your photos with 1 click

  3. #3
    Join Date
    Jul 2002
    Posts
    541
    This is an awesome idea. Never thought to do something like this to get a project done.

    The group projects they give at school are to get you to learn how to work in a group - and that it did!!

    A for ingenuity!

    Note that I am not commenting about any ethicality here.

    -WC-

  4. #4
    and with these offers some people miss the work they should do,

    and some people do more work than they should do

    p.s. i am exsausted after working for a year on Kasamba
    █ Quickly check if a site is down or not - http://down.is
    █ Remote & easy to use ... down.is/webhostingtalk.com

  5. #5
    Join Date
    Jan 2002
    Posts
    453
    hehe what's funny is that this could be done in max 5 hours.. about the right rate for a java programmer hehe.

    but what's the assurance that the programmer will get paid? If you sign my contract agreement, i'll have it in you mail box the next day.

    (realistically speaking, 30 mins is all you need, go to google and search for some examples.. or get some oreilly books)

  6. #6

    solution

    you get source code when I get cash...
    Attached Files Attached Files

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •