Identify the fallacies of insufficient evidence in the following arguments. If no fallacy is committed, write “no fallacy.

9. Either you support preferential treatment for disadvantaged minorities in university admissions, or you’re a racist. But surely, you’re not a racist. Therefore, you support preferential treatment for disadvantaged minorities in university admissions.

11. Students have asked that we extend residence hall visitation hours by one hour on Friday and Saturday nights. This request will have to be denied. If we give students an extra visitation hour on weekends, next they’ll be asking us to allow their boyfriends and girlfriends to stay over all night. Eventually, we’ll have students shacking up in every room.

13. A Saint Bernard is large, cuddly, furry, and makes a great house pet. A baby grizzly bear is also large, cuddly, and furry. Therefore, a baby grizzly bear would make a great house pet, too. 15. You’re not seriously thinking of voting for that bum, are you? Why don’t you wake up and smell the coffee?

How Laude? Many educational institutions award three levels of Latin honors often based on GPA. These are laude (with high praise), magna laude (with great praise), and summa laude (with highest praise). Requirements vary from school to school. Suppose the GPAs at State College are normally distributed with a mean of 2.95 and standard deviation of 0.43.

(a) Suppose State College awards the top 2% of students (based on GPA) with the summa laude honor. What GPA gets you this honor? Round your answer to 2 decimal places.
? GPA or higher

(b) Suppose State College awards the top 10% of students (based on GPA) with the magna laude honor. What GPA gets you this honor? Round your answer to 2 decimal places.
?? GPA or higher

(c) Suppose State College awards the top 20% of students (based on GPA) with the laude honor. What GPA gets you this honor? Round your answer to 2 decimal places.
?? GPA or higher

5. List the methods for a compensation structure.

6. What other ways are used to determine wages?

7. List the different alternatives of incentive plans.

8. What are employee’s benefits? Explain.


9. Why it is a concern for companies the cost of benefits?

10. List the benefits required by law?



11. What are the options of voluntary benefits?

Develop a short list of local and national businesses where employees might be better motivated by theory Y assumptions than theory X assumptions. Explain what factors put some companies on the X list and others on the Y list. Are there specific characteristics, such as education required and/ or the work itself, which appear to be determining factors?

Question 1:

Write a method getSmallest(), which returns the smallest number in the linked list.

Question 2:

Write a member method getPosition(int entry) which returns the position of the entry is in the linked list. If the entry is not in the list, return -1.

Please use C++ language for both questions, I only need functions.

import java.util.ArrayList;
import java.util.Collections;
import java.lang.Exception;

public class ItemList
{
/** This is the main process for the project */
public static void main ()
{
System.out.println("\n\tBegin Item List Demo\n");

System.out.println("Declare an ArrayList to hold Item objects");
ArrayList<Item> list = new ArrayList<Item>();

try
{
System.out.println("\n Add several Items to the list");
list.add(new Item(123, "Statue"));
list.add(new Item(332, "Painting"));
list.add(new Item(241, "Figurine"));
list.add(new Item(126, "Chair"));
list.add(new Item(411, "Model"));
list.add(new Item(55, "Watch"));

System.out.println("\nDisplay original Items list:");
listItems(list);

int result = -1;
// 1. TO DO: change the XXX to a number in the list, and YYY to a number
// not in the list (1 Pt)
System.out.println("\nLinear Search list for items XXX and YYY:");
// 2. TO DO: code a call to linearSearch with the item number (XXX)
// that is in the list; store the return in the variable result (2 Pts)

  
if(result >= 0)
// 3. TO DO: change both XXX numbers to the number searched for (1 Pt)
System.out.printf("Item XXX found at pos %d\n", result);
else
System.out.printf("Item XXX not found in list\n");

// 4. TO DO: code a call to linearSearch with the item number (yyy)
// that is not in the list; store the return in the variable result (2 Pts)
  
  
if(result >= 0)
// 5. TO DO: change both YYY to the number searched for (1 Pt)
System.out.printf("Item YYY found at pos %d\n", result);
else
System.out.printf("Item YYY not found in list\n");

System.out.println("\nSort list into Item Number sequence");
// 6. TO DO: code to sort the array using the Collections class (5 Pts)

  
System.out.println("\nDisplay the Sorted Items list:");
listItems(list);

// 7. TO DO: change the AAA to a number in the list, and BBB to a number
// not in the list (use two different numbers) (1 Pt)
System.out.println("\nBinary Search list for items AAA and BBB5:");
// 8. TO DO: code a call to binarySearch with the item number (AAA)
// that is in the list; store the return in the variable result (3 Pts)
  

if(result >= 0)
// 0. TO DO: change both AAA numbers to the number searched for (1 Pt)
System.out.printf("Item AAA found at pos %d\n", result);
else
{
System.out.printf("Item AAA not found in list\n");
System.out.printf("Should be at pos %d\n", -result -1); // note conversion
}
// 10. TO DO: code a call to binarySearch with the item number (BBB)
// that is not in the list; store the return in the variable result (3 Pts)
  
  
if(result >= 0)
// 11. TO DO change both BBB numbers to the number searched for (1 Pt)
System.out.printf("Item BBB found at pos %d\n", result);
else
{
System.out.println("Item BBB not found in list");
System.out.printf("Should be at pos %d\n", -result -1); // note conversion
}
}
catch (Exception e)
{
System.out.println(e.getMessage());
}

System.out.println("\n\tEnd Item List Demo\n");
}

/**
* This function performs a linear seach of the list
* @param list - reference to the ArrayList to be searched
* @param number - item number to seek
* @return i - index where item number wass found, -1 if not found
*/
public static int linearSearch(ArrayList<Item>list, int number)
{
for (int i = 0; i < list.size(); i++)
if(list.get(i).getItemNo() == number)
return i;
return -1;
}

/**
* This method traverses the Item list and displays the items
* @param list - reference to the ArrayList of Item Objects
*/
public static void listItems(ArrayList<Item> list)
{
for (Item item : list)
System.out.println(item.toString());
}

/**
* This recursive method finds a value in a range of a sorted ArrayList,
* using a binary search algorithm.
* @param list - reference to the ArrayList in which to search   
* @param key - the object key value to find
* @return the index at which the key occurs,
* or -n - 1 if it does not occur in the array
* n is the position in which the key object should appear   
*/
public static int binarySearch(ArrayList<Item> list, int key)
{
int low = 0;
int high = list.size() - 1;
int pos = 0;  

while (high >= low)
{
pos = (low + high) / 2;
if (key < list.get(pos).getItemNo())
high = pos - 1;
else if (key == list.get(pos).getItemNo())
return pos;
else
low = pos + 1;
}
return -low - 1;
}
}

import java.lang.Exception;

public class Item implements Comparable<Item>
{
/** The Item's identification number */
private int itemNo;
/** The Item's descriptive text */
private String itemDesc;

/**
* Constructs a default Item object
*/
public Item()
{
itemNo = 0;
itemDesc = "";
}
  
/**
* Parameter constructor for objects of class Item
* @param number - the Item's number
* @param desc - the Item's description
*/
public Item(int number, String desc) throws Exception
{
setItemNo(number);
setItemDesc(desc);
}

/**
* This method returns the Item identification number   
* @return itemNo - the Item's number
*/
public int getItemNo()
{
return itemNo;
}
  
/**
* Tis method returns the Item's description
* @return itemDesc - the Item's descriptive text
*/
public String getItemDesc()
{
return itemDesc;
}
  
/**
* This method sets the Item's identification number.
* It accepts a number change if and only if the current number is zero(0).
* Otherwise it throws an Exception
* @param number - the Item's new number
* @throw Exception, if number is invalid for this operation
*/
public void setItemNo(int number) throws Exception
{
if (itemNo == 0)
if (number > 0)
itemNo = number;
else
throw new Exception("Item number must be greater than zero(0)");   
else
throw new Exception("An existing item number cannot be changed!");
}
  
/**
* This method sets the Item's description
* @param desc - the Item's descriptive text
* @throws Exception if input desc is blank or null
*/
public void setItemDesc(String desc) throws Exception
{
if(desc.trim().length() > 0)
itemDesc = desc;
else
throw new Exception("Item description cannot be blank");
}
  
/**
* This method determines if one Item equals another
* @param other - the other Item to be matched
* @return true, if numbers are equal, false if not.
*/
public boolean equals(Item other)
{
return (itemNo == other.itemNo);
}
  
/**
* Provides the compareTo() method for the Comparable Interface
* @param otherObject - the other object for comparison
* @returns a: positive value, if this number is greater than the other
* negative value, if this number is less than the other
* zero, if the numbers are equal to each other
*/
@Override
public int compareTo(Item other)
{
return itemNo - other.itemNo;
}
  
/**
* This method overrides the toSting() method of Object
* Its purpose is to expose the data elements of the Product
* object in String form
* @return String - a string containing the Item's information
*/
@Override
public String toString()
{   
return String.format("%4d %-25s", itemNo, itemDesc);
}
}

Write a class to implement HeadTailListInterface. Instead of using an array, use a List object as your instance data variable. (List (Links to an external site.) from the Java standard library- not ListInterface!). Instantiate the List object to type ArrayList.

Inside the methods of this class, invoke methods on the List object to accomplish the task. Note: some methods might look very simple... this does not mean they are wrong!

There is one difference in how this class will work compared to the other: in this extra credit class, you do not have control over the capacity, so you should not print the capacity in display and the capacity does not have to be exactly doubled in the two add methods.

For full credit:

• Pay close attention to what should happen in "failed" conditions as described by the HeadTailListInterface compared to List!
• Make sure your ListHeadTailList behaves as described in HeadTailListInterface.
• Use the methods of the List interface/ArrayList class when possible instead of re-writing the code yourself.

The class header and instance data will be:

public class ListHeadTailList<T> implements HeadTailListInterface<T>

List<T> list; // initialize to type ArrayList<T> in the ListHeadTailList constructor

------------------------------------------------------------------------------------------------------------------------------------------------

/**
* An interface for a list. Entries in a list have positions that begin with 0.
* Entries can only be removed or added to the beginning and end of the list.
* Entries can be accessed from any position.
*
* @author Jessica Masters
*/
public interface HeadTailListInterface<T> {
  
   /**
   * Adds a new entry to the beginning of the list.
   * Entries currently in the list are shifted down.
   * The list size is increased by 1.
   *
   * @param newEntry The object to be added as a new entry.
   */
   public void addFront(T newEntry);
  
   /**
   * Adds a new entry to the end of the list.
   * Entries currently in the list are unaffected.
   * The list size is increased by 1.
   *
   * @param newEntry The object to be added as a new entry.
   */
   public void addBack(T newEntry);

   /**
   * Removes an entry from the beginning of the list.
   * Entries currently in the list are shifted up.
   * The list size is decreased by 1.
   *
   * @return A reference to the removed entry or null if the list is empty.
   */
   public T removeFront();
  
   /**
   * Removes an entry from the end of the list.
   * Entries currently in the list are unaffected.
   * The list size is decreased by 1.
   *
   * @return A reference to the removed entry or null if the list is empty.
   */
   public T removeBack();

  
   /** Removes all entries from this list. */
   public void clear();

  
   /**
   * Retrieves the entry at a given position in this list.
   *
   * @param givenPosition An integer that indicates the position of the desired entry.
   * @return A reference to the indicated entry or null if the index is out of bounds.
   */
   public T getEntry(int givenPosition);
  
   /**
   * Displays the contents of the list to the console, in order.
   */
   public void display();
  
   /**
   * Determines the position in the list of a given entry.
   * If the entry appears more than once, the first index is returned.
   *
   * @param anEntry the object to search for in the list.
   * @return the first position the entry that was found or -1 if the object is not found.
   */
   public int indexOf(T anEntry);
  
   /**
   * Determines the position in the list of a given entry.
   * If the entry appears more than once, the last index is returned.
   *
   * @param anEntry the object to search for in the list.
   * @return the last position the entry that was found or -1 if the object is not found.
   */
   public int lastIndexOf(T anEntry);
  
   /**
   * Determines whether an entry is in the list.
   *
   * @param anEntry the object to search for in the list.
   * @return true if the list contains the entry, false otherwise
   */
   public boolean contains(T anEntry);

   /**
   * Gets the length of this list.
   *
   * @return The integer number of entries currently in the list.
   */
   public int size();

   /**
   * Checks whether this list is empty.
   *
   * @return True if the list is empty, or false if the list contains one or more elements.
   */
   public boolean isEmpty();
}

------------------------------------------------------------------------------------------------------------------------

********TESTING ISEMPTY AND EMPTY DISPLAY
Empty is true: true

Should display:
0 elements; capacity = 10
0 elements; capacity N/A        


********TESTING ADD TO FRONT
Should display:
1 elements; capacity = 10       [2]
1 elements; capacity N/A        [2]

Should display:
3 elements; capacity = 10       [3, 4, 2]
3 elements; capacity N/A        [3, 4, 2]

Empty is false: false


********TESTING CLEAR
Should display:
0 elements; capacity = 10
0 elements; capacity N/A        

********TESTING ADD TO BACK
Should display:
1 elements; capacity = 10       [7]
1 elements; capacity N/A        [7]

Should display:
3 elements; capacity = 10       [7, 10, 5]
3 elements; capacity N/A        [7, 10, 5]


********TESTING CONTAINS
Contains 5 true:  true
Contains 7 true:  true
Contains 4 false: false


********TESTING ADD WITH EXPANSION
Should display:
32 elements; capacity = 40      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]
32 elements; capacity N/A       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]


********TESTING INDEX OF
Index of 0  is  0: 0
Index of 31 is 31: 31
Index of -5 is -1: -1
Index of 32 is -1: -1
Index of 3  is  0: 0
Index of 5  is  6: 6


********TESTING LAST INDEX OF
Last index of 0  is  1:  1
Last index of 31 is 32: 32
Last index of -5 is -1: -1
Last index of 35 is -1: -1
Last index of 3  is  4:  4
Last index of 5  is  33: 33


********TESTING SIZE
Size is 34: 34


********TESTING GET ENTRY
Element in position 15 is 14: 14
Element in position  0 is  3: 3
Element in position 39 is null: null
Element in position -1 is null: null


********TESTING REMOVES
Remove front element 3: 3
Remove back element  5 :5
Remove front element 0: 0
Remove back element 31: 31

Should display:
30 elements; capacity = 40      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
30 elements; capacity N/A       [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]

Remove element null: null
Remove element null: null

Remove element 1: 1
Should display:
0 elements; capacity = 40
0 elements; capacity N/A        

Remove element 1: 1
Should display:
0 elements; capacity = 40
0 elements; capacity N/A        

Remove element 1: 1
Should display:
0 elements; capacity = 40
0 elements; capacity N/A        

Remove element 1: 1
Should display:
0 elements; capacity = 40
0 elements; capacity N/A        



********TESTING MIX OF ADDS AND REMOVES
Should display:
7 elements; capacity = 40       [5, 4, 3, 2, 3, 8, 9]
7 elements; capacity N/A        [5, 4, 3, 2, 3, 8, 9]

Should display:
5 elements; capacity = 40       [4, 3, 2, 3, 8]
5 elements; capacity N/A        [4, 3, 2, 3, 8]

********TESTING WITH STRINGS
Should display:
5 elements; capacity = 5        [You, did, it!, Nice, job!]
5 elements; capacity = 5        [You, did, it!, Nice, job!]

Contains "Nice" is true: true
Contains "You"  is true: true
Contains "you"  is false: false

Index of "it!" is 2: 2
Last index of "it!" is 2: 2

can you teach me how to implement the ArrayStringList and LinkedStringList using the same interface? I've implemented a couple of methods in my ArrayStringList but I'm not sure if I'm doing it correctly and im confused on how to do the splice, reverse, and a couple others. I'm also having trouble getting started on my LinkedStringList.

In this project, you will be providing two different implementations of a StringList interface, which defines different operations that one should be able to do with a list of strings. A list is simply an object that represents an ordered collection of elements. The list implementation can decide how the elements are stored internally so long as users are able to interact with those elements via the methods defined in the interface. In this way, a list is an example of an abstract data type (ADT). To put it another way: while the implementor needs to understand the specific details of the implementation (in order to write the code to make it happen), the user of a list does not. The users simply interact with objects of the list implementation through the methods defined in the interface.

In order to truly understand this project, you must take a step back and think about how a list object and its storage are separate things. A list uses its storage to actually store its elements. For example, the size of a list does not have to be the same as the size of its storage, although the storage is likely at least as big as the list. For example, say you have created a shopping list with 5 items on it. You would say that there are five items on your list. If the list is implemented as a class in Java, you might have some internal storage (say, an array) that can hold more than five items. From the outside perspective, the list still contains 5 elements even though the internal storage may be larger. The internal array is hidden and is of no concern to the user of the class.

Each implementation of the StringList interface will be a concrete class with specific functional and non-functional requirements. These classes need to implement StringList either directly or via a common abstract parent class.

For this project, you will NOT have access to the .java files for the interface. Instead, you will have access to the generated API documentation for the interface here. Implementors should make sure that each method functions or behaves as described by the interface's API documentation, except in cases where a functional requirement changes the behavior of the method.

Implementors are always free to implement additional methods in addition to the ones defined by the interface. However, they should not assume that users (e.g., graders) will use them (even if declared with public visibility), since they are not defined in the interface. These additional methods may help avoid redundancy and promote code reuse within an implementation.

A functional requirement is added to your point total if satisfied. There will be no partial credit for any of the requirements that simply require the presence of a method related to a particular functionality. The actual functionality is tested using test cases.

For this project, you are required to create two different classes that implement the same interface. While the specific details are listed below, the following diagram illustrates the general relationship between your classes and the interface (with instance variables and most methods omitted from the diagram for brevity):

The specific requirements for each class are presented below.

• ArrayStringList: Create the cs1302.list.ArrayStringList class such that it properly implements the cs1302.listadt.StringList interface with additional requirements listed below.

  • You must explicitly define and document default constructor for this class. The initial size of an ArrayStringList is 0 regardless of the list's underlying storage--remember, the list's internal storage and the list itself are two different things. Here is the signature:

    public ArrayStringList();

  • You must explicitly define and document a copy constructor for this class. It should make the new list a deep copy of the other list. Therefore, the initial size and element values of the new list should be the other list. The other list can be any implementation of the StringList interface. Here is the signature:

    public ArrayStringList(StringList other);

  • Over the lifetime of an ArrayStringList object, its internal storage may change in order to accomodate more list elements. When your code increases the size of an ArrayStringList object's internal array storage, you should actively avoid: i) increasing the array size by one; and ii) doubling the size of the array. Somewhere in between is more reasonable. Furthermore, you should not set the initial array size to 0 or to the largest number that is allowed.

  • There is a requirement related to this class's storage included in the Absolute Requirements section.

  • Extra Credit (5 points): Override the iterator() method for your ArrayStringList class as described in the StringList interface. This may require you to create an additional class that implements another interface. Some web searching might recommend an anonymous inner class. Please do not do this. If you choose to do this extra credit, then you should create a regular class that properly implements the desired interface. In addition to properly overriding iterator(), to receive points for this extra credit, you must include a file called EXTRA.md in your immediate project directory and place the text [EC2] on a single line within the file. In this file, you should have one line for each extra credit that you want the grader to check.

    NOTE: You do not need to implement the iterator() method if you are not doing the extra credit.

• LinkedStringList: Create the cs1302.list.LinkedStringList class such that it properly implements the cs1302.listadt.StringList interface with additional requirements listed below.

  • You must explicitly define and document a default constructor for this class. The initial size of a LinkedStringList is 0 regardless of the list's underlying storage--remember, the list's internal storage and the list itself are two different things. Here is the signature:

    public LinkedStringList();

  • You must explicitly define and document a copy constructor for this class. It should make the new list a deep copy of the other list. Therefore, the initial size and element values of the new list should be the other list. The other list can be any implementation of the StringList interface. Here is the signature:

    public LinkedStringList(StringList other);

  • There is a requirement related to this class's storage included in the Absolute Requirements section.

  • Extra Credit (5 points): Override the iterator() method for your LinkedStringList class as described in the StringList interface. This may require you to create an additional class that implements another interface. Some web searching might recommend an anonymous inner class. Please do not do this. If you choose to do this extra credit, then you should create a regular class that properly implements the desired interface. In addition to properly overriding iterator(), to receive points for this extra credit, you must include a file called EXTRA.md in your immediate project directory and place the text [EC2] on a single line within the file. In this file, you should have one line for each extra credit that you want the the grader to check.

  • Non-Functional Requirements

    A non-functional requirement is subtracted from your point total if not satisfied. In order to emphasize the importance of these requirements, non-compliance results in the full point amount being subtracted from your point total. That is, they are all or nothing.

  • (0 points) [RECOMMENDED] No Static Variables: Use of static variables is not appropriate for this assignment. However, static constants are perfectly fine.

  • Methods for ArrayStringList

  • Modifier and Type	Method and Description
    boolean	add(int index, String s) Inserts the specified string at the specified position in this list.
    boolean	add(int index, StringList sl) Inserts the strings contained in the specified list at the specified position in this list, in the order in which they appear in the specified list.
    boolean	add(String s) Appends the specified string to the end of this list.
    boolean	add(StringList sl) Appends the strings contained in the specified list to the end of this list, in the order in which they appear in the specified list.
    void	clear() Removes all of the strings from this list.
    boolean	contains(String o) Returns true if this list contains the specified string.
    boolean	containsIgnoreCase(String o) Returns true if this list contains the specified string, ignoring case.
    boolean	containsSubstring(String o) Returns true if any string in this list contains the specified substring.
    StringList	distinct() Builds and returns a new StringList from this list without any duplicate strings.
    String	get(int index) Returns the string at the specified position in this list.
    int	indexOf(String s) Returns the index of the first occurrence of the specified string in this list, or -1 if this list does not contain the string.
    int	indexOfIgnoreCase(String s) Returns the index of the first occurrence of the specified string, ignoring case, in this list, or -1 if this list does not contain the string.
    boolean	isEmpty() Returns true if this list contains no elements.
    default Iterator	iterator() Returns a new iterator over the strings in this list in proper sequence.
    default String	makeString() Returns a string representation of this list with all of strings directly concatenated in order.
    String	makeString(String sep) Returns a string representation of this list with every string in the sequence separated by the specified separator string.
    default String	makeString(String start, String sep, String end) Returns a string representation of this list that begins with start and ends with end, with every string in the sequence separated by sep.
    String	remove(int index) Removes the string at the specified position in this list.
    StringList	reverse() Builds and returns a new StringList that contains the strings from this list in reverse order.
    String	set(int index, String s) Replaces the string at the specified position in this list with the specified element.
    int	size() Returns the number of elements in this list.
    StringList	splice(int fromIndex, int toIndex) Builds and returns a new StringList that contains the strings from this list between the specified fromIndex, inclusive, and toIndex, exclusive.
    String[]	toArray() Returns a new array containing all of the strings in this list in proper sequence (from first to last element).

• Methods for LinkedStringList

• Constructor and Description
  Node() Constructs a new node with all properties unset.
  Node(String str) Constructs a new node with the str property set and the next property unset.
  Node(String str, StringList.Node next) Constructs a new node with the str and next properties set.

• Method Summary

  Modifier and Type	Method and Description
  StringList.Node	getNext() Returns the value of the next property for this node.
  String	getStr() Returns the value of the str property for this node.
  void	setNext(StringList.Node next) Sets the value of the next property for this node.
  void	setStr(String str) Sets the value of the str property for this node.

• Uses these methods to implement the same methods as ArrayStringList belonging to the StringList interface however with the usage of node objects.

Used to download the project in UNIX that includes the interface and tester:

 git clone --depth 1 https://github.com/cs1302uga/cs1302-listadt.git

To be clear, both listadt.jar and bin are assumed to be in the your main project directory when the tester is run. If your code does not yet compile because one of the classes does not yet fully implement the StringList interface, then you can rapidly get it to compile by following the advice given here.

To see the options for the tester, run listadt-tester in your main project directory:

$ listadt-tester

Usage: listadt-tester [OPTION]...

Run public test cases for the cs1302-listadt project. This program assumes
that your code compiles correctly, the default location for compiled code
is 'bin', and 'listadt.jar' is in the current directory.

Options:
    -a | --ArrayStringList     Check and test cs1302.list.ArrayStringList
    -l | --LinkedStringList    Check and test cs1302.list.LinkedStringList
    --help                     Show this help information (ignore other options)

You can test your ArrayStringList class, LinkedStringList class, or both. For example, to just test ArrayStringList, you can run:

$ listadt-tester -a

list 9 major arguments in focus of euthansia

that question was incorrect. The correct question is, list 9 major arguments in opposition to euthansia