Answer:
Check the explanation
Explanation:
// Define a Square class with methods to create and read in
// info for a square matrix and to compute the sum of a row,
// a column, either diagonal, and whether it is magic.
//
// ****************************************************************
import java.util.Scanner;
import java.io.*;
public class Square {
int[][] square;
//--------------------------------------
//create new square of given size
//--------------------------------------
public Square(int size) {
square = new int[size][size];
}
//-----------------------------------------------
//return the sum of the values in the given row
//-----------------------------------------------
public int sumRow(int row) {
// Add your code here
int sum = 0;
for (int i = 0; i < square.length; i++) {
sum = sum + square[row][i];
}
return sum;
}
//-------------------------------------------------
//return the sum of the values in the given column
//-------------------------------------------------
public int sumCol(int col) {
// Add your code here
int sum = 0;
for (int i = 0; i < square.length; i++) {
sum = sum + square[i][col];
}
return sum;
}
//---------------------------------------------------
//return the sum of the values in the main diagonal
//---------------------------------------------------
public int sumMainDiag() {
// Add your code here
int sum = 0;
for (int i = 0; i < square.length; i++) {
sum = sum + square[i][i];
}
return sum;
}
//---------------------------------------------------------------
//return the sum of the values in the other ("reverse") diagonal
//---------------------------------------------------------------
public int sumOtherDiag() {
// Add your code here
int sum = 0;
for (int i = 0; i < square.length; i++) {
sum = sum + square[square.length - i - 1][i];
}
return sum;
}
//-------------------------------------------------------------------
//return true if the square is magic (all rows, cols, and diags have
//same sum), false otherwise
//-------------------------------------------------------------------
public boolean magic() {
// Add your code here. Check if the sum of main diagonal equals the other diagonal,
// also if all rows and all columns sums equal to the diagonal as well. Any uneuqal will
// terminate the comparison.
int d1 = sumMainDiag();
int d2 = sumOtherDiag();
if (d1 != d2) {
return false;
}
for (int i = 0; i < square.length; i++) {
if (d1 != sumRow(i) || d1 != sumCol(i)) {
return false;
}
}
return true;
}
//----------------------------------------------------
//read info into the square from the standard input.
//----------------------------------------------------
public void readSquare(Scanner scan) {
for (int row = 0; row < square.length; row++) {
for (int col = 0; col < square.length; col++) {
square[row][col] = scan.nextInt();
}
}
}
//---------------------------------------------------
//print the contents of the square, neatly formatted
//---------------------------------------------------
public void printSquare() {
for (int row = 0; row < square.length; row++) {
for (int col = 0; col < square.length; col++) {
System.out.print(square[row][col] + "\t");
}
System.out.println();
}
}
}
// ****************************************************************
// SquareTest.java
//
// Uses the Square class to read in square data and tell if
// each square is magic.
//
// ****************************************************************
class SquareTest {
public static void main(String[] args) throws IOException {
File file = new File("magicData.txt");
Scanner scan = new Scanner(file);
int count = 1; //count which square we're on
int size = scan.nextInt(); //size of next square
//Expecting -1 at bottom of input file
while (size != -1) {
//create a new Square of the given size
Square magicSquare = new Square(size);
//call its read method to read the values of the square
magicSquare.readSquare(scan);
System.out.println("\n******** Square " + count + " ********");
//print the square
magicSquare.printSquare();
//print the sums of its rows
for (int row = 0; row < size; row++) {
System.out.println("Sum of row " + row + ": "
+ magicSquare.sumRow(row));
}
//print the sums of its columns
for (int col = 0; col < size; col++) {
System.out.println("Sum of column " + col + ": "
+ magicSquare.sumCol(col));
}
//print the sum of the main diagonal
System.out.println("Sum of the main diagonal: "
+ magicSquare.sumMainDiag());
//print the sum of the other diagonal
System.out.println("Sum of the other diagonal: "
+ magicSquare.sumOtherDiag());
//determine and print whether it is a magic square
if (magicSquare.magic()) {
System.out.println("It's a magic square!");
} else {
System.out.println("It's not a magic square!");
}
System.out.println();
//get size of next square
size = scan.nextInt();
count++;
}
}
}
Answer:
See explaination
Explanation:
/ Define a Square class with methods to create and read in
// info for a square matrix and to compute the sum of a row,
// a column, either diagonal, and whether it is magic.
//
// ************************************************************
import java.util.Scanner;
import java.io.*;
public class Square {
int[][] square;
//--------------------------------------
//create new square of given size
//--------------------------------------
public Square(int size) {
square = new int[size][size];
}
//-----------------------------------------------
//return the sum of the values in the given row
//-----------------------------------------------
public int sumRow(int row) {
// Add your code here
int sum = 0;
for (int i = 0; i < square.length; i++) {
sum = sum + square[row][i];
}
return sum;
}
//-------------------------------------------------
//return the sum of the values in the given column
//-------------------------------------------------
public int sumCol(int col) {
// Add your code here
int sum = 0;
for (int i = 0; i < square.length; i++) {
sum = sum + square[i][col];
}
return sum;
}
//---------------------------------------------------
//return the sum of the values in the main diagonal
//---------------------------------------------------
public int sumMainDiag() {
// Add your code here
int sum = 0;
for (int i = 0; i < square.length; i++) {
sum = sum + square[i][i];
}
return sum;
}
//---------------------------------------------------------------
//return the sum of the values in the other ("reverse") diagonal
//---------------------------------------------------------------
public int sumOtherDiag() {
// Add your code here
int sum = 0;
for (int i = 0; i < square.length; i++) {
sum = sum + square[square.length - i - 1][i];
}
return sum;
}
//-------------------------------------------------------------------
//return true if the square is magic (all rows, cols, and diags have
//same sum), false otherwise
//-------------------------------------------------------------------
public boolean magic() {
// Add your code here. Check if the sum of main diagonal equals the other diagonal,
// also if all rows and all columns sums equal to the diagonal as well. Any uneuqal will
// terminate the comparison.
int d1 = sumMainDiag();
int d2 = sumOtherDiag();
if (d1 != d2) {
return false;
}
for (int i = 0; i < square.length; i++) {
if (d1 != sumRow(i) || d1 != sumCol(i)) {
return false;
}
}
return true;
}
//----------------------------------------------------
//read info into the square from the standard input.
//----------------------------------------------------
public void readSquare(Scanner scan) {
for (int row = 0; row < square.length; row++) {
for (int col = 0; col < square.length; col++) {
square[row][col] = scan.nextInt();
}
}
}
//---------------------------------------------------
//print the contents of the square, neatly formatted
//---------------------------------------------------
public void printSquare() {
for (int row = 0; row < square.length; row++) {
for (int col = 0; col < square.length; col++) {
System.out.print(square[row][col] + "\t");
}
System.out.println();
}
}
}
// ****************************************************************
// SquareTest.java
//
// Uses the Square class to read in square data and tell if
// each square is magic.
//
// ****************************************************************
class SquareTest {
public static void main(String[] args) throws IOException {
File file = new File("magicData.txt");
Scanner scan = new Scanner(file);
int count = 1; //count which square we're on
int size = scan.nextInt(); //size of next square
//Expecting -1 at bottom of input file
while (size != -1) {
//create a new Square of the given size
Square magicSquare = new Square(size);
//call its read method to read the values of the square
magicSquare.readSquare(scan);
System.out.println("\n******** Square " + count + " ********");
//print the square
magicSquare.printSquare();
//print the sums of its rows
for (int row = 0; row < size; row++) {
System.out.println("Sum of row " + row + ": "
+ magicSquare.sumRow(row));
}
//print the sums of its columns
for (int col = 0; col < size; col++) {
System.out.println("Sum of column " + col + ": "
+ magicSquare.sumCol(col));
}
//print the sum of the main diagonal
System.out.println("Sum of the main diagonal: "
+ magicSquare.sumMainDiag());
//print the sum of the other diagonal
System.out.println("Sum of the other diagonal: "
+ magicSquare.sumOtherDiag());
//determine and print whether it is a magic square
if (magicSquare.magic()) {
System.out.println("It's a magic square!");
} else {
System.out.println("It's not a magic square!");
}
System.out.println();
//get size of next square
size = scan.nextInt();
count++;
}
}
}
B. Available positions
C. All other answers
D.empty positions
Answer: B)Available positions
Explanation:Open addressing is the addressing method for the components that are present in the hash table. collision are controlled and managed by this process. The total count of keys is less or equal to the size of table.
Linear probing is the mechanism that helps in controlling of the collision happening by the process of key collection maintenance by encoding of the available positions of the element in the hash table.So,the correct option is option(B).
Answer:
Scope creep is defined as the uncontrolled changes occur in the projects scope is known as scope creep. It basically occur when the project scope are not properly define and controlled.
Suggestions for preventing scope creep in projects are as follow:
{
privtae int num1;
private int num2;
/missing constructor /
}
The following statement appears in a method in a class other than Tester. It is intended t o create a new Tester object t with its attributes set to 10 and 20.
Tester t = new Tester(10,20);
Which can be used to replace / missing constructor / so that the object t is correctly created?
Answer:
Explanation:
The following constructor needs to be added to the code so that the object called t can be created correctly...
public Tester(int arg1, int arg2) {
num1 = arg1;
num2 = arg2;
}
This basic constructor will allow the object to be created correctly and will take the two arguments passed to the object and apply them to the private int variables in the class. The question does not state what exactly the Tester constructor is supposed to accomplish so this is the basic format of what it needs to do for the object to be created correctly.
Answer:
Program :
#include <stdio.h> //header file
char* isEven(int number) //function
{
if(number%2==0)
return "True";
else
return "False";
}
int main() //mainfunction
{
printf("%s",isEven(43)); //calling and display output.
return 0; //return statement.
}
Output:
Explanation:
Answer:
It will show compilation error like - no match for 'operator>>'
Explanation:
<< and >> are input output stream operators which are used with different input output stream objects in C++. So << operator is used to output stream of characters to console or a file and >> operator is used to input or read some characters or integers from a file or console. Here input stream character is used with output stream object cout, which produces an error.