Question

Make a program using Java that asks the user to input an integer "size". That integer makes and prints out an evenly spaced, size by size 2D array (ex: 7 should make an index of 0-6 for col and rows). The array must be filled with random positive integers less than 100. Then, using recursion, find a "peak" and print out its number and location. (A peak is basically a number that is bigger than all of its "neighbors" (above, below, left and right of it)).

Below is the actual directions.

A peak in a square 2D int array is a value that is not smaller than its (at most) four neighbors (north, east, south or west are the only potential neighbors). You must write a program that recursively searches for a peak in a square 2D int array using a recursive algorithm that will be reminiscent of (but substantially different than) Binary search. Your pro ram should first read an înt iom te user. Ί hroughout this discussion, we will call this value size and we will assume that size is always a positive int. Then, you should generate a 2D int array that is size by size, whose elements are randomly generated positive ints that are all less than 100. Then, you should print out the array (formatted with even spacing). Finally, print out the value and location (row, col) of a valid peak returned by the recursive algorithm. You must find a valid peak using the recursive method illustrated by the forthcoming example:

//Help would be greatly appreciated. I will definitely up vote if you can help me out. I was able to print out an evenly spaced array with random integers and thought of my base case and such, but I did not know how to implement all the code to make it work.

//comments are always helpful to me

Answer 1

import java.util.*; // headers MUST be above the first class

// one class needs to have a main() method
class Main {
// arguments are passed using the text field below this editor
public static void main(String[] args) {
Random r = new Random();
int low = 0;
int high = 100;

Scanner input = new Scanner(System.in);

System.out.println("Please enter size n");
int n = input.nextInt();

int array[][] = new int[n][n];

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int result = r.nextInt(high - low) + low;
array[i][j] = result;
}
}

int max = 0;
max = findPeak(array, n, n);
System.out.println("Maximum number in the row is " + max);
System.out.println();
}

// A wrapper over findPeakRec()
static int findPeak(int arr[][], int rows, int columns) {
return findPeakRec(arr, rows, columns, columns / 2);
}

static int findMax(int arr[][], int rows, int mid, int max) {
int max_index = 0;

for (int i = 0; i < rows; i++) {
if (max < arr[i][mid]) {
// Saving global maximum and its index
// to check its neighbours
max = arr[i][mid];
max_index = i;
}
}
return max_index;
}

static int findPeakRec(int arr[][], int rows, int columns,
int mid) {
// Evaluating maximum of mid column. Note max is
// passed by reference.
int max = 0;
int max_index = findMax(arr, rows, mid, max);

// If we are on the first or last column,
// max is a peak
if (mid == 0 || mid == columns - 1)
return max;

// If mid column maximum is also peak
if (max >= arr[max_index][mid - 1] &&
max >= arr[max_index][mid + 1])
return max;

// If max is less than its left
if (max < arr[max_index][mid - 1]) {
System.out.println("array is"+arr[max_index][mid - 1]);
System.out.println("rows is"+rows);
System.out.println("columns is"+columns);
System.out.println("mid is"+mid);

return findPeakRec(arr, rows, columns, (mid - mid / 2));
}

// If max is less than its left
// if (max < arr[max_index][mid+1])
return findPeakRec(arr, rows, columns, mid + mid / 2);
}
}