Question

1) Write a public static method named printArray, that takes two arguments. The first argument is an Array of int and the second argument is a String. The method should print out a list of the values in the array, each separated by the value of the second argument.

For example, given the following Array declaration and instantiation:

int[] myArray = {1, 22, 333, 400, 5005, 9}; printArray(myArray, ", ") will print out 1, 22, 333, 400, 5005, 9

printArray(myArray, " - ") will print out 1 - 22 - 333 - 400 - 5005 - 9
2) Write a public static method named getFirst, that takes an Array of int as an argument and returns the value of

the first element of the array.
For example, given the following Array declaration and instantiation:

int[] myArray = {1, 22, 333, 400, 5005, 9}; getFirst(myArray) will return 1

3) Write a public static method named getLast, that takes an Array of int as an argument and returns the value of the last element of the array.

For example, given the following Array declaration and instantiation:

int[] myArray = {1, 22, 333, 400, 5005, 9}; getLast(myArray) will return 9

4) Write a public static method named getAllButFirst, that takes an Array of int as an argument and creates and returns a new array with all of the values in the argument array except the first value.

For example, given the following Array declaration and instantiation:

int[] myArray = {1, 22, 333, 400, 5005, 9};
getAllButFirst(myArray) will return an Array of int with these values {22, 333, 400, 5005, 9}

5) Write a public static method named getIndexOfMin, that takes an Array of int as an argument and returns the index of the least value in the array.

For example, given the following Array declaration and instantiation:

int[] myArray = {333, 22, 1, 400, 5005, 9}; getIndexOfMin(myArray) will return 2

6) Write a public static method named getIndexOfMax, that takes an Array of int as an argument and returns the index of the largest value in the array.

For example, given the following Array declaration and instantiation:

int[] myArray = {1, 22, 333, 400, 5005, 9};

getIndexOfMax(myArray) will return 4

7) Write a public static method named swapByIndex, that takes three arguments. The first argument is an Array of int, and the second and third arguments are int indexes. This method will swap the values at the two given index arguments in the array, and return a reference to the array.

For example, given the following Array declaration and instantiation:

int[] myArray = {1, 22, 333, 400, 5005, 9};
swapByIndex(myArray, 1, 4) will return the Array with these values {1, 5005, 333, 400, 22, 9}

8) Write a public static method named removeAtIndex, that takes two arguments. The first argument is an Array of int, and the second argument is an int index. This method create and return a new array with all of the values in the argument array except the value at the argument index.

For example, given the following Array declaration and instantiation:

int[] myArray = {1, 22, 333, 400, 5005, 9};
removeAtIndex(myArray, 3) will return an Array with these values {1, 22, 333, 5005, 9}

9) Write a public static method named insertAtIndex, that takes three arguments. The first argument is an Array of int, the second argument is an int index, and the third argument is an int value. This method create and return a new array with all of the values in the argument array and including the third argument value inserted at the index specified by the second argument value.

For example, given the following Array declaration and instantiation:

int[] myArray = {1, 22, 333, 400, 9};
insertAtIndex(myArray, 2, 777) will return an Array with these values {1, 22, 777, 333, 400, 9}

10) Write a public static method named isSorted, that takes an Array of int as an argument. This method should return the boolean value true if all the element values in the array are in ascending order; otherwise the method should return the boolean value false.

For example, given the following Array declaration and instantiation:

int[] myArray = {22, 5005, 400, 333, 1, 9}; isSorted(myArray) will return false

Method Template

Here is a template that you may use or refer to when defining your methods. All of your ten methods will follow this template; you must provide the components designated by the angle brackets (< >)

public static <returnType> <methodName>(<parameters>) { <methodBody>

}

Answer 1

I've also added a main method to demonstrate all the methods.

# If you have a query/issue with respect to the answer, please drop a comment. I will surely try to address your query ASAP and resolve the issue

# # Please consider providing a thumbs up to this question if it helps you. by doing that, you will help other students who are facing a similar issue.

//--------------OUTPUT--------------------------

//--------------------------------------------------

import java.util.Arrays;

public class Main{

    public static void main(String[] args){

        

        int[] array={43,42,23,42,4,56,36,7,8,676,54};

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

        printArray(array,"*");

        System.out.println(""+getFirst(array));

        System.out.println(""+getLast(array));

        System.out.println(Arrays.toString(getAllButFirst(array)));

        System.out.println(""+getIndexOfMin(array));

        System.out.println(""+getIndexOfMax(array));

        System.out.println(Arrays.toString(swapByIndex(array, 1,2)));

        System.out.println(Arrays.toString(removeAtIndex(array,3)));

        System.out.println(Arrays.toString(insertAtIndex(array,3,65)));

    }

    //---1----

    public static void printArray(int[] arr, String sep){

        for(int i=0; i<arr.length-1;i++){

            System.out.print(" "+arr[i]+" "+sep);

        }

        System.out.println(" "+arr[arr.length-1]);

    }

    //---2----

    public static int getFirst(int[] arr){

        return arr[0];

    }

    //---3----

    public static int getLast(int[] arr){

        return arr[arr.length-1];

    }

    //---4-----

    public static int[] getAllButFirst(int[] arr){

        int[] anotherArray=new int[arr.length-1];

        for(int i=1; i<arr.length;i++){

            anotherArray[i-1]=arr[i];

        }

        return anotherArray;

    }

    //---5------

    public static int getIndexOfMin(int[] arr){

        int index=0;

        int min=arr[0];

        for(int i=1; i<arr.length;i++){

            if(min>arr[i]){

                min=arr[i];

                index=i;

            }

        }

        return index;

    }

    //---6------

    public static int getIndexOfMax(int[] arr){

        int index=0;

        int max=arr[0];

        for(int i=1; i<arr.length;i++){

            if(max<arr[i]){

                max=arr[i];

                index=i;

            }

        }

        return index;

    }

    //---7------

    public static int[] swapByIndex(int[] arr, int a , int b){

        int temp=arr[a];

        arr[a]=arr[b];

        arr[b]=temp;

        return arr;

    }

    //---8------

    public static int[] removeAtIndex(int[] arr, int index){

        int[] anotherArray = new int[arr.length - 1];

for (int i = 0, k = 0; i < arr.length; i++) {

if (i == index) {

continue;

}

anotherArray[k++] = arr[i];

}

// return the resultant array

return anotherArray;

    }

    //---9------

    public static int[] insertAtIndex(int[] arr, int index, int element){

        int[] anotherArray = new int[arr.length + 1];

        

for (int i = 0, k=0;k < arr.length+1; k++) {

if (k == index) {

anotherArray[k]=element;

                continue;

}

anotherArray[k] = arr[i++];

}

// return the resultant array

return anotherArray;

    }

    //---10------

    public static boolean isSorted(int[] arr){

        for(int i=0; i<arr.length-1;i++){

            if (arr[i+1]<arr[i]){

                return false;

            }

        }

        return true;

    }

}