acm-2008-B-Painting

package acm2008;

import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import util.AcmUtil;

public class acm2008b {
	
	public static void main(String[] args) {
		int m,n;
		int fileContentIndex = 0;
		String input = "E:\\acm\\2008\\TD87\\b.in";
		String output = "E:\\acm\\2008\\TD87\\b.out";
		String myOutput = "E:\\acm\\2008\\TD87\\b-my.out";
		
		List<String> fileContent = AcmUtil.readFromFile(input);
		List<String> outputList = new ArrayList<String>();
		do {
			Integer[] size = getMatrixSize(fileContent, fileContentIndex++);
			m = size[0];
			n = size[1];
			if (m == 0 || n == 0)
				break;
			
			int[][] matrixData = getMatrixData(fileContent.subList(fileContentIndex, fileContentIndex + m), m, n);
			fileContentIndex += m;
			
			
			Stack<Integer> stack = new Stack<Integer>();
			while (matrixData.length > 0) {
				
				if (n == 1 && m > 1) {
					int[] columnData = getColumnMatrix(matrixData, 0);
					int uniqueNum = getUniqueNum(columnData);
					stack.push(uniqueNum);
					matrixData = removeRow(matrixData, uniqueNum);
					m--;
				} else {
					//row
					List<Integer> sameRowDataList = new ArrayList<Integer>();
					//get row duplicate number
					for (int[] rowData : matrixData) {
						if (isAllSameNumber(rowData, rowData[0]) && !sameRowDataList.contains(rowData[0])) {
							sameRowDataList.add(rowData[0]);
						}
					}
					
					if (sameRowDataList.size() > 0) {
						for (Integer sameData : sameRowDataList) {
							matrixData = removeRow(matrixData, sameData);
							m--;
						}
					}
					
					addToStack(stack, sameRowDataList);
				}
				
				if (m == 1 && n > 1) {
					int[] rowData = matrixData[0];
					int uniqueNum = getUniqueNum(rowData);
					stack.push(uniqueNum);
					matrixData = removeColumn(matrixData, uniqueNum);
					n--;
				} else {
					//column
					List<Integer> sameColumnDataList = new ArrayList<Integer>();
					if (matrixData.length > 0) {
						//get column duplicate number
						for (int columnNum=0; columnNum < n; columnNum++) {
							int[] matrixColumnData = getColumnMatrix(matrixData, columnNum);
							if (isAllSameNumber(matrixColumnData, matrixColumnData[0]) && !sameColumnDataList.contains(matrixColumnData[0])) {
								sameColumnDataList.add(matrixColumnData[0]);
							}
						}
						
						if (sameColumnDataList.size() > 0) {
							for (Integer sameData : sameColumnDataList) {
								matrixData = removeColumn(matrixData, sameData);
								n--;
							}
						}
					}
					
					addToStack(stack, sameColumnDataList);
				}
				
			}
			
			
			printStack(stack, outputList);
		} while(m != 0 || n != 0);
		
		writeToFile(outputList, myOutput);
		
		
		System.out.println(AcmUtil.diffFile(output, myOutput));
	}

	private static void addToStack(Stack<Integer> stack, List<Integer> sameColumnDataList) {
		Collections.sort(sameColumnDataList);
		Collections.reverse(sameColumnDataList);
		for (Integer sameData : sameColumnDataList) {
			stack.push(sameData);
		}
	}

	private static void writeToFile(List<String> outputList, String pathFileName) {
		try {
			FileWriter writer = new FileWriter(pathFileName); 
			for(String str: outputList) {
			  writer.write(str + System.lineSeparator());
			}
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	private static boolean isAllSameNumber(int[] arr, int num) {
		boolean isSame = true;
		for (int i : arr) {
			if (i != num)
				isSame = false;
		}
		return isSame;
	}
	
	public static int[][] removeRow(int[][] matrixData, int deleteNum) {
		if (matrixData.length > 0) {
			int row = matrixData.length;
		    int col = matrixData[0].length;
	
		    int [][] newArray = new int[row-1][col]; //new Array will have one column less
	
	
		    boolean isValidArray = false;
		    for (int j=0; j < col; j++) {
		    	int newRow = 0;
		    	for (int i=0; i < row; i++) {
		    		if (matrixData[i][j] != deleteNum) {
		    			newArray[newRow++][j] = matrixData[i][j];
		    			isValidArray = true;
		    		}
		    	}
		    }
	
		    if (isValidArray)
		    	return newArray;
		}
	    return new int[][] {};
		
	}
	
	public static int[][] removeColumn(int[][] matrixData, int deleteNum) {
		if (matrixData.length > 0) {
			int row = matrixData.length;
		    int col = matrixData[0].length;
	
		    int [][] newArray = new int[row][col-1]; //new Array will have one column less
	
	
		    boolean isValidArray = false;
		    for (int i=0; i < row; i++) {
		    	int newCol = 0;
		    	for (int j=0; j < col; j++) {
		    		if (matrixData[i][j] != deleteNum) {
		    			newArray[i][newCol++] = matrixData[i][j];
		    			isValidArray = true;
		    		}
		    	}
		    }
	
		    if (isValidArray)
		    	return newArray;
		}
	    return new int[][] {};
	}
	
	public static int[] getColumnMatrix(int[][] matrix, int column) {
	    return IntStream.range(0, matrix.length).map(i -> matrix[i][column]).toArray();
	}
	
	public static void printStack(Stack<Integer> stack, List<String> outputList) {
		String output = "";
		while (stack.size() != 0) {
			output += (stack.pop() + " ");
		}
		if (output != null && output.length() > 0) {
			output = output.substring(0, output.length()-1);
			outputList.add(output);
		}
	}
	
	
	
	public static int getUniqueNum(int[] arr) {
		List<Integer> uniqueList = new ArrayList<Integer>();
		for (int i : arr) {
			int count = 0;
			for (int j : arr) {
				if (i == j)
					count++;
			}
			if (count == 1)
				uniqueList.add(i);
		}
		if (uniqueList != null && uniqueList.size() > 0) {
			Collections.sort(uniqueList);
			Collections.reverse(uniqueList);
			return uniqueList.get(0);
		}
		return 0;
	}
	
	public static Integer[] getMatrixSize(List<String> fileContent, int fileContentIndex) {
		String mn = fileContent.get(fileContentIndex);
		Integer spaceIndex = mn.indexOf(" ");
		int m = Integer.parseInt(mn.substring(0,spaceIndex));
		int n = Integer.parseInt(mn.substring(spaceIndex+1));
		return new Integer[] {m , n};
	}
	
	public static int[][] getMatrixData(List<String> fileContent, int m, int n) {
		int[][] matrixData = new int[m][n];
		int count = 0;
		for (String rowStr : fileContent) {
			int[] row = getRowMatrixData(rowStr);
			matrixData[count] = row;
			count++;
		}
		return matrixData;
	}
	
	public static int[] getRowMatrixData(String rowWithSpace) {
		List<String> stringData = Arrays.asList(rowWithSpace.split(" "));
		List<Integer> intData = stringData.stream().map(Integer::valueOf).collect(Collectors.toList());
		return intData.stream().mapToInt(i->i).toArray();
	}
	

}