Question

Building Each Exercise Driver

Download the drivers (ExerciseX.java) and start by reading the code. Notice in Exercise1.java’s main how each method for the problems below have already been invoked for you (Skeleton Level: Strong). As you complete additional exercises, notice the comments in each file. As exercises progress, you’ll be required to uncomment lines in main or even build parts of the main driver yourself. We’ll start with skeleton files that are almost complete, and then look at drivers where you need to provide additional code to get things to function correctly.

Exercise One: Searching, Containing and Finding Elements

Download the Driver “Exercise1.java”. We’re going to work on a few functions here, and I’ve already defined the few in question and invoked them from main. In future sections, this will be your responsibility. Lets consider the first function, contains()…

Define the following function in your Exercise1.java code…

public static boolean contains(int[] input, int target)

This function takes an array and a target integer, and returns true if the integer is found in the array, false otherwise.

Walk over the array looking for target; return true if found

Define the following function, using contains()

public static int indexOf(int[] input, int target)

i.This function takes an array as input and returns the index of the first occurrence of target in the input array, or -1 if not found

ii.Build this indexOf() function by calling contains, which you’ve already made above.

Define the following function, using contains()

public static int count(int[] input, int target)

i.This function counts the number of occurrences of target in the input array.

For example, given {1,3,4,5, 1}, the element 1 has a count of 2, whereas the element 6 has a count of 0.

You should try to use contains() here in this function as well.

Define the following function, using count()

public static void duplicates(int[]input, int[] output)

i.This function finds all numbers that occur more than once in the input list and puts them (once) in the output list.

For example, {3,3,3,4,4,5} as input produces {3,4,0,0,0,0} in output

ii.To accomplish this, use the counts function above…

Use counts() to determine if, say, “3” occurs more than once in the input

If it does, use counts() to determine if you’ve already put a “3” in the output.

----

"Ex 1 java file"

// Skeleton file for use with basic array algorithms, such as:// contains, indexOf, count and duplicates.//// Skeleton Level: Strong.// You only need to fill in existing functions// below to complete this driver, with no changes to main.//import java.util.Arrays;
public class Exercise1 {

//Notice that in this main, each of the functions have been called for youpublic static void main(String[] args) {

int[] data = {1,3,5,4,7,9,1,3};int[] output = new int[data.length];
System.out.println("Does our array contain a '1':"+contains(data,

1)); //true

System.out.println("Does our array contain a '0':"+contains(data,

0)); //false

System.out.println("What is the index of '4'? " + indexOf(data, 4));

//3

System.out.println("The number of occurrences of '1'? " +

count(data, 1)); //2

duplicates(data, output);System.out.println("After removing duplicates from data:");System.out.println(Arrays.toString(output));

}public static boolean contains(int[] input, int target) {

//todo: see labreturn false;

}public static int indexOf(int[] input, int target) {

//todo: only find the indexOf a target if we contain() itreturn -1;

}public static int count(int[] input, int target){

int retVal = 0;//todo: only try to count a number that we contain()
return retVal;

}public static void duplicates(int[] input, int[] output) {

//todo: Transfer items once from the arrays:input and output.//Transfer items from input to the output array IF:// only if newArray.count(target) == 0 //ie, we haven't put this

in yet

// only if newArray.indexOf(target) == -1 //not found in

newArray, or

// only if newArray.contains(target) == false //does not exist in

the new array}}

Answer 1

import java.util.Arrays;

public class Exercise {
    //Notice that in this main, each of the functions have been called for you
    public static void main(String[] args) {
        int[] data = {1,3,5,4,7,9,1,3};
        int[] output = new int[data.length];
      
        System.out.println("Does our array contain a '1':"+contains(data, 1)); //true
        System.out.println("Does our array contain a '0':"+contains(data, 0)); //false
        System.out.println("What is the index of '4'? " + indexOf(data, 4));    //3
        System.out.println("The number of occurrences of '1'? " + count(data, 1)); //2
      
        duplicates(data, output);
        System.out.println("After removing duplicates from data:");
        System.out.println(Arrays.toString(output));
    }
    public static boolean contains(int[] input, int target) {
        int trueCount = 0;
        int falseCount = 0;
      
        for (int i = 0; i < input.length; i++) { //iterate over array
            if (input[i] == target) { //if the array contains the target number
                trueCount++; //set boolean true
               } else {
                falseCount++; //set boolean false
               }
           }
      
        if (trueCount > 0) {
            return true; //if there are any trues, then it is true
        }   else {
            return false; //none true, is false
        }
      
    }
  
    public static int indexOf(int[] input, int target) {
        int i = 0;
        int retVal = -1;
      
        if (contains(input,target) == true) { //if it is contained
           for ( i = 0; i < input.length; i++) { //iterate over array
            if (input[i] == target) { //if the array contains the target number
                retVal = i; //set index to retVal
               }
            }
        }
      
        return retVal; //return index
        }
    public static int count(int[] input, int target){
        int retVal = 0;
      
        if (contains(input,target) == true) { //if it is contained
             for (int i = 0; i < input.length; i++) { //iterate over array
            if (input[i] == target) { //check for target #
                retVal++; //add count for every
            }
           }
        }
  
        //todo: only try to count a number that we contain()
      
        return retVal;
    }
    public static void duplicates(int[] input, int[] output) {
      
        Exercise newArray = new Exercise();
      
        for (int i = 0; i < input.length; i++) { //iterate over array
            if (newArray.count(input, i) == 0 || newArray.indexOf(input,i) == -1 ||
            newArray.contains(input,i) == false) { //all conditions to move over to output
                output[i] = input[i]; //move over to output
            } //otherwise the index is empty, or 0
        }
    }
}