import java.awt.DisplayMode;
import java.util.Scanner;
 
 
 
public class mainClass {
 
private static String[][] Cell;
final static String normal="white";
final String abnormal="green";
final static String temp="red";
 
 
public static void main(String []args){
 
Scanner w = new Scanner(System.in);
Cell c1 = new Cell();
//please implement the main method
 
System.out.println("Please enter the size of the array: ");
int size = w.nextInt();
 
displayArray();
 
c1.initializeColor(size);
 
System.out.print("Please enter the the cordinates to chek: ");
 
System.out.println("r: ");
int x = w.nextInt();
 
System.out.println("c: ");
int y = w.nextInt();
 
countCells( x, y);
 
 
 
}//end main
 
 
/*
*The method countCells is a RECURSIVE method whose job is to find
*how many cells are in the same blob as a given cell (i.e cell with
*specified coordinates x and y). The variable int size represents the
*size of the two-dimensional array. This value would have been provided
*by the user at the beginning of the main method.
*Do NOT make any changes to the method declartion.
*/
 
public static int countCells( int x, int y){
int count=0;
 
for(int x1=0; x1<Cell.length; x1++)
for(int y1=0; y1<Cell.length; y1++){
Cell[x][y]=normal;
}
 
for(int x1=0; x1<Cell.length; x1++)
for(int y1=0; y1<Cell.length; y1++){
if(getblobsize(x,y, Cell) > 0)
count++;
}
System.out.print("The number of blobs: " + count);
return count;
 
}//countCells()
 
 
 
 
private static int getblobsize(int r, int c, String Cell[][]) {
 
if(r<0 || r>=Cell.length || c<0 || c>=Cell.length){
return 0;
}
 
if(Cell[r][c] == temp || Cell[r][c] == normal){
return 0;
}
 
else{
int time=1;
 
time += getblobsize( r - 1, c + 1, Cell);
time += getblobsize( r, c + 1, Cell);
time += getblobsize( r + 1, c + 1, Cell);
time += getblobsize(r + 1, c, Cell);
time += getblobsize( r + 1, c - 1, Cell);
time += getblobsize( r, c - 1, Cell);
time += getblobsize( r - 1, c - 1, Cell);
time += getblobsize( r - 1, c, Cell);
return time;
 
}
}
 
 
 
 
/*
* The method diplayArray is provided for you to call when you want to
* display your array on the screen. You should know how and when to 
* to use this method in your program by looking at its declaration and
* the expected output.Do NOT make any changes to this method.
*/
 
public static void displayArray(Cell [][] ,int size){
for(int i=0;i<size;i++){
System.out.println();
System.out.print("-");
for(int j=0;j<size;j++){
System.out.print("-+");
}
System.out.println();
for (int j=0;j<size;j++){
String color=cells[i][j].getColor();
System.out.print("|"+color.charAt(0));
 
}
System.out.print("|");
 
}//outer
System.out.print("\n-");
for(int j=0;j<size;j++){
System.out.print("-+");
}
}//end displayArray()
 
}//end mainClass

public class Cell implements Interface1{
 
private String color;
final String normal="white";
final String abnormal="green";
final String temp="red";
private int column;
private int row;
 
/*Please implement this class. Remember this class
* must implement all the methods declared in the interface
* Interface1.
*/
 
/**
* Method initializeColor will be used to initialize the color
* of each cell in the two-dimensional array.
* The cell can be one of two colors: "green" or "white". Whether 
* a cell will be "white" or "green" should be decided randomly.
* Since the assignment specifies that there should be more normal 
* (white) cells than abnormal (green) cells, you should devise an 
* algorithm that assigns:
* white: 70% of the time
* green: 30% of the time
* (hint:you can use Math.random() for this purpose)
*/
 
public void initializeColor(int size) {
// TODO Auto-generated method stub
Cell[][] Cell = new Cell[row][column];
int d=(size*(70/100));
int b=(size*(30/100));
for (int size1 = 0; size1 < row; size1++){
while(row <= d);{
do([row] = setColor(normal);
}
}
for (int size1 = 0; size1 < column; size1++) {
while(column <= b);{
do([column] = setColor(abnormal);
}
}
}
 
public String getColor() {
// TODO Auto-generated method stub
return null;
}
 
public void setColor(String color) {
// TODO Auto-generated method stub
this.normal;
this.abnormal;
}
 
public void initializeColor() {
// TODO Auto-generated method stub
 
}
 
 
}

/**
* Interface1 defines some constants and declares
* some methods that must be implemented by the
* class "Cell". The purpose of each method is
* described below. Note the statement that says
* public class Cell implements Interface1
*/
public interface Interface1 {
final String normal="white";
final String abnormal="green";
final String temp="red";
 
/**
* Method initializeColor will be used to initialize the color
* of each cell in the two-dimensional array.
* The cell can be one of two colors: "green" or "white". Whether 
* a cell will be "white" or "green" should be decided randomly.
* Since the assignment specifies that there should be more normal 
* (white) cells than abnormal (green) cells, you should devise an 
* algorithm that assigns:
* white: 70% of the time
* green: 30% of the time
* (hint:you can use Math.random() for this purpose)
*/
public void initializeColor();
 
/**
* The method setColor is a typical setter method that
* sets the color of a given cell to a certain color.
* This method is needed especially to re-color a cell
* to a temporary color (i.e "red")
*/
public void setColor(String color);
 
/**
* The method getColor will return the color of the 
* specified cell. This method is called to identify
* the color of the cell.
*/
public String getColor();
 
}