Java Amend the LinkedList so that 1 Your list classes must.pdf
•
0 likes•2 views
Java Amend the LinkedList so that: 1. Your list classes must be generic (see below) and be able to work with any Comparable data. Be sure to genericize any static methods, e.g. printList() would become: public static <AnyType extends Comparable<? super AnyType>> void printList( YourLinkedList<AnyType> theList ) 2. The list is always maintained in ascending order so as each item is added to (or removed from) the list, it must be put in its proper place in the list just like in Assignment 1. This will be handled by a new method, add(), that takes in a lone parameter (the data object to be inserted - you do not pass in an iterator like you do with insert().) Duplicate values are allowed in the list. 3. Change the insert() method to private visibility. 4. Add a method named replace() that takes in two parameters (the data object to replaced, followed by the one to be inserted) that will remove the first occurrence of the item to be replaced and add the second parameter to the list. The method returns a boolean - true if the item to be replaced was found, false if not. If the value to be replaced is not present, do not perform the add. 5. Add an instance method named showList() (no parameters or return value) that will extract all of the values from the list and display them in order, one per line, followed by another line displaying how many values are currently in the list. If the list is empty, display the message The list is currently empty instead. 6. Overload showList() with an integer parameter which represents how many items to display on each line. The method needs to newline after the last item no matter how many items were displayed (i.e. dont leave the cursor hanging.) 7. As with Assignment 1, add an instance method named getMode() that functions the same as the version in Assignment 1. Reuse the same interface but change the package to the one designated below. 8. Add a method named author() that returns a String consisting of your name. 9. Revise and do not subclass the Weiss classes. Do not make your classes part of any package other than the one specified below for this assignment. That package should consist only of the four classes (list, iterator, node, result) used in this assignment..
Report
Share
Report
Share
Download to read offline
Recommended
There are a couple of new methods that you will be writing for this pr.pdf
There are a couple of new methods that you will be writing for this project. Some are easy, some
are hard. I have provided code that tests most of the methods by calling them from the main
method in the file ListTest.java. The test file will only work when you have done all the
methods. In COMP182LinkedList.java I have provided the signature (definition and input
parameters) for these methods. At this point to make sure you can run the file
(COMP182LinkedList.java that you downloaded from Cavas) I have added template values as
return types of the methods. For example, if the method returns an int then I added return 0 as the
return value. Here are the methods are as follows: Anything getFixst () Anything getLast () void
add (Anything value) void addafter (1nt index, Anyehtng value) Anything set(int index,
Rnything aewvalue) void removeAl1 (Anything vaiue) lastIndex (Anything value)
COMP182IinkedIi ateAnything; elone boolean equala (object in) CoMP182IinkedList
KAnythang? gplat () boolean hascycle () Node reveraeliat () Node oddeventiat () Node
deleteDuplicates () boolean ispalindrome () "For the last two methods, you need to add proper
testing to ListTest Java Method Specifications Here are more details for implementing each of
these methods. You need to complete all the following methods in the COMP182LinkedList
class. You can write the methods in any order you wish, but I suggest you do them in the order
they are listed. In particular, make sure all your methods work for empty lists, lists of different
sizes, etc as you can see from the sample test cases provided in ListTest.java. While grading your
project, we will make changes to these values! Also, make sure that your solutions do not modify
the original lists (unless you are specifically instructed to do so). roid main(String[] args) You
can use this method in the ListTest class to create lists as needed and test each of the methods
listed above. I have provided a few test cases, but you may want to add more to some of the
method tests. Until you get add working, you will need to use addFirst to create lists to test your
other methods. Anything getFirsto This method returns the value stored in the first node an the
list. It should prit an error message and seturn null if the list is empty. Anything getLasto This
method returns the value stored in the last node in the list. It should print an error mesiage and
retuin noll if the list is emipty. void add(Anything value) Thus method adds a nade containing
new yalue to the end of the last. This method returns the value stored in the first node in the list.
It should print an error message and return null if the list is empty. Anything getLast0 This
method returns the value stored in the last node in the list. It should print an error message and
retum null if the list is empty: void add(Anything value) This method adds a node containing
new value to the end of the list. void addAfter(int index, Anything value) This method adds a
node contai.
Please and Thank youObjective The purpose of this exercise is to .pdf
Please and Thank you
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below
in your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list
with the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node in the list.
last is a reference variable for the last Node in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a ne.
Objective The purpose of this exercise is to create a Linked List d.pdf
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below
in your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list
with the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node in the list.
last is a reference variable for the last Node in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, i.e. a st.
Collections Api - Java
Core Java - Collections API - Methods of Traversing - Interfaces - MAP - SET - LIST - QUEUE and all its subtypes and methods.
Implementation The starter code includes List.java. You should not c.pdf
Implementation The starter code includes List.java. You should not change anything in List.java.
Your task will be to create LinkedList.java, make LinkedList use generics and inherit from List,
and complete several methods in LinkedList.java. Create LinkedList.java in IntelliJ. Add a main
method to LinkedList.java containing the following code. Your program will not compile again.
public static void main(String[] args) { LinkedList list = new LinkedList();
System.out.println(list.getHead()); System.out.println(list.getTail()); list.add("first");
list.add("middle"); list.add("last"); System.out.println(list.getHead().value);
System.out.println(list.getTail().value); System.out.println(list); } The first issue is that your
LinkedList class does not have a way of specifying what type of data it should store. You can fix
this using Java Generics. Change the first line of your class to the following: LinkedList .
Confirm that the first line in your main method no longer has an error. On the line that declares
the LinkedList class, add extends List before the bracket that begins the class. The first line in
your class will now have a compile error because LinkedList does not implement the methods
required by the List abstract class. Press Ctrl-i to have IntelliJ insert stubs of these methods.
Ensure that Copy JavaDoc is selected so you get JavaDoc comments which describe the method
requirements, then click OK. Your code should now compile again. Next add fields for the head
and tail. These will be of type Node. Create a getHead method which returns your head field, and
a getTail method which returns your tail field. Run your main method now and you will see that
there is a NullPointerException because the add method does not actually add anything to the
list, so head and tail will always be null. Complete the method boolean add(T value) for which
IntelliJ gave you a stub. You need to create a new node with value to add at the end of the list.
This means you will need to connect it to the old tail and update tail to point to the node you
created. Make sure that you handle the case where the list is empty and both head and tail should
be set to the new node you've created. Note: For the full Map I assignment, add will need to
prevent duplicate values being added to the list and should return true or false based on whether
the value was added or not. For this lab, you can ignore this requirement and simply return true.
Add a toString method to your LinkedList class. It should start at the head of your list and
proceed through all the nodes in a loop, combining the values of each node with a comma
between each and square brackets containing the whole thing. When you run your main method,
the final thing printed should be: [first, middle, last] List.java: /** * Specification for a List
ADT. * @author Shubham Chatterjee * @version 03/07/2019 * @param Type */ public abstract
class List { /** * Appends the specified value to the end of this list. * * @para.
Linked List Objective The purpose of this exercise is to cr.pdf
Linked List
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a ne.
Objective The purpose of this exercise is to create a Linke.pdf
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, .
Recommended
There are a couple of new methods that you will be writing for this pr.pdf
There are a couple of new methods that you will be writing for this project. Some are easy, some
are hard. I have provided code that tests most of the methods by calling them from the main
method in the file ListTest.java. The test file will only work when you have done all the
methods. In COMP182LinkedList.java I have provided the signature (definition and input
parameters) for these methods. At this point to make sure you can run the file
(COMP182LinkedList.java that you downloaded from Cavas) I have added template values as
return types of the methods. For example, if the method returns an int then I added return 0 as the
return value. Here are the methods are as follows: Anything getFixst () Anything getLast () void
add (Anything value) void addafter (1nt index, Anyehtng value) Anything set(int index,
Rnything aewvalue) void removeAl1 (Anything vaiue) lastIndex (Anything value)
COMP182IinkedIi ateAnything; elone boolean equala (object in) CoMP182IinkedList
KAnythang? gplat () boolean hascycle () Node reveraeliat () Node oddeventiat () Node
deleteDuplicates () boolean ispalindrome () "For the last two methods, you need to add proper
testing to ListTest Java Method Specifications Here are more details for implementing each of
these methods. You need to complete all the following methods in the COMP182LinkedList
class. You can write the methods in any order you wish, but I suggest you do them in the order
they are listed. In particular, make sure all your methods work for empty lists, lists of different
sizes, etc as you can see from the sample test cases provided in ListTest.java. While grading your
project, we will make changes to these values! Also, make sure that your solutions do not modify
the original lists (unless you are specifically instructed to do so). roid main(String[] args) You
can use this method in the ListTest class to create lists as needed and test each of the methods
listed above. I have provided a few test cases, but you may want to add more to some of the
method tests. Until you get add working, you will need to use addFirst to create lists to test your
other methods. Anything getFirsto This method returns the value stored in the first node an the
list. It should prit an error message and seturn null if the list is empty. Anything getLasto This
method returns the value stored in the last node in the list. It should print an error mesiage and
retuin noll if the list is emipty. void add(Anything value) Thus method adds a nade containing
new yalue to the end of the last. This method returns the value stored in the first node in the list.
It should print an error message and return null if the list is empty. Anything getLast0 This
method returns the value stored in the last node in the list. It should print an error message and
retum null if the list is empty: void add(Anything value) This method adds a node containing
new value to the end of the list. void addAfter(int index, Anything value) This method adds a
node contai.
Please and Thank youObjective The purpose of this exercise is to .pdf
Please and Thank you
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below
in your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list
with the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node in the list.
last is a reference variable for the last Node in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a ne.
Objective The purpose of this exercise is to create a Linked List d.pdf
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below
in your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list
with the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node in the list.
last is a reference variable for the last Node in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, i.e. a st.
Collections Api - Java
Core Java - Collections API - Methods of Traversing - Interfaces - MAP - SET - LIST - QUEUE and all its subtypes and methods.
Implementation The starter code includes List.java. You should not c.pdf
Implementation The starter code includes List.java. You should not change anything in List.java.
Your task will be to create LinkedList.java, make LinkedList use generics and inherit from List,
and complete several methods in LinkedList.java. Create LinkedList.java in IntelliJ. Add a main
method to LinkedList.java containing the following code. Your program will not compile again.
public static void main(String[] args) { LinkedList list = new LinkedList();
System.out.println(list.getHead()); System.out.println(list.getTail()); list.add("first");
list.add("middle"); list.add("last"); System.out.println(list.getHead().value);
System.out.println(list.getTail().value); System.out.println(list); } The first issue is that your
LinkedList class does not have a way of specifying what type of data it should store. You can fix
this using Java Generics. Change the first line of your class to the following: LinkedList .
Confirm that the first line in your main method no longer has an error. On the line that declares
the LinkedList class, add extends List before the bracket that begins the class. The first line in
your class will now have a compile error because LinkedList does not implement the methods
required by the List abstract class. Press Ctrl-i to have IntelliJ insert stubs of these methods.
Ensure that Copy JavaDoc is selected so you get JavaDoc comments which describe the method
requirements, then click OK. Your code should now compile again. Next add fields for the head
and tail. These will be of type Node. Create a getHead method which returns your head field, and
a getTail method which returns your tail field. Run your main method now and you will see that
there is a NullPointerException because the add method does not actually add anything to the
list, so head and tail will always be null. Complete the method boolean add(T value) for which
IntelliJ gave you a stub. You need to create a new node with value to add at the end of the list.
This means you will need to connect it to the old tail and update tail to point to the node you
created. Make sure that you handle the case where the list is empty and both head and tail should
be set to the new node you've created. Note: For the full Map I assignment, add will need to
prevent duplicate values being added to the list and should return true or false based on whether
the value was added or not. For this lab, you can ignore this requirement and simply return true.
Add a toString method to your LinkedList class. It should start at the head of your list and
proceed through all the nodes in a loop, combining the values of each node with a comma
between each and square brackets containing the whole thing. When you run your main method,
the final thing printed should be: [first, middle, last] List.java: /** * Specification for a List
ADT. * @author Shubham Chatterjee * @version 03/07/2019 * @param Type */ public abstract
class List { /** * Appends the specified value to the end of this list. * * @para.
Linked List Objective The purpose of this exercise is to cr.pdf
Linked List
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a ne.
Objective The purpose of this exercise is to create a Linke.pdf
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, .
Objective The purpose of this exercise is to create a Linke.pdf
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, .
The MyLinkedList class used in Listing 24.6 is a one-way directional .docx
The MyLinkedList class used in Listing 24.6 is a one-way directional .docx
The following class stores a list of integer values and contains a met.docx
The following class stores a list of integer values and contains a method to return the smallest value in a non-empty list. Make changes and cross out old code as needed to turn this into a generic class that can be used to store lists of any element type E as long as those elements can be compared for ordering (i.e., any type E whose elements support the compareTo method). You can assume the code is adequate otherwise – you don’t need to, for example, add additional tests to guard against null values.
public class MinList f List items; ** Construct new empty list*/ public MinList () { items = new ArrayList ( ); } *add new item x to list * public void add(int x) items.add(x); /** return smallest value in a non-empty list* public int minItem() assert items.size)> e; int minValue-items.get (0); for (int val: items) if (val
Solution
import java.util.ArrayList;
public class MinList<E extends Comparable<E>> {
ArrayList<E> items;
public MinList(){
items = new ArrayList<E>();
}
public void add(E x){
items.add(x);
}
public E minItem(){
assert items.size()>0;
E minValue = items.get(0);
for(E val:items){
if(val.compareTo(minValue) < 0){
minValue = val;
}
}
return minValue;
}
}
.
Everything needs to be according to the instructions- thank you! SUPPO.pdf
Everything needs to be according to the instructions, thank you!
SUPPORTING CODE:
MyList.java
/**
This interface specifies the basic operations of any list-like object.
This interface contains a variation of the methods of the
standard java.util.List interface.
*/
public interface MyList {
/**
Adds an element at the end of the list.
*/
public void addToEnd(Object o);
/**
Inserts an element at the specified index
Throws NoSuchElementException if index is out of bounds.
*/
public void insertAt(int index, Object o);
/**
Removes the element at the specified index
Throws NoSuchElementException if index is out of bounds.
*/
public void removeAt(int index);
/**
Returns the element at the specified index
Throws NoSuchElementException if index is out of bounds.
*/
public Object getAt(int index);
/**
Returns the size of the list.
@return the number of elements in the list
*/
public int getSize();
/**
Returns a list iterator for this list.
@return a list iterator for this list
*/
public MyListIterator getIterator();
}
MyListIterator.java
/**
A list iterator allows access of a position in a list.
This interface contains a subset of the methods of the
standard java.util.ListIterator interface. The methods for
backward traversal are not included.
*/
public interface MyListIterator
{
/**
Moves the iterator past the next element.
@return the traversed element
*/
Object next();
/**
Tests if there is an element after the iterator
position.
@return true if there is an element after the iterator
position
*/
boolean hasNext();
}
Main.java
// you may use this file to write and run code to test your MyArrayList class
public class Main {
public static void main(String[] args) {
}
}
FILE THAT NEEDS THAT NEEDS CODE:
MyArrayList.java
// Complete the implementation of your MyArrayList class in this file
public class MyArrayList implements MyList {
// Implement the required fields and methods here
private int capacity = 8;
private Object[ ] array = new Object [capacity];
private int size = 0;
@Override
public void add(Object o) {
if (size >= capacity){
Object[] temp = new Object[2*array.length];
for(int i=0;i<size;++i){
temp[i] = array[i];
}
this.capacity = 2*array.length;
array = temp;
array[size++] = o;
return;
}
else
{
array[size++] = o;
}
}
@Override
public int size() {
return size;
}
@Override
public Object at(int index) {
if (index >= capacity)
return null;
else
return array[index];
}
@Override
public void insertAt(int index, Object o) {
if (index >= capacity)
return;
else
{
size++;
for (int x = size - 1; x > index; x--) {
array[x] = array[x - 1];
}
array[index] = o;
}
}
@Override
public void removeAt(int index) {
if (index >= size || size == 0)
return;
else {
Object e = array[index];
for (int x = index; x < this.array.length - 1; x++) {
array[x] = array[x + 1];
}
size--;
}
}
public void ensureCapacity(int minCapacity) {
}
public void trimToSize() {
ensureCapacity(size);
}
// Do not alter the code below
@Override
public MyListIterator getIterator() {
return new MyA.
Part B- Implementing a Sorted Linked list The class declarations has b.pdf
Part B: Implementing a Sorted Linked list
The class declarations has been created in the a1.py starter file. The data member names are
provided (but not initialized so code will not compile).
Aside from the class declaration you will find a functions called iter
You are allowed to add data members to both Node and Linked list. You are also allowed to
rename your data members BUT, if you do this, you will need to alter the iter function to match
your new data member names.
A sorted linked list is a linked list where values stay sorted from smallest to biggest. That is the
smallest value is at the front of the list while the largest is in the back.
When a doubly linked sorted list is first created it is empty.
The sorted list has the following member functions
this function inserts data into the list such that the list stays sorted. You may assume that the data
being added can be compared using comparison operators
this function finds and removes node containing data from the list. If a node containing data was
found and removed, function returns True. If no such node was found (data was not in list),
function returns False
insert(30); front_ back_.
AD3251-LINKED LIST,STACK ADT,QUEUE ADT.docx
Here's a suggestion for a description to upload your document on a website:
"Unlock the power of data structures with our comprehensive guide! Dive into the world of linked lists, Stack ADT (Abstract Data Type), and Queue ADT with our expertly curated document. Whether you're a seasoned programmer or just starting out, our resource provides clear explanations, insightful examples, and practical applications to help you master these fundamental concepts. Explore the intricacies of linked lists for efficient data storage, understand the versatility of Stack ADT for managing data in a Last-In, First-Out (LIFO) fashion, and delve into the functionality of Queue ADT for orderly data processing in a First-In, First-Out (FIFO) manner. Elevate your understanding of data structures and revolutionize your programming skills with our invaluable document. With clear explanations, illustrative examples, and practical exercises, our document equips you with the knowledge and skills needed to conquer data structure challenges with confidence. Whether you're a student embarking on your journey into computer science or a seasoned developer .Seeking to expand your repertoire, our resource is your roadmap to success.
Download our document now and embark on a transformative learning experience that will elevate your programming prowess to new heights!"
For this lab you will complete the class MyArrayList by implementing.pdf
Find the time it takes the boat to travel the given distance. A ball is thrown vertically upward
with a speed of 40.0 m/s. How high does it rise? How long does it take to reach its highest
point? How long does the ball take to hit the ground after it reaches its highest point? What is
its velocity when it returns to the level from which it started? The center of mass moves with
constant acceleration when constant forces act on the object. A gym ground. How high above
this point is her center of mass at the following times? Ignore the effects
Solution
initial velocity, u = + 40 m/s
a = - 9.8 m/s^2
(a) it will rise until its velocity becomes zero.
hence final velocity, v = 0
Applying, v^2 - u^2 = 2 a h
0^2 - 40^2 = 2(-9.8)(h)
h = 81.63 m
(B) v = u + at
0 = 40 - 9.8 t
t = 4.08 sec
(C) now for motion from highest point to ground,
initial velocity, v (velocity at highets point) = 0
displacement, y = - 81.63 m
a = - 9.8 m/s^2
applying, y = u t + a t^2 /2
- 81.63 = 0 - 9.8 t^2 / 2
t = 4.08 s
(D) applying v = u + at
v = 0 + (-9.8)(4.08)
v = - 40 m/s
(minus sign indicates that direction is downwards).
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
Class Diagram:
In the Assignment #10, you are given three files Assignment10.java, LinkedList.java, and
ListIterator.java. You will need to add additional methods in the LinkedList class in the
LinkedList.java file. The LinkedList will be tested using strings only.
Specifically, the following methods must be implemented in the LinkedList class:
(You should utilize listIterator() method already defined in the LinkedList class to obtain its
LinkedListIterator object, and use the methods in the LinkedListIterator class to traverse from
the first element to the last element of the linked list to define the following methods.)
1.
public String toString()
The toString method should concatenate strings in the linked list, and return a string of the
following format:
{ Apple Banana Melon Orange }
Thus it starts with \"{\" and ends with \"}\", and there is a space between strings and \"{\" or
\"}\". If the list is empty, it returns \"{ }\" with a space in between.
2.
public boolean isEmpty()
The isEmpty method returns true of the linked list is empty, false otherwise.
3.
public void addElement(Object element)
The addElement adds the parameter element at the parameter in the linked list in alphabetical
order. For instance, if the linked list contains {Apple, Banana, Grape}, and a user tries to add
\"Carrot\", then it should be added as:
{Apple, Banana, Carrot, Grape}.
4.
public Object removeElement(int index)
The removeElement removes the string (Object) at the parameter index and returns it. Note that
this index starts with 0 just like array indices. For instance, if the linked list contains {Apple,
Banana, Carrot, Grape} and the parameter index is 3, then \"Grape\" should be remove. If the
parameter index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
5.
public Object getElement(int index)
The getElement searches the string (Object) at the parameter index and returns it. Note that this
index starts with 0 just like array indices. For instance, if the linked list contains {Apple, Banana,
Carrot, Grape} and the parameter index is 3, then \"Grape\" will be returned. If the parameter
index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
6.
public void searchAndReplace(Object oldString, Object newString)
The searchAndReplace method searches all occurrences of the first parameter string (object) in
the list, and replaces them with the second parameter string (object). If the parameter string does
not exist in the linked list, then the linked list content will not change.
7.
public int indexOfLast(Object searchString)
The indexOfLast searches the parameter string (object) with the largest index, and returns its
index. If the parameter string does not exist in the linked list, then it should return -1.
For i.
In this homework- you will write a program modify program you wrote in.pdf
In this homework, you will write a program modify program you wrote in Homework3.
2) Modify the MyList class that you wrote for Programming challenge 1 so the type parameter T
should accept any type that implements the Comparable interface. Test the class in a program
that creates one instance of MyList to store Integers, and another instance to store Strings. Input
two numbers from the user and insert them into the first instance of Modified MyList.
Input name and City and insert the two strings into the second instance of modified MyList class.
Then display the contents of the the two instances.
here is the program to modify
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// part 1 code.
// creating a Number list
MyList<Number> intList = new MyList<>();
// adding the numbers mentioned in the question
intList.add(2);
intList.add(5);
intList.add(-13);
intList.add(11);
intList.add(12);
// creating a Double list, adding double values to it
MyList<Double> doubleList = new MyList<>();
doubleList.add(27.3);
doubleList.add(5.7);
doubleList.add(-23.9);
doubleList.add(1.11);
doubleList.add(5.12);
System.out.println("PART 1");
// printing largest and smallest of both lists
System.out.println("The Integer largest: \n" + intList.largest());
System.out.println("The Integer smallest: \n" + intList.smallest());
System.out.println("The Double largest: \n" + doubleList.largest());
System.out.println("The Double smallest: \n" + doubleList.smallest());
}
}
//MyList class, which is defined outside Generics1 class BUT still within Generics1.java file.
class MyList<T extends Number> {
// defining an array list as storage
ArrayList<T> list;
// constructor initializing list
public MyList() {
// initializing array list
list = new ArrayList<>();
}
// method to add a value to the list
public void add(T value) {
list.add(value);
}
// method to return the largest element on the list
public T largest() {
// assuming list is not empty, taking first value as largest
T max = list.get(0);
for (int i = 1; i < list.size(); i++) {
// comparing element at i with max using doubleValue() of Number class
if (list.get(i).doubleValue() > max.doubleValue()) {
max = list.get(i);
}
}
return max;
}
// method to return the smallest element on the list
public T smallest() {
// assuming list is not empty, taking first value as smallest
T min = list.get(0);
for (int i = 1; i < list.size(); i++) {
// comparing element at i with min using doubleValue() of Number class
if (list.get(i).doubleValue() < min.doubleValue()) {
min = list.get(i);
}
}
return min;
}
// returns the elemnt at a given position
public T get(int index) {
return list.get(index);
}
}
Here is the sample input/outPut
TestCase1:
PART 2
Please enter a number:
30
Please another number:
20
Please enter your name:
John
Please enter your City:
Los Angeles
First number is 30
Second number is 20
Name is: John
City is: Los Angeles
TestCase2:
PART 2
Please enter a number:
.
Prompt Your task is to create a connected list implementation and .pdf
Prompt
Your task is to create a connected list implementation and a contiguous list
implementation. Both these classes behaves like a list to users but behind the
scenes the connected list class uses a Node class to store the data. This Node
class simply holds the data as well as a reference to the next Node in the list.
The contiguous list class uses an array to hold the data. Both implementations
must implement the ListInterface interface.
For contiguous list a few things should be considered
The array should start at size 10
When an element is added to the list over the size cap the array must
be reallocated with double the size. Then all the data must be copied
over from the previous array. then you must add the new element.
For simplicity the array will only hold Strings. This means the class
implements ListInterface specifically for Strings. I have given you this
code in the starter file.
The ListInterface has the following functions:
void prepend(T e)
Adds the given element to front of the list
void append(T e)
Adds the given element to the end of the list
void insert(int index, T e)
Inserts the given element add the given index
Shifts all elements after the given index up by 1 index
void empty()
Removes all elements from the list
boolean has(T e)
Returns true if the given element exists in the list, false otherwise
T retrieve(int index)
Retrieves the element at the given index, if the index doesnt exist
then return null
boolean isEmpty()
Returns true if the list is empty, false otherwise
T delete(int index)
Deletes the element at the given index and returns it, if the index
doesnt exist then return null
boolean delete(T e)
Deletes the first occurrence of an element from the list if it exists, if
an element is removed return true, false otherwise
boolean deleteAll(Collection c)
Deletes all elements within the given collection, this includes dupli-
cates. If it removes an element then return true, otherwise false
1
T mutate(int index, T e)
Sets the element at the given index to the given element and returns
the old element, return null if the index doesnt exist
int length()
Returns the current length of the list
The following functions must also be implemented:
String toString()
Override toString from Object
Should print out with a square bracket at the front and the back of
the list
Each element should be seperated by a comma and a space
For example if your list had the elements 1 2 and 3 then the
output would be [1, 2, 3]
boolean equals(Object o)
Override equals from Object
Should return true if the contents of your list are equal to the contents
of os list, otherwise false
AND THIS IS THE TEST CLASS.
Problem Solving with Algorithms and Data Structure - Lists
Study slides for http://interactivepython.org/runestone/static/pythonds/BasicDS/Lists.html
Implement a singly linked list as a functional data structure in Kot.pdf
Implement a singly linked list as a functional data structure in Kotlin. As discussed in
the class, the list should be a sealed class with enclosed classes to construct a list,
including construction of an empty list. The following methods should be available for a
singly linked list:
1. modifyListHead() method to replace the head of the list with a different element. This
function accepts an input list and an input variable, and returns a list where the head of
the input list has been replaced with the input variable. For example, calling
modifyListHead(exList, 10) where exList = (1,2,3,4,5) would return (10,2,3,4,5).
2. dropFromList() method to drop the first n elements from the list. This function accepts
an input list and a value for n, and returns a list with the first n elements dropped. For
example, calling dropFromList(exList,1) where exList = (1,2,3,4,5) would return (2,3,4,5).
3. sumTwoLists() method that accepts two lists and adds corresponding elements of each
list. This function accepts two input lists and returns their sum as illustrated in the
example below. For two input lists (1,2,3) and (4,5,6), this function returns (5,7,9)
4. multiplyTwoLists() method that accepts two lists and multiplies corresponding elements
in the same way sumTwoLists() adds elements of two arrays.
NB:
Solution
that I earlier got showed some errors when tried to run it. I am also sharing the solution below:
sealed class SinglyLinkedList {
object Empty : SinglyLinkedList()
data class Cons(val head: T, val tail: SinglyLinkedList) :
SinglyLinkedList()
}
fun modifyListHead(list: SinglyLinkedList, newHead: T): SinglyLinkedList =
when (list) {
is SinglyLinkedList.Empty -> SinglyLinkedList.Empty
is SinglyLinkedList.Cons -> SinglyLinkedList.Cons(newHead, list.tail)
}
fun dropFromList(list: SinglyLinkedList, n: Int): SinglyLinkedList =
when (list) {
is SinglyLinkedList.Empty -> SinglyLinkedList.Empty
is SinglyLinkedList.Cons -> if (n == 0) list else dropFromList(list.tail, n - 1)
}
fun sumTwoLists(list1: SinglyLinkedList, list2: SinglyLinkedList): SinglyLinkedList =
when {
list1 is SinglyLinkedList.Empty && list2 is SinglyLinkedList.Empty ->
SinglyLinkedList.Empty
list1 is SinglyLinkedList.Empty -> list2
list2 is SinglyLinkedList.Empty -> list1
else -> SinglyLinkedList.Cons(list1.head + list2.head, sumTwoLists(list1.tail, list2.tail))
}
fun multiplyTwoLists(list1: SinglyLinkedList, list2: SinglyLinkedList): SinglyLinkedList =
when {
list1 is SinglyLinkedList.Empty || list2 is SinglyLinkedList.Empty ->
SinglyLinkedList.Empty
else -> SinglyLinkedList.Cons(list1.head * list2.head, multiplyTwoLists(list1.tail,
list2.tail))
}
fun main(){
val exList = linkedListOf(1, 2, 3, 4, 5)
println(exList)
// Output: 1 2 3 4 5
val modifiedList = exList.modifyListHead(10)
println(modifiedList)
// Output: 10 2 3 4 5
val droppedList = exList.dropFromList(1)
println(droppedList)
// Output: 2 3 4 5
val list1 = linkedListOf(1, 2, 3)
val list2 = linkedListOf(4, 5, 6)
val sumList = list.
Implement a singly linked list as a functional data structure in Ko.pdf
Implement a singly linked list as a functional data structure in Kotlin. As discussed in
the class, the list should be a sealed class with enclosed classes to construct a list,
including construction of an empty list. The following methods should be available for a
singly linked list:
1. modifyListHead() method to replace the head of the list with a different element. This
function accepts an input list and an input variable, and returns a list where the head of
the input list has been replaced with the input variable. For example, calling
modifyListHead(exList, 10) where exList = (1,2,3,4,5) would return (10,2,3,4,5).
2. dropFromList() method to drop the first n elements from the list. This function accepts
an input list and a value for n, and returns a list with the first n elements dropped. For
example, calling dropFromList(exList,1) where exList = (1,2,3,4,5) would return (2,3,4,5).
3. sumTwoLists() method that accepts two lists and adds corresponding elements of each
list. This function accepts two input lists and returns their sum as illustrated in the
example below. For two input lists (1,2,3) and (4,5,6), this function returns (5,7,9)
4. multiplyTwoLists() method that accepts two lists and multiplies corresponding elements
in the same way sumTwoLists() adds elements of two arrays..
It is somewhat curious that this documentation does not wind.pdf
It is somewhat curious that this documentation does not wind up in the same build/reports/ folder
that holds other reports about our code. Add to build.gradle a new task named copyDocs that is
run only after the javadoc task has completed, and copies the files and directories from build/docs/
into build/reports, resulting in a new build/reports/javadoc directory. (CODE IS WRITTEN IN JAVA
USING build.gradle).
izgi ynteminin ve nceden alanm plakann sonularna gre k.pdf
izgi ynteminin ve nceden alanm plakann sonularna gre, koloninin baarl bir ekilde izole edildiini nasl
anlayabilirsiniz? a) Bakteri kolonisi, dier kolonilerden birka milimetre uzakta, agar plakasnn
yzeyinde, dzgn, aka tanmlanm ekil ve renkte birikmitir. c) Bakteri kolonisi, agar plak yzeyinde
benzer ekil ve renklerdeki dier koloniler kmesi iindedir. d) Sadece plaka baklarak belirlenemez..
More Related Content
Similar to Java Amend the LinkedList so that 1 Your list classes must.pdf
Objective The purpose of this exercise is to create a Linke.pdf
Objective: The purpose of this exercise is to create a Linked List data structure that mimics the
behavior of the Java Standard Library Version (Java API). The outcomes/results of using the
library features should be identical with your own version (My API). However, the underlying
implementation should follow with the descriptions listed below.
Instructions : Create the following Linked List Data Structure with the given description below in
your utils package and use "for loops" for your repetitive tasks.
Where to find starter code in my-api
package.class : utils.LinkedList
package.class : tests.console.week04.LinkedListTest
Where to find your JUNIT test in my-api
package.class : tests.junit.LinkedListJUnitTest
Nested Class that has to be added to LinkedList class
package.class : utils.LinkedList.Node
Task Check List
ONLY "for" loops should be used within the data structure class. There is an automatic 30%
deduction, if other loops are used.
The names of identifiers MUST match the names listed in the description below. Deductions
otherwise.
Complete coding Assignment in your "my-api" GitHub Repository. You will not be graded
otherwise and will receive a 0, if not uploaded there.
Run JUNIT TEST and take a SNAPSHOT of results. Upload PDF of snapshot of your JUnitTest
results to Canvas.
Description
The internal structure of the Linked List is a doubly linked Node data structure and should have
at a minimum the following specifications:
data fields: The data fields to declare are private and you will keep track of the size of the list with
the variable size and the start of the list with the reference variable data.
first is a reference variable for the first Node<E> in the list.
last is a reference variable for the last Node<E> in the list.
size keeps track of the number of nodes in the list of type int. This will allow you to know the
current size of the list without having to traversing the list.
constructors: The overloaded constructors will initialize the data fields size and data.
A constructor that is a default constructor initializes the starting node location first and size to a
zero equivalent, that is, constructs an empty list.
methods: methods that manages the behavior of the linked nodes.
Together, the methods below give the illusion of a index or countable location. Implement these
methods within your generic Linked List class.
Method
Description
Header
public boolean add(E item)
public void add(int index, E item)
public void append( E item)
private void checkIndex(int index)
public boolean contains(E item)
public void clear()
private E detach(int index)
public E get(int index)
public int indexOf(E item)
private void insertBefore(int index, E item)
public boolean isEmpty()
private Node<E> node(int index)
public E remove(int index)
public boolean remove(E item)
public E set(int index, E item)
public int size()
public String toString()
Node Data Structure
The generic Linked List class includes a static Node class as a nested class, .
The MyLinkedList class used in Listing 24.6 is a one-way directional .docx
The MyLinkedList class used in Listing 24.6 is a one-way directional .docx
The following class stores a list of integer values and contains a met.docx
The following class stores a list of integer values and contains a method to return the smallest value in a non-empty list. Make changes and cross out old code as needed to turn this into a generic class that can be used to store lists of any element type E as long as those elements can be compared for ordering (i.e., any type E whose elements support the compareTo method). You can assume the code is adequate otherwise – you don’t need to, for example, add additional tests to guard against null values.
public class MinList f List items; ** Construct new empty list*/ public MinList () { items = new ArrayList ( ); } *add new item x to list * public void add(int x) items.add(x); /** return smallest value in a non-empty list* public int minItem() assert items.size)> e; int minValue-items.get (0); for (int val: items) if (val
Solution
import java.util.ArrayList;
public class MinList<E extends Comparable<E>> {
ArrayList<E> items;
public MinList(){
items = new ArrayList<E>();
}
public void add(E x){
items.add(x);
}
public E minItem(){
assert items.size()>0;
E minValue = items.get(0);
for(E val:items){
if(val.compareTo(minValue) < 0){
minValue = val;
}
}
return minValue;
}
}
.
Everything needs to be according to the instructions- thank you! SUPPO.pdf
Everything needs to be according to the instructions, thank you!
SUPPORTING CODE:
MyList.java
/**
This interface specifies the basic operations of any list-like object.
This interface contains a variation of the methods of the
standard java.util.List interface.
*/
public interface MyList {
/**
Adds an element at the end of the list.
*/
public void addToEnd(Object o);
/**
Inserts an element at the specified index
Throws NoSuchElementException if index is out of bounds.
*/
public void insertAt(int index, Object o);
/**
Removes the element at the specified index
Throws NoSuchElementException if index is out of bounds.
*/
public void removeAt(int index);
/**
Returns the element at the specified index
Throws NoSuchElementException if index is out of bounds.
*/
public Object getAt(int index);
/**
Returns the size of the list.
@return the number of elements in the list
*/
public int getSize();
/**
Returns a list iterator for this list.
@return a list iterator for this list
*/
public MyListIterator getIterator();
}
MyListIterator.java
/**
A list iterator allows access of a position in a list.
This interface contains a subset of the methods of the
standard java.util.ListIterator interface. The methods for
backward traversal are not included.
*/
public interface MyListIterator
{
/**
Moves the iterator past the next element.
@return the traversed element
*/
Object next();
/**
Tests if there is an element after the iterator
position.
@return true if there is an element after the iterator
position
*/
boolean hasNext();
}
Main.java
// you may use this file to write and run code to test your MyArrayList class
public class Main {
public static void main(String[] args) {
}
}
FILE THAT NEEDS THAT NEEDS CODE:
MyArrayList.java
// Complete the implementation of your MyArrayList class in this file
public class MyArrayList implements MyList {
// Implement the required fields and methods here
private int capacity = 8;
private Object[ ] array = new Object [capacity];
private int size = 0;
@Override
public void add(Object o) {
if (size >= capacity){
Object[] temp = new Object[2*array.length];
for(int i=0;i<size;++i){
temp[i] = array[i];
}
this.capacity = 2*array.length;
array = temp;
array[size++] = o;
return;
}
else
{
array[size++] = o;
}
}
@Override
public int size() {
return size;
}
@Override
public Object at(int index) {
if (index >= capacity)
return null;
else
return array[index];
}
@Override
public void insertAt(int index, Object o) {
if (index >= capacity)
return;
else
{
size++;
for (int x = size - 1; x > index; x--) {
array[x] = array[x - 1];
}
array[index] = o;
}
}
@Override
public void removeAt(int index) {
if (index >= size || size == 0)
return;
else {
Object e = array[index];
for (int x = index; x < this.array.length - 1; x++) {
array[x] = array[x + 1];
}
size--;
}
}
public void ensureCapacity(int minCapacity) {
}
public void trimToSize() {
ensureCapacity(size);
}
// Do not alter the code below
@Override
public MyListIterator getIterator() {
return new MyA.
Part B- Implementing a Sorted Linked list The class declarations has b.pdf
Part B: Implementing a Sorted Linked list
The class declarations has been created in the a1.py starter file. The data member names are
provided (but not initialized so code will not compile).
Aside from the class declaration you will find a functions called iter
You are allowed to add data members to both Node and Linked list. You are also allowed to
rename your data members BUT, if you do this, you will need to alter the iter function to match
your new data member names.
A sorted linked list is a linked list where values stay sorted from smallest to biggest. That is the
smallest value is at the front of the list while the largest is in the back.
When a doubly linked sorted list is first created it is empty.
The sorted list has the following member functions
this function inserts data into the list such that the list stays sorted. You may assume that the data
being added can be compared using comparison operators
this function finds and removes node containing data from the list. If a node containing data was
found and removed, function returns True. If no such node was found (data was not in list),
function returns False
insert(30); front_ back_.
AD3251-LINKED LIST,STACK ADT,QUEUE ADT.docx
Here's a suggestion for a description to upload your document on a website:
"Unlock the power of data structures with our comprehensive guide! Dive into the world of linked lists, Stack ADT (Abstract Data Type), and Queue ADT with our expertly curated document. Whether you're a seasoned programmer or just starting out, our resource provides clear explanations, insightful examples, and practical applications to help you master these fundamental concepts. Explore the intricacies of linked lists for efficient data storage, understand the versatility of Stack ADT for managing data in a Last-In, First-Out (LIFO) fashion, and delve into the functionality of Queue ADT for orderly data processing in a First-In, First-Out (FIFO) manner. Elevate your understanding of data structures and revolutionize your programming skills with our invaluable document. With clear explanations, illustrative examples, and practical exercises, our document equips you with the knowledge and skills needed to conquer data structure challenges with confidence. Whether you're a student embarking on your journey into computer science or a seasoned developer .Seeking to expand your repertoire, our resource is your roadmap to success.
Download our document now and embark on a transformative learning experience that will elevate your programming prowess to new heights!"
For this lab you will complete the class MyArrayList by implementing.pdf
Find the time it takes the boat to travel the given distance. A ball is thrown vertically upward
with a speed of 40.0 m/s. How high does it rise? How long does it take to reach its highest
point? How long does the ball take to hit the ground after it reaches its highest point? What is
its velocity when it returns to the level from which it started? The center of mass moves with
constant acceleration when constant forces act on the object. A gym ground. How high above
this point is her center of mass at the following times? Ignore the effects
Solution
initial velocity, u = + 40 m/s
a = - 9.8 m/s^2
(a) it will rise until its velocity becomes zero.
hence final velocity, v = 0
Applying, v^2 - u^2 = 2 a h
0^2 - 40^2 = 2(-9.8)(h)
h = 81.63 m
(B) v = u + at
0 = 40 - 9.8 t
t = 4.08 sec
(C) now for motion from highest point to ground,
initial velocity, v (velocity at highets point) = 0
displacement, y = - 81.63 m
a = - 9.8 m/s^2
applying, y = u t + a t^2 /2
- 81.63 = 0 - 9.8 t^2 / 2
t = 4.08 s
(D) applying v = u + at
v = 0 + (-9.8)(4.08)
v = - 40 m/s
(minus sign indicates that direction is downwards).
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
Class Diagram:
In the Assignment #10, you are given three files Assignment10.java, LinkedList.java, and
ListIterator.java. You will need to add additional methods in the LinkedList class in the
LinkedList.java file. The LinkedList will be tested using strings only.
Specifically, the following methods must be implemented in the LinkedList class:
(You should utilize listIterator() method already defined in the LinkedList class to obtain its
LinkedListIterator object, and use the methods in the LinkedListIterator class to traverse from
the first element to the last element of the linked list to define the following methods.)
1.
public String toString()
The toString method should concatenate strings in the linked list, and return a string of the
following format:
{ Apple Banana Melon Orange }
Thus it starts with \"{\" and ends with \"}\", and there is a space between strings and \"{\" or
\"}\". If the list is empty, it returns \"{ }\" with a space in between.
2.
public boolean isEmpty()
The isEmpty method returns true of the linked list is empty, false otherwise.
3.
public void addElement(Object element)
The addElement adds the parameter element at the parameter in the linked list in alphabetical
order. For instance, if the linked list contains {Apple, Banana, Grape}, and a user tries to add
\"Carrot\", then it should be added as:
{Apple, Banana, Carrot, Grape}.
4.
public Object removeElement(int index)
The removeElement removes the string (Object) at the parameter index and returns it. Note that
this index starts with 0 just like array indices. For instance, if the linked list contains {Apple,
Banana, Carrot, Grape} and the parameter index is 3, then \"Grape\" should be remove. If the
parameter index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
5.
public Object getElement(int index)
The getElement searches the string (Object) at the parameter index and returns it. Note that this
index starts with 0 just like array indices. For instance, if the linked list contains {Apple, Banana,
Carrot, Grape} and the parameter index is 3, then \"Grape\" will be returned. If the parameter
index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
6.
public void searchAndReplace(Object oldString, Object newString)
The searchAndReplace method searches all occurrences of the first parameter string (object) in
the list, and replaces them with the second parameter string (object). If the parameter string does
not exist in the linked list, then the linked list content will not change.
7.
public int indexOfLast(Object searchString)
The indexOfLast searches the parameter string (object) with the largest index, and returns its
index. If the parameter string does not exist in the linked list, then it should return -1.
For i.
In this homework- you will write a program modify program you wrote in.pdf
In this homework, you will write a program modify program you wrote in Homework3.
2) Modify the MyList class that you wrote for Programming challenge 1 so the type parameter T
should accept any type that implements the Comparable interface. Test the class in a program
that creates one instance of MyList to store Integers, and another instance to store Strings. Input
two numbers from the user and insert them into the first instance of Modified MyList.
Input name and City and insert the two strings into the second instance of modified MyList class.
Then display the contents of the the two instances.
here is the program to modify
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// part 1 code.
// creating a Number list
MyList<Number> intList = new MyList<>();
// adding the numbers mentioned in the question
intList.add(2);
intList.add(5);
intList.add(-13);
intList.add(11);
intList.add(12);
// creating a Double list, adding double values to it
MyList<Double> doubleList = new MyList<>();
doubleList.add(27.3);
doubleList.add(5.7);
doubleList.add(-23.9);
doubleList.add(1.11);
doubleList.add(5.12);
System.out.println("PART 1");
// printing largest and smallest of both lists
System.out.println("The Integer largest: \n" + intList.largest());
System.out.println("The Integer smallest: \n" + intList.smallest());
System.out.println("The Double largest: \n" + doubleList.largest());
System.out.println("The Double smallest: \n" + doubleList.smallest());
}
}
//MyList class, which is defined outside Generics1 class BUT still within Generics1.java file.
class MyList<T extends Number> {
// defining an array list as storage
ArrayList<T> list;
// constructor initializing list
public MyList() {
// initializing array list
list = new ArrayList<>();
}
// method to add a value to the list
public void add(T value) {
list.add(value);
}
// method to return the largest element on the list
public T largest() {
// assuming list is not empty, taking first value as largest
T max = list.get(0);
for (int i = 1; i < list.size(); i++) {
// comparing element at i with max using doubleValue() of Number class
if (list.get(i).doubleValue() > max.doubleValue()) {
max = list.get(i);
}
}
return max;
}
// method to return the smallest element on the list
public T smallest() {
// assuming list is not empty, taking first value as smallest
T min = list.get(0);
for (int i = 1; i < list.size(); i++) {
// comparing element at i with min using doubleValue() of Number class
if (list.get(i).doubleValue() < min.doubleValue()) {
min = list.get(i);
}
}
return min;
}
// returns the elemnt at a given position
public T get(int index) {
return list.get(index);
}
}
Here is the sample input/outPut
TestCase1:
PART 2
Please enter a number:
30
Please another number:
20
Please enter your name:
John
Please enter your City:
Los Angeles
First number is 30
Second number is 20
Name is: John
City is: Los Angeles
TestCase2:
PART 2
Please enter a number:
.
Prompt Your task is to create a connected list implementation and .pdf
Prompt
Your task is to create a connected list implementation and a contiguous list
implementation. Both these classes behaves like a list to users but behind the
scenes the connected list class uses a Node class to store the data. This Node
class simply holds the data as well as a reference to the next Node in the list.
The contiguous list class uses an array to hold the data. Both implementations
must implement the ListInterface interface.
For contiguous list a few things should be considered
The array should start at size 10
When an element is added to the list over the size cap the array must
be reallocated with double the size. Then all the data must be copied
over from the previous array. then you must add the new element.
For simplicity the array will only hold Strings. This means the class
implements ListInterface specifically for Strings. I have given you this
code in the starter file.
The ListInterface has the following functions:
void prepend(T e)
Adds the given element to front of the list
void append(T e)
Adds the given element to the end of the list
void insert(int index, T e)
Inserts the given element add the given index
Shifts all elements after the given index up by 1 index
void empty()
Removes all elements from the list
boolean has(T e)
Returns true if the given element exists in the list, false otherwise
T retrieve(int index)
Retrieves the element at the given index, if the index doesnt exist
then return null
boolean isEmpty()
Returns true if the list is empty, false otherwise
T delete(int index)
Deletes the element at the given index and returns it, if the index
doesnt exist then return null
boolean delete(T e)
Deletes the first occurrence of an element from the list if it exists, if
an element is removed return true, false otherwise
boolean deleteAll(Collection c)
Deletes all elements within the given collection, this includes dupli-
cates. If it removes an element then return true, otherwise false
1
T mutate(int index, T e)
Sets the element at the given index to the given element and returns
the old element, return null if the index doesnt exist
int length()
Returns the current length of the list
The following functions must also be implemented:
String toString()
Override toString from Object
Should print out with a square bracket at the front and the back of
the list
Each element should be seperated by a comma and a space
For example if your list had the elements 1 2 and 3 then the
output would be [1, 2, 3]
boolean equals(Object o)
Override equals from Object
Should return true if the contents of your list are equal to the contents
of os list, otherwise false
AND THIS IS THE TEST CLASS.
Problem Solving with Algorithms and Data Structure - Lists
Study slides for http://interactivepython.org/runestone/static/pythonds/BasicDS/Lists.html
Implement a singly linked list as a functional data structure in Kot.pdf
Implement a singly linked list as a functional data structure in Kotlin. As discussed in
the class, the list should be a sealed class with enclosed classes to construct a list,
including construction of an empty list. The following methods should be available for a
singly linked list:
1. modifyListHead() method to replace the head of the list with a different element. This
function accepts an input list and an input variable, and returns a list where the head of
the input list has been replaced with the input variable. For example, calling
modifyListHead(exList, 10) where exList = (1,2,3,4,5) would return (10,2,3,4,5).
2. dropFromList() method to drop the first n elements from the list. This function accepts
an input list and a value for n, and returns a list with the first n elements dropped. For
example, calling dropFromList(exList,1) where exList = (1,2,3,4,5) would return (2,3,4,5).
3. sumTwoLists() method that accepts two lists and adds corresponding elements of each
list. This function accepts two input lists and returns their sum as illustrated in the
example below. For two input lists (1,2,3) and (4,5,6), this function returns (5,7,9)
4. multiplyTwoLists() method that accepts two lists and multiplies corresponding elements
in the same way sumTwoLists() adds elements of two arrays.
NB:
Solution
that I earlier got showed some errors when tried to run it. I am also sharing the solution below:
sealed class SinglyLinkedList {
object Empty : SinglyLinkedList()
data class Cons(val head: T, val tail: SinglyLinkedList) :
SinglyLinkedList()
}
fun modifyListHead(list: SinglyLinkedList, newHead: T): SinglyLinkedList =
when (list) {
is SinglyLinkedList.Empty -> SinglyLinkedList.Empty
is SinglyLinkedList.Cons -> SinglyLinkedList.Cons(newHead, list.tail)
}
fun dropFromList(list: SinglyLinkedList, n: Int): SinglyLinkedList =
when (list) {
is SinglyLinkedList.Empty -> SinglyLinkedList.Empty
is SinglyLinkedList.Cons -> if (n == 0) list else dropFromList(list.tail, n - 1)
}
fun sumTwoLists(list1: SinglyLinkedList, list2: SinglyLinkedList): SinglyLinkedList =
when {
list1 is SinglyLinkedList.Empty && list2 is SinglyLinkedList.Empty ->
SinglyLinkedList.Empty
list1 is SinglyLinkedList.Empty -> list2
list2 is SinglyLinkedList.Empty -> list1
else -> SinglyLinkedList.Cons(list1.head + list2.head, sumTwoLists(list1.tail, list2.tail))
}
fun multiplyTwoLists(list1: SinglyLinkedList, list2: SinglyLinkedList): SinglyLinkedList =
when {
list1 is SinglyLinkedList.Empty || list2 is SinglyLinkedList.Empty ->
SinglyLinkedList.Empty
else -> SinglyLinkedList.Cons(list1.head * list2.head, multiplyTwoLists(list1.tail,
list2.tail))
}
fun main(){
val exList = linkedListOf(1, 2, 3, 4, 5)
println(exList)
// Output: 1 2 3 4 5
val modifiedList = exList.modifyListHead(10)
println(modifiedList)
// Output: 10 2 3 4 5
val droppedList = exList.dropFromList(1)
println(droppedList)
// Output: 2 3 4 5
val list1 = linkedListOf(1, 2, 3)
val list2 = linkedListOf(4, 5, 6)
val sumList = list.
Implement a singly linked list as a functional data structure in Ko.pdf
Implement a singly linked list as a functional data structure in Kotlin. As discussed in
the class, the list should be a sealed class with enclosed classes to construct a list,
including construction of an empty list. The following methods should be available for a
singly linked list:
1. modifyListHead() method to replace the head of the list with a different element. This
function accepts an input list and an input variable, and returns a list where the head of
the input list has been replaced with the input variable. For example, calling
modifyListHead(exList, 10) where exList = (1,2,3,4,5) would return (10,2,3,4,5).
2. dropFromList() method to drop the first n elements from the list. This function accepts
an input list and a value for n, and returns a list with the first n elements dropped. For
example, calling dropFromList(exList,1) where exList = (1,2,3,4,5) would return (2,3,4,5).
3. sumTwoLists() method that accepts two lists and adds corresponding elements of each
list. This function accepts two input lists and returns their sum as illustrated in the
example below. For two input lists (1,2,3) and (4,5,6), this function returns (5,7,9)
4. multiplyTwoLists() method that accepts two lists and multiplies corresponding elements
in the same way sumTwoLists() adds elements of two arrays..
Similar to Java Amend the LinkedList so that 1 Your list classes must.pdf (20)
Objective The purpose of this exercise is to create a Linke.pdf
Objective The purpose of this exercise is to create a Linke.pdf
The MyLinkedList class used in Listing 24.6 is a one-way directional .docx
The MyLinkedList class used in Listing 24.6 is a one-way directional .docx
The following class stores a list of integer values and contains a met.docx
The following class stores a list of integer values and contains a met.docx
Everything needs to be according to the instructions- thank you! SUPPO.pdf
Everything needs to be according to the instructions- thank you! SUPPO.pdf
Part B- Implementing a Sorted Linked list The class declarations has b.pdf
Part B- Implementing a Sorted Linked list The class declarations has b.pdf
For this lab you will complete the class MyArrayList by implementing.pdf
For this lab you will complete the class MyArrayList by implementing.pdf
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
In this homework- you will write a program modify program you wrote in.pdf
In this homework- you will write a program modify program you wrote in.pdf
Prompt Your task is to create a connected list implementation and .pdf
Prompt Your task is to create a connected list implementation and .pdf
Problem Solving with Algorithms and Data Structure - Lists
Problem Solving with Algorithms and Data Structure - Lists
Implement a singly linked list as a functional data structure in Kot.pdf
Implement a singly linked list as a functional data structure in Kot.pdf
Implement a singly linked list as a functional data structure in Ko.pdf
Implement a singly linked list as a functional data structure in Ko.pdf
More from adinathassociates
It is somewhat curious that this documentation does not wind.pdf
It is somewhat curious that this documentation does not wind up in the same build/reports/ folder
that holds other reports about our code. Add to build.gradle a new task named copyDocs that is
run only after the javadoc task has completed, and copies the files and directories from build/docs/
into build/reports, resulting in a new build/reports/javadoc directory. (CODE IS WRITTEN IN JAVA
USING build.gradle).
izgi ynteminin ve nceden alanm plakann sonularna gre k.pdf
izgi ynteminin ve nceden alanm plakann sonularna gre, koloninin baarl bir ekilde izole edildiini nasl
anlayabilirsiniz? a) Bakteri kolonisi, dier kolonilerden birka milimetre uzakta, agar plakasnn
yzeyinde, dzgn, aka tanmlanm ekil ve renkte birikmitir. c) Bakteri kolonisi, agar plak yzeyinde
benzer ekil ve renklerdeki dier koloniler kmesi iindedir. d) Sadece plaka baklarak belirlenemez..
Jamie needs a new roof on her house The cash cost is 4100.pdf
Jamie needs a new roof on her house. The cash cost is $4100. She decides to finance the project
by paying 13.0% down, with the balance paid in 12 monthly payments of $304. a) What finance
charge will Jamie pay? b) What is the APR to the nearest half percent? Click the icon to view the
APR table. a) The finance charge is $.
It is necessary for Marketers to know how the customers feel.pdf
It is necessary for Marketers to know how the customers feel about the products their company
offers. They need to search information from different social media, such as Facebook, YouTube,
WhatsApp, IG, etc to find and understand their customers. Discuss what kinds of mining they
could apply in different social media and justify your discussion by giving and describing real-life
examples..
James tiene la enfermedad celaca Cul de los siguientes a.pdf
James tiene la enfermedad celaca. Cul de los siguientes alimentos puede comer James?
Pregunta 6 opciones:
Un sndwich de Ruben en pan de centeno
Un sndwich de queso a la parrilla en pan blanco
Sndwich de atn en pan multicereales
Sndwich de pavo sobre pan de arroz
Un sndwich de Ruben en pan de centeno
Un sndwich de queso a la parrilla en pan blanco
Sndwich de atn en pan multicereales
Sndwich de pavo sobre pan de arroz.
It is difficult to quantify a value for certain biological a.pdf
It is difficult to quantify a value for certain biological and ecosystem services provided, but one of
these specific services gives you the ability to increase your overall grade in this class. A.
Pollination Services
B. Habitat/Refuges
C. Genetic Resources
D. Soil Formation
E. Recreation
F. Nutrient Cycling
G. Water Regulation and Supply
H. Disturbance Regulation and Erosion Control
I. Waste Treatment
J. Food and Raw Materials
K. Atmospheric and Climate Services
L. Biological Control Services.
It was leaked that Bergdorf Goodman treated Kayla a Hispanic.pdf
It was leaked that Bergdorf Goodman treated Kayla a Hispanic candidate dierently during the
employment process compared to her caucasian counteparts, is an example of A. Impact
discrimination it. Equity policy E Disparate treatment D. Afirmative Action qutsTion 18 Jerry has an
adequate understanding of the tasks he needed to perlorm A. Procedural knowledge 1.
Knowledge Compilation c. Declarative knowledgo D. Expert QUestion 19.
It is possible to create dynamic GUI applications based on c.pdf
It is possible to create dynamic GUI applications based on configurable data. For example, we can
build a mad libs type application in Python where the GUI presents input boxes dynamically based
on various stories. We can even allow people to create their own stories dynamically for use in the
app. While many designs could achieve this goal, let me present a proposed approach that you
can expand upon.
from tkinter import *
from tkinter.messagebox import showinfo
class PyLibs:
START_PROMPT = "<"
END_PROMPT = ">"
def __init__(self, file):
self.window = Tk()
def display(self):
pass
#=========================================================================
================
# Testing code below - DO NOT MODIFY
# Only run this code below if this is called as the main, not imported
if __name__ == '__main__':
import sys
sys.path.append('../..')
from utils.ledger import grab
FILE = "PyLibs"
grab(FILE)
uut = PyLibs("story.pylib")
uut.display()
can you finish my code please?.
Joe makes annual income of 5000 for five years Joe withdr.pdf
Joe makes annual income of $5,000 for five years. Joe withdraw $1,200 at the end of each year
The interest rate is 10%. What is NPV? incomes are made at the END of each year. Your answers
should be rounded to the 2nd decimal place.
Joan Robinson ktisat okumann amac iktisat sorularna bir d.pdf
Joan Robinson, "ktisat okumann amac, iktisat sorularna bir dizi hazr cevap elde etmek deil,
iktisatlar tarafndan aldatlmaktan nasl kanlacan renmektir" dedi. nce modelleri aklamay, ardndan
zayflklarn tartmay vurgulayan bu kursta rendiklerinize dayanarak, Bayan Robinson'n bununla ne
demek istediini aklayn. [Yantnz hem ksa hem de orta vadeli modellerin tartmasn ve eletirilerini
iermelidir.].
Jobyde ie alma ilerleme terfi ve tevik etme grevleri gen.pdf
Joby'de ie alma, ilerleme, terfi ve tevik etme grevleri genellikle en iyi yneticiler ve st dzey yneticiler
tarafndan gerekletirilir. Joby gibi kresel bir irkette bu tr grevler ________'nin bir paras olarak kabul
edilir.
A
uluslararas insan kaynaklar ynetimi
B
ii sendikas
C
lkeler aras farkllklar
D
ortak belirleme
e
gurbeti masraflar
2) Joby iin doru insanlar ie almak ok nemlidir. Bu nedenle, Joby genellikle ofislerinin bulunduu
lkelerde ie alm yapan kiilerin ________ veya alann alaca lkenin vatandalar olmasn ister.
A
i konseyi yeleri
B
yerliler
C
memleket vatandalar
D
gurbetiler
e
nc lke vatandalar
Ltfen doru cevaplar seiniz. Teekkr ederim!
A uluslararas insan kaynaklar ynetimi
B ii sendikas
C lkeler aras farkllklar
D ortak belirleme
e gurbeti masraflar.
It is not option 3 please help What would be the outcome of.pdf
It is not option 3. please help
What would be the outcome of a partial diploid with the following genotype? Genome =IP+O+Z+Y
+F plasmid =I+P+OZ+Y+ The structural genes would be expressed only in the absence of lactose.
The structural genes would be expressed in the absence or presence of lactose The structural
genes would be expressed only in the presence of lactose. The structural genes would never be
expressed.
Joanna and Chip Gaines and Michael Dubin got together recent.pdf
Joanna and Chip Gaines and Michael Dubin got together recently to share dinner at a quiet little
restaurant. Both were excited because they wanted to hear the others insights regarding where
they thought their colleagues firm should head strategy-wise. Explain what message about current
strategy strength and attendant risks/benefits the Gaineses shared with Dubin about Dubins firm,
and vice versa (i.e., the message Dubin had to share about the Gaines's firm) Then explain the
overall strategy recommendation each offered for going forward. Finally, even though Joanna
forgot to call you and invite you to the dinner, share what recommendations you would have made
to both CEOs if you were in attendance.
Pls go into details!.
JKL Co issues zero coupon bonds on the market at a price of.pdf
JKL Co. issues zero coupon bonds on the market at a price of $447 per bond. Each bond has a
face value of $1,000 payable at maturity in 19 years. What is the yield to maturity for these bonds
(in percent)? Answer to two decimals..
Jill is offered a choice between receiving 50 with certaint.pdf
Jill is offered a choice between receiving $50 with certainty or possibly receiving the proceeds
from a gamble. In the gamble a fair coin is tossed, and if it comes up heads, Jill will receive $100;
if the coin comes up tails, she will receive nothing. Jill chooses the $50 instead of the gamble. Jill's
behavior indicates __________.
Multiple Choice
prospect theory loss aversion
that she has a diminishing marginal utility of wealth
overconfidence
regret avoidance.
Jennys Froyo INC Balance Sheet For Year Ended December 31.pdf
Jenny's Froyo INC. Balance Sheet For Year Ended December 31, 2014 Assets Cash Marketable
Securities Inventories Accrued Interest Total Current Assets Property Plant and Equipment (net)
Total Assets 205,625 Liabilities Accounts Payable Accrued Taxes Total Liabilities Equity Common
Stock Retained Earnings Total Liabilities and Equity 205,625Jenny's Froyo INC. Income
Statement For Year Ended December 31, 2014 Sales Cost of Goods Sold Gross Profit Rent
Expense Bank Charges Advertising Expense Salary Expense Utilities Expense Depreciation
Expense Business License Expense Operating Income Add: Interest Income Income Before Tax
Tax Expense (66400*25%) Net Income 16,60049,800.
Jim y Sue se iban a casar y estaban muy enamorados Antes de.pdf
Jim y Sue se iban a casar y estaban muy enamorados. Antes de la fecha de la boda, salieron a
tomar un caf y acordaron oralmente cmo se dividiran los bienes conyugales si se divorciaban.
Cuatro aos despus se divorciaron. Jim intent hacer cumplir su acuerdo prenupcial oral. Cul ser el
resultado?
A. Se har cumplir segn haya consideracin.
B. No se har cumplir por el estatuto de fraudes.
C. No se har cumplir ya que viola la poltica pblica.
D. Se har cumplir como hubo una reunin de las mentes..
Jhania Bive the muk hroutwes ite p+4i if peras bt in +45 te.pdf
Jhania Bive the muk hroutwes ite p+4i if peras bt in +4.5 tei pe a is at pinik gins bw asan haniuse
itii=1iHeina-isinm+4.5F.arir43 Pintis I3 fat in Hor deviminisine Dintin. buin in in in atio r prees in tot
pente a diskmons marn min B Fart ias. Pintiai n in do noi mesi ofe Aas hypotian isi hamen tor
decanion ini Cosinisin Erarte.
JAVA Please help me on this method The requirement of the m.pdf
JAVA
Please help me on this method!
The requirement of the method is showing below.
For this program I read the CSV file (showing below) into 7 different arrays and made a list menu
to allow user change file content. The original CSV file content is showing below.
// Prompts the user for the id of the patient to be updated. 1/ If the id does not exist, "Invalid id" is
returned. // // Prompts the user for the patient's height, weight, temperature, and blood pressure. II
If the height or weight are not integer values or the temperature is not a double value, 1/ "Invalid
value" is returned as soon as one invalid value is entered. 1/ I/ If valid values are entered, the
patient's height, weight, temperature, and blood pressure 1/ are updated and "Successful update"
is returned. // /I Throws an IllegalArgumentException with the message Il "Null array" if ids, names,
birthdates, heights, weights, temperatures, 1/ and/or bloodPressures are/is null 1/ // Throws an
IllegalAngumentException with the message 1/ "Invalid array length" if the lengths of the array
parameters are not the same 1/ and / or <1 /1 1/ NOTE: You must check for invalid parameters
(arguments) in the order given above. public static String updatePatient(Scanner scnr, int [] ids,
String[] names, String [] birthdates, int [] heights, int [] weights, double[] temperatures, String[]
bloodPressures) {Patient Records Program - Please choose an option. L - List patients U - Update
patient A - Add patient Q - Quit Option: u Patient id: 1002 Height: 73 Weight: 205 Temperature:
99.3 Blood pressure: 130/90 Successful update11001,MaryBethJones,04/21/1972,62,135,102.4,
120/901002,ThomasA.Berry,06/19/1967,73,198,98.6,130/801003
,TriciaPatel,11/18/1956,64,105,100.2,120/80.
Jennifer invested the profit of his business in an investmen.pdf
Jennifer invested the profit of his business in an investment fund that was earning 3.25%
compounded monthly. He began withdrawing $4,000 from this fund every 6 months, with the first
withdrawal in 4 years. If the money in the fund lasted for the next 3 years, how much money did he
initially invest in the fund? $ Round to the nearest cent.
More from adinathassociates (20)
It is somewhat curious that this documentation does not wind.pdf
It is somewhat curious that this documentation does not wind.pdf
izgi ynteminin ve nceden alanm plakann sonularna gre k.pdf
izgi ynteminin ve nceden alanm plakann sonularna gre k.pdf
Jamie needs a new roof on her house The cash cost is 4100.pdf
Jamie needs a new roof on her house The cash cost is 4100.pdf
It is necessary for Marketers to know how the customers feel.pdf
It is necessary for Marketers to know how the customers feel.pdf
James tiene la enfermedad celaca Cul de los siguientes a.pdf
James tiene la enfermedad celaca Cul de los siguientes a.pdf
It is difficult to quantify a value for certain biological a.pdf
It is difficult to quantify a value for certain biological a.pdf
It was leaked that Bergdorf Goodman treated Kayla a Hispanic.pdf
It was leaked that Bergdorf Goodman treated Kayla a Hispanic.pdf
It is possible to create dynamic GUI applications based on c.pdf
It is possible to create dynamic GUI applications based on c.pdf
Joe makes annual income of 5000 for five years Joe withdr.pdf
Joe makes annual income of 5000 for five years Joe withdr.pdf
Joan Robinson ktisat okumann amac iktisat sorularna bir d.pdf
Joan Robinson ktisat okumann amac iktisat sorularna bir d.pdf
Jobyde ie alma ilerleme terfi ve tevik etme grevleri gen.pdf
Jobyde ie alma ilerleme terfi ve tevik etme grevleri gen.pdf
It is not option 3 please help What would be the outcome of.pdf
It is not option 3 please help What would be the outcome of.pdf
Joanna and Chip Gaines and Michael Dubin got together recent.pdf
Joanna and Chip Gaines and Michael Dubin got together recent.pdf
JKL Co issues zero coupon bonds on the market at a price of.pdf
JKL Co issues zero coupon bonds on the market at a price of.pdf
Jill is offered a choice between receiving 50 with certaint.pdf
Jill is offered a choice between receiving 50 with certaint.pdf
Jennys Froyo INC Balance Sheet For Year Ended December 31.pdf
Jennys Froyo INC Balance Sheet For Year Ended December 31.pdf
Jim y Sue se iban a casar y estaban muy enamorados Antes de.pdf
Jim y Sue se iban a casar y estaban muy enamorados Antes de.pdf
Jhania Bive the muk hroutwes ite p+4i if peras bt in +45 te.pdf
Jhania Bive the muk hroutwes ite p+4i if peras bt in +45 te.pdf
JAVA Please help me on this method The requirement of the m.pdf
JAVA Please help me on this method The requirement of the m.pdf
Jennifer invested the profit of his business in an investmen.pdf
Jennifer invested the profit of his business in an investmen.pdf
Recently uploaded
Supporting (UKRI) OA monographs at Salford.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
Palestine last event orientationfvgnh .pptx
An EFL lesson about the current events in Palestine. It is intended to be for intermediate students who wish to increase their listening skills through a short lesson in power point.
How libraries can support authors with open access requirements for UKRI fund...
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
A Strategic Approach: GenAI in Education
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
Acetabularia Information For Class 9 .docx
Acetabularia acetabulum is a single-celled green alga that in its vegetative state is morphologically differentiated into a basal rhizoid and an axially elongated stalk, which bears whorls of branching hairs. The single diploid nucleus resides in the rhizoid.
2024.06.01 Introducing a competency framework for languag learning materials ...
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
Unit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
Overview on Edible Vaccine: Pros & Cons with Mechanism
This ppt include the description of the edible vaccine i.e. a new concept over the traditional vaccine administered by injection.
Francesca Gottschalk - How can education support child empowerment.pptx
Francesca Gottschalk from the OECD’s Centre for Educational Research and Innovation presents at the Ask an Expert Webinar: How can education support child empowerment?
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...Nguyen Thanh Tu Collection
https://app.box.com/s/hqnndn05v4q5a4k4jd597rkdbda0fniiCLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
Class 11 CBSE Business Studies Project ( AIDS TO TRADE - INSURANCE)
The approach at University of Liverpool.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
Embracing GenAI - A Strategic Imperative
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
The Challenger.pdf DNHS Official Publication
Read| The latest issue of The Challenger is here! We are thrilled to announce that our school paper has qualified for the NATIONAL SCHOOLS PRESS CONFERENCE (NSPC) 2024. Thank you for your unwavering support and trust. Dive into the stories that made us stand out!
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Letter from the Congress of the United States regarding Anti-Semitism sent June 3rd to MIT President Sally Kornbluth, MIT Corp Chair, Mark Gorenberg
Dear Dr. Kornbluth and Mr. Gorenberg,
The US House of Representatives is deeply concerned by ongoing and pervasive acts of antisemitic
harassment and intimidation at the Massachusetts Institute of Technology (MIT). Failing to act decisively to ensure a safe learning environment for all students would be a grave dereliction of your responsibilities as President of MIT and Chair of the MIT Corporation.
This Congress will not stand idly by and allow an environment hostile to Jewish students to persist. The House believes that your institution is in violation of Title VI of the Civil Rights Act, and the inability or
unwillingness to rectify this violation through action requires accountability.
Postsecondary education is a unique opportunity for students to learn and have their ideas and beliefs challenged. However, universities receiving hundreds of millions of federal funds annually have denied
students that opportunity and have been hijacked to become venues for the promotion of terrorism, antisemitic harassment and intimidation, unlawful encampments, and in some cases, assaults and riots.
The House of Representatives will not countenance the use of federal funds to indoctrinate students into hateful, antisemitic, anti-American supporters of terrorism. Investigations into campus antisemitism by the Committee on Education and the Workforce and the Committee on Ways and Means have been expanded into a Congress-wide probe across all relevant jurisdictions to address this national crisis. The undersigned Committees will conduct oversight into the use of federal funds at MIT and its learning environment under authorities granted to each Committee.
• The Committee on Education and the Workforce has been investigating your institution since December 7, 2023. The Committee has broad jurisdiction over postsecondary education, including its compliance with Title VI of the Civil Rights Act, campus safety concerns over disruptions to the learning environment, and the awarding of federal student aid under the Higher Education Act.
• The Committee on Oversight and Accountability is investigating the sources of funding and other support flowing to groups espousing pro-Hamas propaganda and engaged in antisemitic harassment and intimidation of students. The Committee on Oversight and Accountability is the principal oversight committee of the US House of Representatives and has broad authority to investigate “any matter” at “any time” under House Rule X.
• The Committee on Ways and Means has been investigating several universities since November 15, 2023, when the Committee held a hearing entitled From Ivory Towers to Dark Corners: Investigating the Nexus Between Antisemitism, Tax-Exempt Universities, and Terror Financing. The Committee followed the hearing with letters to those institutions on January 10, 202
Recently uploaded (20)
How libraries can support authors with open access requirements for UKRI fund...
How libraries can support authors with open access requirements for UKRI fund...
2024.06.01 Introducing a competency framework for languag learning materials ...
2024.06.01 Introducing a competency framework for languag learning materials ...
Overview on Edible Vaccine: Pros & Cons with Mechanism
Overview on Edible Vaccine: Pros & Cons with Mechanism
Francesca Gottschalk - How can education support child empowerment.pptx
Francesca Gottschalk - How can education support child empowerment.pptx
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Java Amend the LinkedList so that 1 Your list classes must.pdf
- 1. Java Amend the LinkedList so that: 1. Your list classes must be generic (see below) and be able to work with any Comparable data. Be sure to genericize any static methods, e.g. printList() would become: public static <AnyType extends Comparable<? super AnyType>> void printList( YourLinkedList<AnyType> theList ) 2. The list is always maintained in ascending order so as each item is added to (or removed from) the list, it must be put in its proper place in the list just like in Assignment 1. This will be handled by a new method, add(), that takes in a lone parameter (the data object to be inserted - you do not pass in an iterator like you do with insert().) Duplicate values are allowed in the list. 3. Change the insert() method to private visibility. 4. Add a method named replace() that takes in two parameters (the data object to replaced, followed by the one to be inserted) that will remove the first occurrence of the item to be replaced and add the second parameter to the list. The method returns a boolean - true if the item to be replaced was found, false if not. If the value to be replaced is not present, do not perform the add. 5. Add an instance method named showList() (no parameters or return value) that will extract all of the values from the list and display them in order, one per line, followed by another line displaying how many values are currently in the list. If the list is empty, display the message The list is currently empty instead. 6. Overload showList() with an integer parameter which represents how many items to display on each line. The method needs to newline after the last item no matter how many items were displayed (i.e. dont leave the cursor hanging.) 7. As with Assignment 1, add an instance method named getMode() that functions the same as the version in Assignment 1. Reuse the same interface but change the package to the one designated below. 8. Add a method named author() that returns a String consisting of your name. 9. Revise and do not subclass the Weiss classes. Do not make your classes part of any package other than the one specified below for this assignment. That package should consist only of the four classes (list, iterator, node, result) used in this assignment.