Sunday, 6 November 2016

Chapter 11 Exercise 9, Introduction to Java Programming, Tenth Edition Y. Daniel LiangY.

11.9 (Largest rows and columns) Write a program that randomly fills in 0s and 1s
into an n-by-n matrix, prints the matrix, and finds the rows and columns with the
most 1s. (Hint: Use two ArrayLists to store the row and column indices with
the most 1s.) Here is a sample run of the program:
Enter the array size n: 4
The random array is
0011
0011
1101
1010
The largest row index: 2
The largest column index: 2, 3
import javafx.scene.control.TextField;

public class Kit {

public static final int NOT_VALID = -1;

public static String randomNumbers(int size) {

String s = "";
for (int i = 0; i < size; i++) {
s += " " + (int) (Math.random() * 100);
}

return s;
}

public static Object[] getArray(Object... objects) {
Object[] temp = new TextField[objects.length];
for (int i = 0; i < objects.length; i++) {
temp[i] = objects[i];
}
return temp;
}

public static String binaryFormat(String binaryString) {

StringBuilder string = new StringBuilder(binaryString);

int extraZeros = string.length() % 4;

if (extraZeros != 0) {
for (int i = 0; i < extraZeros; i++) {
string.insert(0, "0");
}
}

for (int i = string.length() - 1; i >= 0; i--) {

if (i % 4 == 0 && i != 0) {
string.insert(i, " ");
}
}

return string.toString();

}
public static String hexToBinary(String hex) {

return decimalToBinary(hexToDecimal(hex));
}

public static String decimalToBinary(long n) {

StringBuilder stringBuilder = new StringBuilder();
while (n > 0) {

stringBuilder.insert(0, n & 1);
n >>= 1;
}

return stringBuilder.toString();
}

public static String decimalToHex(long n) {

StringBuilder stringBuilder = new StringBuilder();
while (n > 0) {

stringBuilder.insert(0, decimalToHexChar(n % 16));
n /= 16;

}

return stringBuilder.toString();
}
public static long hexToDecimal(String hex) {

long n = 0;

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

char ch = hex.charAt(i);

if (isNumeric(ch)) {
n += (charToDecimal(ch) * Math.pow(16, placeValue--));
} else {
n += hexLetterToInt(ch) * Math.pow(16, placeValue--);

}
}
return n;
}

private static int hexLetterToInt(char ch) {

ch = Character.toUpperCase(ch);

return (ch - 'A' + 10);
}

/** returns Z is n is > 15 */
private static char decimalToHexChar(long n) {

if (n > 15) return 'Z';
if (n > 9) return (char)(n % 10 + 'A');

return (char)(n + '0');
}
public static long stringToDecimal(String s) {

long n = 0;
int placeValue =  s.length() - 1;

for (int i = 0; i < s.length(); i++) {

int valid = charToDecimal(s.charAt(i));

if (valid == NOT_VALID) return NOT_VALID;

n += (Math.pow(10, placeValue--) * valid);

}

return n;
}

public static String decimalToString(long n) {

StringBuilder s = new StringBuilder();

while (n != 0) {

s.insert(0, n % 10);
n /= 10;
}

return s.toString();
}

public static int charToDecimal(char ch) {

if (!isNumeric(ch)) return NOT_VALID;

return ch - '0';

}
public static boolean isNumeric(String s) {

for (int i = 0; i < s.length(); i++) {

if (!isNumeric(s.charAt(i))) return false;
}

return true;
}
public static boolean isNumeric(char ch) {

return (ch >= '0' && ch <= '9');
}

public static boolean isHexadecimal(String s) {

for (int i = 0; i < s.length(); i++) {

if (!isHexValid(s.charAt(i))) return false;
}

return true;
}

public static boolean isHexValid(char ch) {

ch = Character.toUpperCase(ch);

return isCharAtRange(ch, '0', '9') || isCharAtRange(ch, 'A', 'F');

}

public static boolean isCharAtRange(char ch, char start, char end) {

return !(ch < start || ch > end);

}

public static int count(String str, char a) {

int count = 0;
for (int i = 0; i < str.length(); i++) {

if (str.charAt(i) == a) count++;
}

return count;
}

public static void displayGrid(int[][] grid) {

for (int[] aGrid : grid) {

System.out.printf("%20s", "");
for (int k = 0; k < aGrid.length; k++) {
System.out.printf("|%-2d|", aGrid[k]);
}
System.out.println("");
}

}

public static void displayGrid(int[] grid) {
for (int i = 0; i < grid.length; i++) {

System.out.printf("%-4d ", grid[i]);
if ((i + 1) % 10 == 0)
System.out.println("");
}

}

public static void displayTimesTable(int x, int y) {
// display 8x8 numbered grid to help solve exercise
for (int i = 1; i <= y; i++) {

System.out.printf("%20s", "");
for (int k = 1; k <= x; k++) {
System.out.printf("|%-2d|", i * k);
}
System.out.println("");
}
}

public static int[] makeUnsortedArray(int size, int range) {
int[] array = new int[size];

for (int i = 0; i < array.length; i++) {
array[i] = (int) (Math.random() * range + 1);
}

return array;
}

public static double[][] makeUnsortedArray(int rows, int columns, int range) {
double[][] array = new double[rows][columns];

for (int i = 0; i < array.length; i++) {

for (int j = 0; j < array[i].length; j++) {
array[i][j] = (int) (Math.random() * range + 1);
}
}

return array;
}

public static int[] merge(int[] list1, int[] list2) {

int[] merge = new int[list1.length + list2.length];
int m = 0, l1 = 0, l2 = 0;
boolean l1isFinished = false;
boolean l2isFinished = false;

while (!l1isFinished || !l2isFinished) {

if (l1 == list1.length) l1isFinished = true;
if (l2 == list2.length) l2isFinished = true;
if (l1isFinished && l2isFinished) break;

if (!l1isFinished && l2isFinished) merge[m++] = list1[l1++];
else if (!l2isFinished && l1isFinished) merge[m++] = list2[l2++];
else if (list1[l1] <= list2[l2]) merge[m++] = list1[l1++];
else if (list2[l2] <= list1[l1]) merge[m++] = list2[l2++];

}
return merge;
}

public static boolean isSorted(int[] numbers) {

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

if (numbers[i] > numbers[i + 1]) return false;

}
return true;
}

public static void displayMatrix(double[][] matrix) {
for (double[] aMatrix : matrix) {

for (int column = 0; column < aMatrix.length; column++) {
System.out.printf("%5.0f ", aMatrix[column]);
}
System.out.printf("\n");
}
}

public static void display(Object[] objects) {

int count = 1;
for (Object o : objects) {
System.out.printf("%4s\n", o.toString());
if (count % 10 == 0) {
System.out.println("");
}
count++;
}
}
}


import java.util.ArrayList;
import java.util.Scanner;
public class Exercise_09 {

public static void main(String[] args) {

System.out.print("Enter the array size n: ");
int n = new Scanner(System.in).nextInt();
int[][] m = new int[n][n];

for (int i = 0; i < m.length; i++) {
for (int j = 0; j < m[i].length; j++) {
m[i][j] = (int) (Math.random() * 2);
}
}

ArrayList<Integer> row = new ArrayList<>();
ArrayList<Integer> column = new ArrayList<>();
getHighestRow(m, row);
getHighestColumn(m, column);

Kit.displayGrid(m);
System.out.println("Highest row: " + row);
System.out.println("Highest column: " + column);

}

public static void getHighestRow(int[][] m, ArrayList<Integer> row) {

int highest = 0;
for (int i = 0; i < m.length; i++) {
int occurrence = 0;
for (int j = 0; j < m[i].length; j++) {

if (m[i][j] == 1) {
occurrence++;
}
}
if (highest < occurrence) {
highest = occurrence;
row.clear();
} else if (highest == occurrence) {
}
}

}
public static void getHighestColumn(int[][] m, ArrayList<Integer> column) {

int highest = 0;
for (int j = 0; j < m[0].length; j++) {
int occurrence = 0;
for (int i = 0; i < m.length; i++) {

if (m[i][j] == 1) {
occurrence++;
}
}
if (highest < occurrence) {
highest = occurrence;
column.clear();