# Data Structure and Algorithms Assignment

Question 1

In this exercise we’ll be using a combination of things we’ve worked on before, but now starting almost from scratch. No individual element here is new, so read the instructions carefully and break the task down into steps.

In the skeleton you are given a class `Sequence` with very little code in it. It starts with an array called `sequence`, and that’s about it.

Below the indicated comment you need to do the following (you may want to think about the order):

• Create a standard `main` method. In the main method you need to:
• Create a `Scanner` object to be used to read things in
• Print a prompt to `"Enter the first double: "`, without a new line after it.
• Read a `double` in from the user and store it as the first element of `sequence`.
• Print a prompt to `"Enter the second double: "`, without a new line after it.
• Read a `double` in from the user and store it as the second element of `sequence`.
• Calculate a third `double` which is the second`double` divided by the first `double`, all multiplied by the second `double`.
• Store this third `double` as the third element of `sequence`.
• Print `"The first element was <x>, the second element was <y>, so the third element is <z>."` where `<x>`, `<y>` and `<z>` are replaced by the values of the first, second and third `doubles` respectively.

Remember that computers aren’t clever, so note the formatting and punctuation, especially in the feedback of the tests.

Note also that part of the task is to use the array `sequence`. Although you can print out the correct things without it, you cannot pass the task.

As an example, you have also been given the class `AreaOfRectangle`, you do not need to change anything, it is just

Starter Code Question one

import java.util.Scanner;

public class Sequence {

static double [] sequence = {0, 0, 0};

// DO NOT CHANGE ANYTHING ABOVE THIS COMMENT LINE

//Create a main method

//Create a Scanner

//Prompt the user as per the description and read in a double.

//Prompt the user as per the description and read in another double.

//Calculate the third double.

//Print out the message about the sequence values.

//Don’t forget to put a closing brace at the end of the main method.

}

Question 2

In this exercise we’ll be using a slightly different combination of things we’ve worked on before, starting from scratch again. No individual element here is new, so read the instructions carefully and break the task down into steps.

In the skeleton you are given a class `ThreeNumbers` which starts with an array called `num`, and little else.

Below the indicated comment you need to do the following (you may want to think about the order):

• Create a standard `main` method. In the main method you need to:
• Create a `Scanner` object to be used to read things in
• Print a prompt to `"Enter the first number: "`, without a new line after it.
• Read an `int` in from the user and store it as the first element of `num`.
• Print a prompt to `"Enter the second number: "`, without a new line after it.
• Read an `int` in from the user and store it as the second element of `num`.
• Print a prompt to `"Enter the third number: "`, without a new line after it.
• Read an `int` in from the user and store it as the third element of `num`.
• Print `"The sum of the three numbers is <sum>."`, with a new line after it, where `<sum>` is replaced by the actual sum of the elements of `num`.
• Print `"The average of the three numbers is <avg>."`, with a new line after it, where `<avg>` is replaced by the actual average (rounded down, so you can use integer division) of the the elements of `num`.

Remember that computers aren’t clever, so note the formatting and punctuation, especially in the feedback of the tests.

Note also that part of the task is to use the array `num`. Although you can print out the correct things without it, you cannot pass the task.

Question 2 Starter Code:

import java.util.Scanner;

/*

class ThreeNumbers

static int [] num = {0, 0, 0};

// DO NOT CHANGE ANYTHING ABOVE THIS COMMENT LINE

//Create a main method

//Create a Scanner

//Prompt the user as per the description and read in an int.

//Prompt the user as per the description and read in another int.

//Prompt the user as per the description and read in the third int.

//Calculate the sum.

//Calculate the average.

//Print out the messages about the sum and average.

//Don’t forget to put a closing brace at the end of the main method.

}

Question 3

In this exercise the goal is to implement the Bubble Sort algorithm on a small array. If you are comfortable with loops and arrays, you can solve this by implementing the full algorithms. If you are not, you can “unroll” the loop and implement each step by hand by hard coding each pass through the array as a sequence of explicit checks and potential swaps.

The skeleton contains two methods:

1. A `main` method which will allow you to do your own testing, and give a working example.
2. A `bubbleSort` method where you’ll do the actual implementation of the sorting algorithm.

The `bubbleSort` method takes in an `int[]` called `data`. This is the array that you are to sort. You are guaranteed for this exercise that `data` will have length 4. At the end of the method you should `return data;`. This line has already been added, so you can just leave it as is.

For the tests to ensure you are correctly implementing a Bubble Sort (and not some other sort, or using a library), you must print out the array using `printArray(data)` every time you swap elements in the array. You should not print it out any other time in the `bubbleSort` method.

Question 3 – Starter Code

import java.util.Arrays;

public class BubbleSort {

//Don’t touch this method!

private static void printArray(int[] a) {

System.out.println(Arrays.toString(a));

}

//Complete this method.

public static int[] bubbleSort(int[] data) {

//Implement a Bubble Sort on data here!

return data;

}

//You can mess around in the main method

//as you wish. As long as it compiles,

//it won’t affect the testing.

public static void main(String[] args) {

int[] testData = {45, 93, 33, 55};

System.out.println(“Sorting.”);

testData = bubbleSort(testData);

System.out.println(“After sorting the array is: “);

printArray(testData);

}

}

Question 4 :

In this exercise the goal is to implement the Selection Sort algorithm on a small array, in a similar manner to the Bubble Sort required exercise. If you are comfortable with loops and arrays, you can solve this by implementing the full algorithms. If you are not, you can “unroll” the loop and implement each step by hand by hard coding each pass through the array as a sequence of explicit checks and potential swaps.

The skeleton contains two methods:

1. A `main` method which will allow you to do your own testing, and give a working example.
2. A `selectionSort` method where you’ll do the actual implementation of the sorting algorithm.

The `selectionSort` method takes in an `int[]` called `data`. This is the array that you are to sort. You are guaranteed for this exercise that `data` will have length 4. At the end of the method you should `return data;`. This line has already been added, so you can just leave it as is.

For the tests to ensure you are correctly implementing a Selection Sort (and not some other sort, or using a library), you must print out the array using `printArray(data)` every time you swap elements in the array. You should not print it out any other time in the `selectionSort` method. For consistency in which version of Selection Sort is implemented:

1. Stop the sort once the unsorted area is only one element.
2. Don’t swap if the minimum element is the first element in the unsorted area (so no print out in this case).

Question 4 Starter Code

import java.util.Arrays;

public class SelectionSort {

//Don’t touch this method!

private static void printArray(int[] a) {

System.out.println(Arrays.toString(a));

}

//Complete this method.

public static int[] selectionSort(int[] data) {

//Implement a Selection Sort on data here!

return data;

}

//You can mess around in the main method

//as you wish. As long as it compiles,

//it won’t affect the testing.

public static void main(String[] args) {

int[] testData = {45, 93, 33, 55};

System.out.println(“Sorting.”);

testData = selectionSort(testData);

System.out.println(“After sorting the array is: “);

printArray(testData);

}

}

Question 5

This exercise is similar to the “Calling Methods” exercise, but flipped. Here we will be filling out methods so that they function as specified. The code here is also a little “simpler”, in that it is contained in a single class, and everything is `static`, so we don’t need to deal with creating objects just yet.

In the skeleton you have a class called `BankAccountStatic`. The class has three data members `accountNumber`, `accountName` and `balance`. You do not need to do anything to these declarations.

It contains two completed methods: a `main` method which runs at least one example of each method, you can change the main as much as you like, as long as it compiles, it will not affect the marking; a method called `withdraw`, this method should serve as an example for the methods you have to complete, although the methods you have to complete are typically much simpler, do not change this method.

Your task is to complete these six methods:

• `getAccountNumber`
• `setAccountNumber`
• `getAccountName`
• `setAccountName`
• `getBalance`
• `deposit`

Each of this represents a method that either accesses or changes one of the three data members, as suggested by the name. You should read the comment block associated with each method, as it describes what needs to be complete for each method.

Question 5 Starter Code

/**

* This “BankAccount” class is a simple introduction to

* methods and variables / fields / private data members.

*

/*

* HINT: You should NOT need to memorise much to complete

*       this skeleton.  The type of the variables

*       “accountNumber”, “accountName” and “balance”

*       (i.e. int, String and double respectively)

*       provide useful information.

*/

public class BankAccountStatic

{

/*

* The variables follow. These are also

* called “fields” or “?”private data members”.

*/

private static int accountNumber = 0;

private static String accountName = “no name”;

private static double balance; // eg. 1.27 means \$1.27

public static void main(String[] args) {

System.out.println(“The initial value for account number is ” + accountNumber + “. Look at line 24.”);

System.out.println(“The initial value for account name is ” + accountName + “. Look at line 26.”);

System.out.println(“The initial value for balance is ” + balance + “. Look at line 28.”);

BankAccountStatic.setAccountNumber(12345678);

BankAccountStatic.setAccountName(“Samantha”);

//the above two lines should update the values stored in accountNumber and accountName to the given value. Let’s test it:

System.out.println(“The new account number is 12345678. Your program’s new account number is ” + accountNumber +”. If these two numbers don’t match then something is not right…”);

System.out.println(“The new account name is Samantha. Your program’s new account name is ” + accountName+”. If these two names don’t match then something is not right…”);

//lets put some money in the account

BankAccountStatic.deposit(3.70);

//the new balance should be 3.70. Let’s check it:

System.out.println(“New balance should be 3.70. Your program’s new balance is ” + balance+”. If these two numbers don’t match then something is not right…”);

//let’s put some more money in our bank account:

BankAccountStatic.deposit(100.00);

//the new balance should be 103.70. Let’s check it:

System.out.println(“New balance should be 103.70. Your program’s new balance is ” + balance+”. If these two numbers don’t match then something is not right…”);

//let’s withdraw some money now. the new balance should be 93.20. Let’s check it:

System.out.println(“After this line, the new balance should be 93.20. Your program’s balance after calling withdraw(10.50) is ” + BankAccountStatic.withdraw(10.50) + “. If these two numbers don’t match then something is not right…”);

//let’s attempt to withdraw more than what we have in the account. The result of print statement should be zero:

System.out.println(“Attempting to withdraw 1000.00 dollars from this bank accoutn should return a -1.0. Your program’s return value after calling withdraw(1000.00) is ” + BankAccountStatic.withdraw(1000.00) + “. If these two numbers don’t match then something is not right…”);

}

/**

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype getAccountNumber(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype setAccountNumber(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype getAccountName(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype setAccountName(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static double getBalance(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype deposit(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* @param   amount  To be subtracted from the balance

*

* @return  the updated account balance or -1.0 if the withdrawal is refused

*

* The withdrawal is refused when the withdrawal would

* have resulted in a negative balance.

*

* Note: This method “withdraw” has been provided in

*       its entirety. You do NOT have to make any

*       changes to it.

*/

public static double withdraw(double amount)

{

if ( balance >= amount )

{

balance = balance – amount;

return balance;

}

else

return -1.0;

}

} // class BankAccountStatic

Question 6

Here will we again build some methods, but in a slightly different context, to help build the programming links between the code and your conception of it, rather than just understanding how a bank account should work.

In the skeleton you have a class called `SummerStatic`. The class has two data members `sum` and `count`. You do not need to do anything to these declarations. The purpose of the class is to receive numbers one by one, and update the current `sum` and `count`, and thus be able to report on the sum, average and count. The sequence can also be reset if desired.

It contains one completed method: a `main` method which runs at least one example of each method, you can change the main as much as you like, as long as it compiles, it will not affect the marking.

Your task is to complete the following six methods:

1. `putNumber`
2. `reset`
3. a different `reset`
4. `getSum`
5. `getCount`
6. `getAverage`

You should read the description of each method in the associated comment block carefully as it describes the purpose of each method, and what needs to be completed for the method

Question 6 Starter Code

/**

* This “Summer” class is a simple introduction to

* methods and variables / fields / private data members.

*

public class SummerStatic

{

/*

* The variables follow. These are also

* called “fields” or “private data members”.

*/

private static int sum;   // sum of all integers received

private static int count; // number of integers received

public static void main(String [] args)

{

/*

* Note: This method “main” has been provided in

* its entirety. You do NOT have to make any

* changes to it.

*

* You could use this “main” method to test your code.

*/

System.out.println(“First we call reset so that th evalues of sum and count are set to zero.”);

reset();

System.out.println(“Now we assign numbers 17 and 1.”);

putNumber(17);

putNumber(1);

System.out.println(“Now we call getCount, getSum and getAverage in three print statements to check the values.”);

System.out.println(“count should be 2, sum should be 18 and average should be 9.00:”);

System.out.println(“Now we call getCount, getSum and getAverage in three print statements to check the values.”);

System.out.println(“”);

System.out.println(“”);

System.out.print(“count = ” + getCount() + ” “);

System.out.print(“sum = ” + getSum() + ” “);

System.out.println(“average = ” + getAverage());

System.out.println(“”);

System.out.println(“”);

System.out.println(“”);

System.out.println(“”);

System.out.println(“”);

// Repeat for a second set of numbers

System.out.println(“We run the program again, this time we start by calling reset(3)”);

reset(3);

System.out.println(“Now we assign numbers 5 and 7.”);

putNumber(5);

putNumber(7);

System.out.println(“Now we call getCount, getSum and getAverage in three print statements to check the values.”);

System.out.println(“count should be 3, sum should be 15 and average should be 5.00:”);

System.out.println(“”);

System.out.println(“”);

System.out.print(“count = ” + getCount() + ” “);

System.out.print(“sum = ” + getSum() + ” “);

System.out.println(“average = ” + getAverage());

} // method main

/**

* Receives and processes a new number in the series

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype putNumber(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* Resets so all numbers previously forgotten. This is

* dangerous since average is now undefined.

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype reset(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* Resets with the first number of a new series. This is

* safer reset since the average remains defined.

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype reset(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype getSum(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

* – code to actually do what it should

*/

public static returntype getCount(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* This method needs to be completed. It needs:

* – a proper return type

* – a proper list of parameters (maybe empty)

*/

public static returntype getAverage(parametersIfAny)

{

/*

* Note: This body of this method “getAverage” has

* been provided in its entirety. You do NOT have

* to make any changes to it.

*/

return (

(double) sum  /  (double) count

);

}

} // class SummerStatic

Question 7

This exercise builds on the static version of the same exercise from last week. The idea is basically the same, we have series of methods to complete, but this time they are not static – i.e. they relate to object-level data.

This means that to actually use these methods and the data members they (should) access, an object needs to be created. As before, this part has actually already been done in the `main` method, and it is useful to observe the differences between this week and last’s week’s required exercises.

In many ways, the result of this exercise will look very similar to the static version, but now we can have several `BankAccount`s, with differing data.

To complete it, you have to provide return types, parameter lists and code for the following methods:

• `setInterestRate`
• `getInterestRate`
• `toString`

You also have to complete two constructors. If you are unsure what a constructor is, or the syntax, check the Classes and Objects lesson, or talk to the teaching staff.

Question 7 Starter Code

/**

* This Object-Oriented” version of the “BankAccount” class

* is a simple introduction to Constructors /

* private data members / static vs. not static / and the

* “toString” method.

*

* SKELETON FOR LAB TEST.

*/

public class BankAccountOO {

public static double interestRate = 0.0;

// Note: the interest rate is “static”. That is, all

//       bank accounts have the same interest rate.

/*

* The instance variables follow (i.e. not static). These

* are also called “fields” or “private data members”.

*/

public final int accountNumber;

public String accountName;

public double balance; // e.g. 1.27 means \$1.27

public static void main (String[] args) {

BankAccountOO.setInterestRate(7.50);

System.out.println(“(Interest rate should be 7.50) Interest rate is ” + BankAccountOO.getInterestRate() + “.”);

BankAccountOO bankaccountoo = new BankAccountOO(99998888,”Jack”);

System.out.println(“So we created an account for Jack with zero dollars in his bank account under the account number 99998888.”);

System.out.println(“”);

System.out.println(“”);

System.out.println(“For the object created, the account number is: ” + bankaccountoo.accountNumber);

System.out.println(“For the object created, the account name is: ” + bankaccountoo.accountName);

System.out.println(“For the object created, the balance is: ” + bankaccountoo.balance);

System.out.println(“”);

System.out.println(“”);

System.out.println(“”);

System.out.println(“Now we use the constructor which takes three argumants including name, number and initial balance:”);

BankAccountOO bankaccountoo2 = new BankAccountOO(12345678,”Jane”,1000.99);

System.out.println(“So we created an account for Jane with 1000.99 dollars in her bank account under the account number 12345678”);

System.out.println(“”);

System.out.println(“”);

System.out.println(“For the second object created, the account number is: ” + bankaccountoo2.accountNumber);

System.out.println(“For the second object created, the account name is: ” + bankaccountoo2.accountName);

System.out.println(“For the second object created, the balance is: ” + bankaccountoo2.balance);

System.out.println(“”);

System.out.println(“”);

System.out.println(“”);

System.out.println(“Now we use the method toString to print it all in the same line”);

System.out.println(“First object: ” + bankaccountoo.toString());

System.out.println(“Second object: ” + bankaccountoo2.toString());

System.out.println(“”);

System.out.println(“”);

System.out.println(“Testing withdraw method on Jane’s account: Jane’s new balance after we withdraw 100.00 is ” + bankaccountoo2.withdraw(100.00));

}

/**

*   The constructors now follow

*/

/**

* @param    num  number for the account

* @param    name name of the account

*/

public returnTypeIfAny nameOfConstructor(parametersIfAny) {

add whatever code is required in the constructor body

}

/**

* @param    num    number for the account

* @param    name   name of the account

* @param    bal    opening balance

*/

public returnTypeIfAny nameOfConstructor(parametersIfAny) {

add whatever code is required in the constructor body

}

/*

* A number of the methods from the “static” version

* have been left out of this object-oriented version

* because you’ve already done that once.

*

* Most of those methods would appear in a complete

* version of this object-oriented version of the

* class, with the *ONLY* change being that the reserved

* word “static” would be deleted from the method

*

* The method setAccountNumber() would definitely NOT

* be copied across from the static version to this

* object-oriented version. That’s because each object

* (i.e. instance of BankAccount) represents a unique

* bank account. The account number set up by the

* constructor should never change again.

*

* The method setAccountName() MIGHT be copied across.

* That’s a business decision.  Some banks might allow

* a customer to change their name.  Other banks might

* only allow a name change by creating a new account.

* If the account name cannot be changed, then the

* declaration of private data member “accountName”

* should have the reserved word “final” added.

*

* The method withdraw() has been copied across

* because:

* (1) it was provided in its entirety in the

*     “static” version of the class,

* (2) to provide an example that “static” is dropped

*     from the header,

* (3) to provide a hint as to what changes might be

*     needed for the other, incomplete methods.

*/

/**

* The withdrawal should be refused if the withdrawal

* would result in a negative balance.

*

* @param   amount  The amount to be withdrawn

*

* @return  new balance or -1.0 if withdrawal refused

*/

public returntype withdraw(double amount) {

if ( balance >= amount ) {

balance = balance – amount;

return balance;

}

else

return -1.0;

}

/**

* Note that this is a static method. So a change to the

* interest rate changes the interest rate for all objects

* of this class.

*

* @param   newInterest    The new interest rate

*/

public static returntype setInterestRate(parametersIfAny) {

add whatever code is required here in the method body

}

/**

* Note that this is a static method.

*

* @return   The interest rate

*/

public static returntype getInterestRate(parametersIfAny) {

add whatever code is required here in the method body

}

/**

* It is common practise to supply a “toString” method

* in an object-oriented class.  In fact, if you don’t

* explicitly supply such a method, Java produces an

* implicit, simplistic “toString” method which produces

* a String like “BankAccountOO@1edd1f0”. The word before

* the “@” is the name of the class. The hexadecimal

* number after the “@” is called the objects “hash code”.

*

* Note: Method “toString” method is NOT “static”. It

* can’t be static, since the values in the data members

* may vary between objects of this class.

*

*@return   The state of this “class instance” or “object”

*/

public returntype toString(parametersIfAny) {

return “accountNumber = ”  + accountNumber +

” accountName = ”   + accountName   +

” balance = ”       + balance;

}

} // class BankAccountOO

Question 8

As with the bank account exercises, here we revisit the Summer exercise and change from using static variables and methods to a mixture of static and non-static ones. As before, the immediate consequences to the written code are not dramatic, but the implied use is. Once this is complete, we can create multiple Summers, to keep as many sums as we care to, rather than only being able to retain a single sum in the static case. This exercise also includes a static variable and related static method that shows a more natural use of class level static data.

Your task here is to complete two constructors, and the methods getNumSummers and toString

Question 8 Starter Code

/**

* This Object-Oriented version of the “Summer” class

* is a simple introduction to constructors /

* private data members / static vs. not static / and the

* “toString” method.

*

* SKELETON FOR LAB TEST.

*

*

*/

public class SummerOO

{

static int numSummers = 0;

// The above variable is used to count the number of

// instances of the class SummerOO that have been created.

// (i.e. the number of objects that have been created.)

//

// Note: “numSummers” is declared as “static”. It is a

//       variable that belongs to the class, not an

//       individual object.

/*

* The instance variables follow (i.e. not static). These

* are also called “fields” or “data members”.

* Each object has its own copy of these variables.

*/

int sum;   // sum of all integers received

int count; // number of integers received

/**

* The constructors now follow. There are two constructors.

* Both constructors have the same name, since all

* constructors always have the same name as the class.

* The constructors are distinguishable because one of the

* constructors requires zero parameters while the other

* constructor requires a single integer parameter.

*/

/**

* This is a “dangerous” constructor, since the average is

* undefined when the object is created.

*

* This constructor and the method reset()

* are similar. The differences are that:

* (1) The constructor can only be used once, when the

*     object is created.

* (2) The method reset() can’t create an object, but it can

*     be used whenever we like, as many times as we like,

*     after the object has been created.

*/

public returnTypeIfAny nameOfConstructor()

{

add whatever code is required in the constructor body

}

/**

* This is a safer constructor, since the average is

* well defined when the object is created.

*

* This constructor and the method reset(int firstNumber)

* are similar. The differences are that:

* (1) The constructor can only be used once, when the

*     object is created.

* (2) The method reset() can’t create an object, but can

*     be used whenever we like, as many times as we like,

*     after the object has been created.

*

* @param   firstNumber The first number of a series

*/

public returnTypeIfAny nameOfConstructor(parameter)

{

add whatever code is required in the constructor body

}

/**

* Receives and processes a new number in the series.

*

* NOTE TO STUDENTS: When studying this code, experiment

* by adding “static” into “public void putNumber”.

* When you compile, you’ll get an error message …

*

* “non-static variable sum cannot be referenced from a

* static context”.

*

* In other words a “static” method (which belongs to the

* class, not an individuaual object), can’t access the

* variables in an object. This is for two reasons:

* (1) If we haven’t created ANY objects yet, then there is

*     no variable “sum” to access!

* (2) If multiple objects (“instances”) of this

*     class exist, then there are multiple versions of

*     the “sum” variable, one version of “sum” in each

*     object. The static method (which belongs to the

*     class) cannot choose from the many versions of “sum”.

*  The same applies to the variable “count”. The error

*  message singled out “sum” because it occured before

*  “count”.

*

* @param  newNumber   a new number in the series

*/

public /* not static! */ void putNumber(int newNumber)

{

// This method is complete. No changes are required to

// “putNumber” in the lab test.

sum = sum + newNumber; // could write “sum += newNumber”

count = count + 1;     // could write “++count”

}

/*

* A number of the methods from the “static” version

* have been left out of this object-oriented version

* because you’ve already done that.

*

* All those methods would appear in a complete

* version of this object-oriented version of the

* class, with the *ONLY* change being that the reserved

* word “static” would be deleted from the method

*

* The method putNumber() has been copied across to support

* the experiment of adding “static” to its header,

*/

/**

* Note that this is a static method.

*

* @return  The number of objects that have been created.

*/

public static returntype getNumSummers(parametersIfAny)

{

add whatever code is required here in the method body

}

/**

* It is common practise to supply a “toString” method

* in an object-oriented class.  In fact, if you don’t

* explicitly supply such a method, Java produces an

* implicit, simplistic “toString” method which produces

* a String like “SummerOO@1edd1f0”. The word before

* the “@” is the name of the class. The hexadecimal

* number after the “@” is called the objects “hash code”.

*

* Note: Method “toString” method is NOT “static”. It

* can’t be static, since the values in the data members

* may vary between objects of this class.

*

*@return   The state of this “class instance” / “object”

*/

public returntype toString(parametersIfAny)

{

return “sum = ”  +  sum  +  ” count = ”  +  count;

}

/**

* The main method is already complete, and you

* don’t need to change anything, but it won’t

* hurt anything if you do, as long as it still

* compiles.

*/

public static void main(String [] args)

{

SummerOO summer1 = new SummerOO();

// the above line used the zero parameter constructor.

summer1.putNumber(17);

summer1.putNumber(1);

System.out.println(summer1.toString());

// in the above line, the “.toString()” can be omitted,

// to give just …

//                  System.out.println(summer1);

//

// When the name of an object is given where a String

// is required (and println requires a String), Java

// automatically calls the “toString()” method of the

// object.

// Repeat for a second set of numbers

System.out.println();

SummerOO summer2 = new SummerOO(3);

// above line used the constructor that takes a parameter

summer2.putNumber(5);

summer2.putNumber(7);

System.out.println(summer2);

// in the above line, Java automatically calls the

// “toString()” method of the “summer2” object.

} // method main

} // class SummerOO

Question 9

The basic idea of a list in most programming languages is that of an array, but where elements can be added or removed (i.e. it can be resized).

In this exercise we’re going to take a step towards that idea and build a simplified version of a list backed by an array as the actually storage. That is, the class will store an array internally, but present a list-like interface to the outside world. The list will store `ints`, to help keep things simple.

The skeleton starts with the basic class defined, and a single data member `data` of type `int[]`. It’s `public` only to simplify testing, and `final` to prevent one particular misstep in some of the tasks.

The tasks are then to complete the methods in the class, as given by their method signatures (more detail is given in the comments in the class as well):

1. `MyArrayList()` – A constructor which will initialise the array and any other data members you add. The array should have length 6. Note that this is not the same as the size of the list, it just defines the maximum size. The list starts empty. The values stored in unused portions of the array are not important.
2. `boolean add(int)` – adds an element to the end of the list if there’s space. If there is, add it and return `true`. If not, return `false`.
3. `int get(int)` – returns the value at the specified position.
4. `int size()` – return the current size of the list (not necessarily the length of the array, which is the maximum capacity of the list).
5. `boolean overwriteWith(int, int)` – replace the element at the specified position with the new element. If this is successful, return `true`. If this is impossible, return `false`.
6. `void overwriteWith(MyArrayList)` – replace all the values in this list with the values from the other list. Note that this cannot fail, as the other list has the same capacity, so there is no return type.

Question 9 Starter Code

public class MyArrayList {

//The array to store the data.

public final int[] data;

//Constructor

public MyArrayList() {

this.data = null;

}

//Add element value to the end of the list

//return true if the element is added,

//false if there’s no space left

public boolean add(int value) {

return false;

}

//Return the element at position

//You don’t have to worry about

//positions less than 0 or greater

//than the array length – 1, but you

//do have to worry about positions that are

//after the end of the list. In that case

//return 0.

public int get(int position) {

return Integer.MIN_VALUE;

}

//Return the current size of the list

//Note that this may be different to

//the length of the array.

public int size() {

return -1;

}

//Replace the element at position with value

//Return true if the replacement happened,

//false otherwise.

public boolean overwriteWith(int position, int value) {

return false;

}

//Replace the data in the list with

//the elements of other. If other

//is smaller than the current list,

//the current list will get smaller.

public void overwriteWith(MyArrayList other) {

}

}

Get expert help for Data Structure Algorithms and many more. 24X7 help, plag free solution. Order online now!

Universal Assignment (November 29, 2023) Data Structure and Algorithms Assignment. Retrieved from https://universalassignment.com/data-structure-and-algorithms-assignment/.
"Data Structure and Algorithms Assignment." Universal Assignment - November 29, 2023, https://universalassignment.com/data-structure-and-algorithms-assignment/
Universal Assignment July 26, 2022 Data Structure and Algorithms Assignment., viewed November 29, 2023,<https://universalassignment.com/data-structure-and-algorithms-assignment/>
Universal Assignment - Data Structure and Algorithms Assignment. [Internet]. [Accessed November 29, 2023]. Available from: https://universalassignment.com/data-structure-and-algorithms-assignment/
"Data Structure and Algorithms Assignment." Universal Assignment - Accessed November 29, 2023. https://universalassignment.com/data-structure-and-algorithms-assignment/
"Data Structure and Algorithms Assignment." Universal Assignment [Online]. Available: https://universalassignment.com/data-structure-and-algorithms-assignment/. [Accessed: November 29, 2023]

## Please note along with our service, we will provide you with the following deliverables:

Please do not hesitate to put forward any queries regarding the service provision.

We look forward to having you on board with us.

# Get 90%* Discount on Assignment Help

### Most Frequent Questions & Answers

Universal Assignment Services is the best place to get help in your all kind of assignment help. We have 172+ experts available, who can help you to get HD+ grades. We also provide Free Plag report, Free Revisions,Best Price in the industry guaranteed.

We provide all kinds of assignmednt help, Report writing, Essay Writing, Dissertations, Thesis writing, Research Proposal, Research Report, Home work help, Question Answers help, Case studies, mathematical and Statistical tasks, Website development, Android application, Resume/CV writing, SOP(Statement of Purpose) Writing, Blog/Article, Poster making and so on.

We are available round the clock, 24X7, 365 days. You can appach us to our Whatsapp number +1 (613)778 8542 or email to info@universalassignment.com . We provide Free revision policy, if you need and revisions to be done on the task, we will do the same for you as soon as possible.

We provide services mainly to all major institutes and Universities in Australia, Canada, China, Malaysia, India, South Africa, New Zealand, Singapore, the United Arab Emirates, the United Kingdom, and the United States.

We provide lucrative discounts from 28% to 70% as per the wordcount, Technicality, Deadline and the number of your previous assignments done with us.

After your assignment request our team will check and update you the best suitable service for you alongwith the charges for the task. After confirmation and payment team will start the work and provide the task as per the deadline.

Yes, we will provide Plagirism free task and a free turnitin report along with the task without any extra cost.

No, if the main requirement is same, you don’t have to pay any additional amount. But it there is a additional requirement, then you have to pay the balance amount in order to get the revised solution.

The Fees are as minimum as \$10 per page(1 page=250 words) and in case of a big task, we provide huge discounts.

We accept all the major Credit and Debit Cards for the payment. We do accept Paypal also.

### 5 Places you must visit in Busan, South Korea

Write 2 articles 1st Topic: 5 Places you must visit in Busan, South Korea 2nd topic: Korean language: various tips and resources to learn Deadline: 10th October 2023 12:00 AM Instructions: Article Structure is given below Meta Description: First, you will start with a meta description of your article in

### 2002HSV Human Services Research

Assessment 2: Written research proposal Worth 45% of final grade Complete your answers in this assignment template Name: xxxxxxx Student ID: xxxxxxx Title: xxxxxxx Exact word count (exc. cover sheets and reference list; max. 2,000 words): x,xxx Please specify the research methodology are you proposing to use: ☐ Quantitative                                    ☐

### COIT29226 Introduction to IoT

Assessment item 3 – Project Due date: Week 12 (8 October 2023) 11:55 pm AEST Weighting: Length: Submission: 50% There is no word limit for this report Group work (submit via Moodle) Objectives This assessment item relates to the following unit learning outcomes: Learning Outcomes Assessed: Enabling objectives What do

### BUSM1008 Assessment 2 Brief Spring 2023

Assessment 2: Individual Report (20%) and Presentation (20%) Background You are appointed as a business consultant, recruited by the company allocated to you in week 6 by your tutor.  Your role is to undertake research on the company, the allocated topic and an issue identified in the media in relation to your company and

### ECON1020 PRINCIPLES OF ECONOMICS

INDIVIDUAL ASSIGNMENT Total Marks 100 | Weighting 25% DUE: 29/09/2023, 11:55pm IMPORTANT INFORMATION: READ BEFORE YOU START SUBMISSION 11.55 pm. A 1-hour grace period is provided to students who experience a technical concern. DOCUMENT PREPARATION REFERENCING UNACCEPTABLE ACADEMIC ACTIVITIES MARKING Question 1 | [12 marks] Download the spreadsheet data that

### ENTERPRISE LAW LAWS1001

Assessment task 3 Individual Case Study This task is the result of your individual effort, so students must not discuss their work with anyone else, otherwise it may lead to an allegation of collusion. Weight: 15% Due: Before 5 pm on Wednesday 27th September. Late submissions will incur a penalty

### International Business INBU01-7

Module International Business INBU01-7 (NQF LEVEL 7) FORMATIVE ASSESSMENT – ASSIGNMENT C Assignment C (INBU01-7/DLO4 10/2023) Exam Date 20 October 2023 Marks 50 Assignment C (INBU01-7/DLO4 10/2023)   Total: 20 marks SECTION A (10 MARKS) – PARAGRAPH QUESTION Question 1 (10 marks) Coca-Cola is marking its 70th year in Nigeria

### Summative Assessment Help

Summative Assessment Brief: Learning Outcomes: LO1: Construct a problem/issue/need identified from practice that impacts on individual outcomes LO2: Formulate a focus-based enquiry on the identified problem/issue/need utilising an area of individual learner interest LO3: Critically evaluate the evidence base to support the proposal of the solution focused initiative LO4: Develop

### EDU30067 Teaching English

Assignment 2: Folio Template INTRODUCTION:         LESSON 1 Lesson title:   Year level: Topic:   Duration of lesson: Curriculum links: Strands & sub-strands Content descriptions       Students background knowledge: What is your starting point – what do the students already know, what have they done

### Edge Computing Security and Privacy

Proposal Background Title: Edge Computing Security and Privacy Proposal The new computing paradigm in the Internet of Things domain is known as IoT edge computing which functions by processing calculations at the edge of the network (Alli & Alam, 2020). The current technology aided by cloud and fog computing has created

### Foundations of Communication Assessment 2 Instructions

Discussion task (Total grade – 10%)   Process Work (Steps to complete the task) Answer on the Assessment 2 Submission Document – Do not upload this instruction document. Requirements (important elements to include) lastname_firstname_studentID_COMS_Assess 2_semester_year. Process for Assessment discussion tasks NOTE: If you do not participate in the class discussions then

### Assessment Two Dos and Don’ts (Internal)

Do: Read the assessment instructions carefully Read the marking rubric carefully Understand the question – break it down Conduct research – record the reference details Read the topic materials about communication theories, forms and factors and refer to them Contribute to the discussions in class or no marks for the

### Unpacking the Question: Assessment Two

Studying at university requires you to become familiar with strategies to un-pack or breakdown a variety of assessment questions/tasks throughout your studies.  Task Example of integrating the discussion, research and theories. In the group discussion my group members (name them) stated that an advertisement for a beauty product would most

### MGMT0001 Introduction to Commerce Assessment

MGMT0001 Introduction to Commerce Assessment 2 (worth 30%) Due date:                  2:00pm (AWST) Friday 15th September 2023 Submission:              Via Turnitin assessment submission link (see ‘Assessment 2’ folder in ‘Assessments’ section of Blackboard). Additional Instructions: Part A (42 marks) Nathan is a well-known chef with years of experience cooking various cuisines. After

### ACCT5011: Accounting Systems in the Digital Age

Practical Assignment Guide, Semester 2, 2023 Due Date for Submission: Monday 11th September 2023 at 5.00 PM Please note that the Folio Assignment for ACCT5011 Accounting Systems in the Digital Age is an individual assessment task worth 30% of your total marks in the unit. Please refer to the online

### EC229- Review session

Assume two cities, A and B, that can’t trade between them. Each city produces its own coconuts for its local market. If suddenly trade is possible then: D) As we saw in class, the new price will be somewhere between the original price 𝑃_𝐴,𝑃_𝐵. Hence it is impossible for consumers

### Computing Theory COSC

Computing Theory COSC 1107/1105 Assignment 1: Fundamentals Assessment Type Individual assignment. Submit online via Canvas → As- signments → Assignment 1. Marks awarded for meeting re- quirements as closely as possible. Clarifications/updates may be made via announcements/relevant discussion forums. Due Date Week 6, Sunday 27th August 2023, 11:59pm Marks 125

### BE279 Applied Statistics and Forecasting

Strategy, Operations, & Entrepreneurship Group Essex Business School Module Code BE279 Module Title Applied Statistics and Forecasting Assessment Type Individual Report (2,000 word) Academic Year 2022/23, Spring Term Submission Deadline Refer to FASER Task Specific Guidance Please note that: Module Learning Outcomes On successful completion of the module, students will

### Learning Design Tool: Little Learners Level 1 sounds

Learning Design Tool: Little Learners Level 1 sounds. Prepared by Sara Hart Date 30th August, 2023 (feel free to leave this date as it is the AT2 due date) Brief description of Learning Design   Chooseit Maker: Create, edit and play personalised learning activities that can be used in your

### HUMN1041 PEOPLE, PLACE AND SOCIAL DIFFERENCE ASSIGNMENT

HUMN1041 PEOPLE, PLACE AND SOCIAL DIFFERENCE ASSIGNMENT 1 TEMPLATE This assignment is made up of three (3) parts, plus a reference list and appendix. Marks are allocated for each section, as follows: – 1 mark Please ensure that you provide your answers in this template, and provide a Reference list

### Model 3 Launch in Australia

Client Information Company Name Tesla Contact Name   Email   Phone Number   Address Level 14, 15 Blue St. North Sydney, NSW 2060 Australia Ad link & image Project Information Project Title Model 3 Launch in Australia Project Description (100 words) Highlight the uniqueness of the car. Show the superior

### MKT10009 Marketing and the Consumer Experience

School of Business, Law and Entrepreneurship Assessment Task – Assignment 2  MKT10009 Marketing and the Consumer Experience Semester 2, 2023. Assessment Type Analytical Report Associated Unit Learning Outcomes (ULO’s) 2, 3, 4 Group or Individual task Individual Value (%) 25% Due Date Monday 20th September at 10:00 AET – Enterthis

### ASSIGNMENT – 1st Evaluation

ASSIGNMENT – 1st Evaluation Date of Submission- 4TH SEP 2023 25 MARKS COMPARATIVE PUBLIC LAW Q. You are the new Central Minister for Urban Development who is keen to make major Indian cities as smart cities. You visit different countries like USA, UK, European Countries, Japan and other developed countries

### Corporate & Financial Due Diligence Report

[Name of the company] Note: Students should keep in mind that application of legal provisions (including Securities Regulations) and analysis of the same is important. Merely putting the facts and figures won’t fetch even a decent mark. Note: Students should only mention the broad area of business. This part should

### ECON1000 S2 2023 – Marking Guidance and FAQs on GTP

Students will be marked on the extent to which they specifically answer the question and provide clear, logical, well-reasoned and sufficient explanations. Here is a summary breakdown of how marks are allocated in this GTP: Part 1 [15 marks] §  Providing relevant observations from the information provided in the articles

### ECON1000 S2 2023 – GTP Brief

ECON1000 S2 2023 – GTP Brief A.  Context and Overview The Game Theory Presentation (GTP) is worth 30% of the final mark. GTP is a ‘take-home’ exercise with a set of tasks to do. The GTP is based on Lecture Topics: L1 and L2. You will have twenty (21) days

### Order #35042 Human Rights Research Essay

Draft due 26th Aug 2,500 words (excluding references and bibliography) Instructions: Structure: Title – The Tigray War: A Critical Analysis of What the Future Holds for Human Rights in the Region What can be done to ensure human rights violations will cease and be prosecuted? Expand on different actors and

### PMC1000: Applied Pathology

Assessment Task Sheet: Poster Presentation Date: Thursday 31st August 2023 | Weighting: 30% Assessment Task 2 You are required to develop a handout style resource (pamphlet or brochure) on a selected pathological condition which is aimed at first year student paramedics. You will need to use high quality peer reviewed

### Identify a current and topical public health ethical issue

Task Details You are required to identify a current and topical public health ethical issue in the workplace (if you work within a public health setting) or in a selected community and a plan of action to address the issue and submit it in Moodle as a Power Point presentation. The