(The Location class) Design a class named Location for locating a maximal value and its location in a two-dimensional array. The
class contains public data fields row, column, and maxValue that store the maximal value and its indices in a two dimensional array with row and column as int type and maxValue as double type.Write the following method that returns the location of the largest element in a two-dimensional array.public static int[] locateLargest(double[][] a)The return value is a one-dimensional array that contains two elements. These two elements indicate the row and column indices of the largest element in the two dimensional array. Write a test program that prompts the user to enter a two-dimensional array and displays the location of the largest element in the array. Here is a sample run:Enter the number of rows and columns of the array: 3 4Enter the array:23.5 35 2 104.5 3 45 3.535 44 5.5 9.6The location of the largest element is at (1, 2)
1 answer:
Answer:
Here is the Location class:
public class Location { //class name
public int row; // public data field to hold the value of no. of rows
public int column; // public data field to hold the value of no. of columns
public double maxValue; //public data field to hold the maximum value
public Location(int row, int column, double maxValue) { //parameterized constructor of Location class
//this keyword is used to refer to a current instance variable and used to avoid naming conflicts between attributes and parameters with the same name
this.row = row;
this.column = column;
this.maxValue = maxValue; }
public static Location locateLargest(double[][] a) { //method that takes a 2 dimensional array a as argument and returns the location of the largest element
int row = 0; //initializes row to 0
int column = 0; //initializes column to 0
double maxValue = a[row][column]; //stores largest element
for (int i = 0; i < a.length; i++) { //iterates through rows of a[] array
for (int j = 0; j < a[i].length; j++) { //iterates through columns of array
if (maxValue < a[i][j]) { //if the maxValue is less than the element of 2 dimensional array at ith row and jth column
maxValue = a[i][j]; //then set that element to maxValue
row = i; // i is set to traverse through rows
column = j; } } } // i is set to move through columns
return new Location(row,column,maxValue); } } //calls constructor of class by passing row, column and maxValue as argument
Explanation:
Here is the Main class with a main() function to test program
import java.util.Scanner; //to accept input from user
public class Main { //class name
public static void main(String[] args) { //start of main function
Scanner scan = new Scanner(System.in); //creates Scanner class object to scan the input from user
System.out.print("Enter the number of rows and columns in the array: "); //prompt for user
int row = scan.nextInt(); // reads value of row from user
int column = scan.nextInt(); //reads input value of column
double[][] array = new double[row][column]; //declares a 2 dimensional array named array
System.out.println("Enter the array:"); //prompts to enter array elements
for (int i = 0; i < array.length; i++) { //iterates through the rows of array until the size of array is reaced
for (int j = 0; j < array[i].length; j++) { //iterates through the columns of array
array[i][j] = scan.nextDouble(); } } //reads each element at i-th row and j-th column
Location location = Location.locateLargest(array); //calls locateLargest method by passing array to it in order to locate the largest element in the array
System.out.println("The largest element in a two-dimensional array is: " + location.maxValue); //displays the largest element of array
System.out.println("The location of the largest element is at (" + location.row + ", " + location.column + ")"); } } //displays the location of the largest element in the two dimensional array
Suppose the user enters 2 rows and 2 columns. The elements are:
1 5.5
4.5 3
The program works as follows:
for (int i = 0; i < array.length; i++) this outer loop iterates through rows
i = 0
inner loop for (int j = 0; j < array[i].length; j++) iterates through columns
array[i][j] = scan.nextDouble(); reads the element at position i-th row and j-th column. This becomes:
array[0][0] = scan.nextDouble();
so element at 0th row and 0th column is 1
Location location = Location.locateLargest(array); now this calls the method which works as follows:
double maxValue = a[row][column]; this becomes:
double maxValue = a[0][0];
so maxValue = 1
for (int i = 0; i < a.length; i++) this loop in method iterates through rows and for (int j = 0; j < a[i].length; j++) this iterates through columns of array
if (maxValue < a[i][j]) this becomes:
if (maxValue < a[0][0])
As we know that maxValue = 1 so this if condition is true.
maxValue = a[i][j]; this becomes:
maxValue = a[0][0];
maxValue = 1
Now set row = 0 and column = 0
Now the inner loop value of j is incremented to 1. So j = 1
At next iteration array[0][1] is checked. The element at this position is 5.5
if (maxValue < a[i][j]) is true because 1<5.5 so now value of maxValue becomes:
maxValue = 5.5
and
i = 0 j = 1
This way at each iteration of inner loop the columns are traversed and at each iteration of outer loop rows are traversed.
At next iteration element at array[1][0] is checked which is 4.5. This is not greater than maxValue so maxValue remains 5.5
At next iteration element at array[1][1] is checked which is 3. This is not greater than maxValue so maxValue remains 5.5 .
After both the loops end the statement:
return new Location(row,column,maxValue);
returns row , column and maxValue
where row = 0 column = 1 and maxValue = 5.5
So the output is:
The largest element in a two-dimensional array is: 5.5
The location of the largest element is at (0,1)
You might be interested in
Answer:
I am writing the program in C++ programming language.
#include<iostream> // to use input output functions
using namespace std; // to identify objects like cin cout
class ProblemSolution { //class name
private:
// private data members that only be accessed within ProblemSolution class
int real, imag;
// private variables for real and imaginary part of complex numbers
public:
// constructor ProblemSolution() to initialize values of real and imaginary numbers to 0. r is for real part and i for imaginary part of complex number
ProblemSolution(int r = 0, int i =0) {
real = r; imag = i; }
/* print() method that displays real and imaginary part in output of the sum of complex numbers */
void print(){
//prints real and imaginary part of complex number with a space between //them
cout<<real<<" "<<imag;}
// computes the sum of complex numbers using operator overloading
ProblemSolution operator + (ProblemSolution const &P){ //pass by ref
ProblemSolution sum; // object of ProblemSolution
sum.real = real + P.real; // adds the real part of the complex nos.
sum.imag = imag + P.imag; //adds imaginary parts of complex nos.
//returns the resulting object
return sum; } //returns the sum of complex numbers
}; //end of the class ProblemSolution
int main(){ //start of the main() function body
int real,imag; //declare variables for real and imaginary part of complex nos
//reads values of real and imaginary part of first input complex no.1
cin>>real>>imag;
//creates object problemSolution1 for first complex number
ProblemSolution problemSolution1(real, imag); //creates object
//reads values of real and imaginary part of first input complex no.2
cin>>real>>imag;
//creates object problemSolution2 for second complex number
ProblemSolution problemSolution2(real,imag);
//creates object problemSolution2 to store the addition of two complex nos.
ProblemSolution problemSolution3 = problemSolution1 + problemSolution2;
problemSolution3.print();} //calls print() method to display the result of the //sum with real and imaginary part of the sum displayed with a space
Explanation:
The program is well explained in the comments mentioned with each statement of the program. The program has a class named ProblemSolution which has two data members real and imag to hold the values for the real and imaginary parts of the complex number. A default constructor ProblemSolution() which initializes an the objects for complex numbers 1 and 2 automatically when they are created.
ProblemSolution operator + (ProblemSolution const &P) is the operator overloading function. This performs the overloading of a binary operator + operating on two operands. This is used here to add two complex numbers. In order to use a binary operator one of the operands should be passed as argument to the operator function. Here one argument const &P is passed. This is call by reference. Object sum is created to add the two complex numbers with real and imaginary parts and then the resulting object which is the sum of these two complex numbers is returned.
In the main() method, three objects of type ProblemSolution are created and user is prompted to enter real and imaginary parts for two complex numbers. These are stored in objects problemSolution1 and problemSolution2. Then statement ProblemSolution problemSolution3 = problemSolution1 + problemSolution2; creates another object problemSolution3 to hold the result of the addition. When this statement is executed it invokes the operator function ProblemSolution operator + (ProblemSolution const &P). This function returns the resultant complex number (object) to main() function and print() function is called which is used to display the output of the addition.
