Ad
Guillermo.rfvs.Guillermo.rf

Cross Math

Code
Diff
  • import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;

 
public class CrossMath {
	static class Operation {
		ArrayList<String> parameters;
		String result;
		public Operation(ArrayList<String> parameters, String result) {
			this.parameters = parameters;
			this.result = result;
		}
 
		@Override
		public String toString() {
			return "Operation [" + parameters + ", =" + result + "]";
		}
		public int unknownAmmount(HashMap<String, Integer> solvedUnkowns) {
			int ammount = 0;
			final String REGEX = "^([0-9]+)|([-+*/])$";
			for (String str : parameters) {
				if (!str.matches(REGEX) && !solvedUnkowns.containsKey(str)) {
					ammount++;
				}
			}
			if (!result.matches(REGEX) && !solvedUnkowns.containsKey(result)) {
				ammount++;
			}
			return ammount;
		}
 
		public void calculateUnkown(HashMap<String, Integer> solvedUnkowns) {
			for(int position=0;position<this.parameters.size();position++) {
				String param = this.parameters.get(position);
				if (solvedUnkowns.containsKey(param)) {
				    this.parameters.set(position, Integer.toString(solvedUnkowns.get(param)));
				}
			}

			String resultVar = result;
			if (solvedUnkowns.containsKey(resultVar)) {
			    result = Integer.toString(solvedUnkowns.get(resultVar));
			}
			
			if(result.matches("[A-Z]+")) {
				
				int resultUnknown;
				int intParameter1 = Integer.parseInt(this.parameters.get(0));
				int intParameter2 = Integer.parseInt(this.parameters.get(2));
				
					switch(this.parameters.get(1)) {
						case "+":
							resultUnknown = intParameter1+intParameter2;
							break;
						case "-":
							resultUnknown = intParameter1-intParameter2;
							break;
						case "*":
							resultUnknown = intParameter1*intParameter2;
							break;
						case "/":	
							if(intParameter1 == 0 || intParameter2== 0) {
								resultUnknown = 0;
							}else {
								resultUnknown = intParameter1/intParameter2;
							}
							break;
						default: 
							throw new IllegalArgumentException("Comando desconocido: ");
				}
				solvedUnkowns.put(result, resultUnknown);
			}else if(this.parameters.get(0).matches("[A-Z]+")){
				
				int resultUnknown;
				int intResult = Integer.parseInt(result);
				int intParameter = Integer.parseInt(this.parameters.get(2));
				
				switch(this.parameters.get(1)) {
				case "+":
					resultUnknown = intResult-intParameter;
					break;
				case "-":
					resultUnknown = intParameter+intResult;
					break;
				case "*":
					if(intResult == 0 || intParameter== 0) {
						resultUnknown = 0;
					}else {
						resultUnknown = intResult/intParameter;
					}
					break;
				case "/":
					resultUnknown = intResult*intParameter;
					break;
				default: 
					throw new IllegalArgumentException("Comando desconocido: ");
				}
				solvedUnkowns.put(this.parameters.get(0), resultUnknown);
			}else if(this.parameters.get(2).matches("[A-Z]+")){
				
				int intResult = Integer.parseInt(result);
				int intParameter = Integer.parseInt(this.parameters.get(0));
				int resultUnknown;
				
				switch(this.parameters.get(1)) {
				case "+":
					resultUnknown = intResult-intParameter;
					break;
				case "-":
					resultUnknown = intParameter-intResult;
					break;
				case "*":
					if(intResult == 0 || intParameter== 0) {
						resultUnknown = 0;
					}else {
						resultUnknown = intResult/intParameter;
					}
					break;
				case "/":
					resultUnknown = intParameter/intResult;
					break;
				default: 
					
					throw new IllegalArgumentException("Comando desconocido: ");
					
				}
				solvedUnkowns.put(this.parameters.get(2), resultUnknown);
			}
		}
	
	}
	public static String[][] solve(String[][] board) {
		HashMap<String, Integer> solvedUnkowns = new HashMap<String, Integer>();
		LinkedList<Operation> operations = new LinkedList<CrossMath.Operation>();
		for (int row = 0; row < board.length; row += 2) {
			ArrayList<String> parameters = new ArrayList<String>();
			for (int col = 0; col < board.length; col++) {
				if ("=".equals(board[row][col])) {
					operations.add(new Operation(parameters, board[row][col+1]));
					parameters = new ArrayList<String>();
				} else {
					parameters.add(board[row][col]);
				}
			}
		}
		for (int col = 0; col < board[0].length; col += 2) {
			ArrayList<String> parameters = new ArrayList<String>();
			for (int row = 0; row < board.length; row++) {
				if ("=".equals(board[row][col])) {
					operations.add(new Operation(parameters, board[row+1][col]));
					parameters = new ArrayList<String>();
				} else {
					parameters.add(board[row][col]);
				}
			}
		}
		int cont = 0;
		while (0 < operations.size()) {
			Operation op = operations.pollFirst();
			switch (op.unknownAmmount(solvedUnkowns)) {
			case 0:
				cont = 0;
				break;
			case 1:
				op.calculateUnkown(solvedUnkowns);
				cont = 0;
				break;
			default:
				operations.addLast(op);
				cont++;
				break;
			}
			if (operations.size() <= cont) {
				String[][] res = new String[5][5];
				for(int i = 0; i < board.length; i++) {
					for(int k = 0; k < board[i].length; k++) {
						if(board[i][k].matches("[A-Z]")) {
							res[i][k] = String.valueOf(solvedUnkowns.get(board[i][k]));
						}else {
							res[i][k] = board[i][k];
						}
					}
				}
				
				return res;
			}
		}
		return null;
	}
}
    • import java.util.ArrayList;
    • import java.util.HashMap;
    • import java.util.LinkedList;
    • public class CrossMath {
    • static class Operation {
    • ArrayList<String> parameters;
    • String result;
    • public Operation(ArrayList<String> parameters, String result) {
    • this.parameters = parameters;
    • this.result = result;
    • }
    • @Override
    • public String toString() {
    • return "Operation [" + parameters + ", =" + result + "]";
    • }
    • public int unknownAmmount(HashMap<String, Integer> solvedUnkowns) {
    • int ammount = 0;
    • final String REGEX = "^([0-9]+)|([-+*/])$";
    • for (String str : parameters) {
    • if (!str.matches(REGEX) && !solvedUnkowns.containsKey(str)) {
    • ammount++;
    • }
    • }
    • if (!result.matches(REGEX) && !solvedUnkowns.containsKey(result)) {
    • ammount++;
    • }
    • return ammount;
    • }
    • public void calculateUnkown(HashMap<String, Integer> solvedUnkowns) {
    • for(int position=0;position<this.parameters.size();position++) {
    • String param = this.parameters.get(position);
    • if (solvedUnkowns.containsKey(param)) {
    • this.parameters.set(position, Integer.toString(solvedUnkowns.get(param)));
    • }
    • }
    • String resultVar = result;
    • if (solvedUnkowns.containsKey(resultVar)) {
    • result = Integer.toString(solvedUnkowns.get(resultVar));
    • }
    • if(result.matches("[A-Z]+")) {
    • int resultUnknown;
    • int intParameter1 = Integer.parseInt(this.parameters.get(0));
    • int intParameter2 = Integer.parseInt(this.parameters.get(2));
    • switch(this.parameters.get(1)) {
    • case "+":
    • resultUnknown = intParameter1+intParameter2;
    • break;
    • case "-":
    • resultUnknown = intParameter1-intParameter2;
    • break;
    • case "*":
    • resultUnknown = intParameter1*intParameter2;
    • break;
    • case "/":
    • resultUnknown = intParameter1/intParameter2;
    • case "/":
    • if(intParameter1 == 0 || intParameter2== 0) {
    • resultUnknown = 0;
    • }else {
    • resultUnknown = intParameter1/intParameter2;
    • }
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • solvedUnkowns.put(result, resultUnknown);
    • }else if(this.parameters.get(0).matches("[A-Z]+")){
    • int resultUnknown;
    • int intResult = Integer.parseInt(result);
    • int intParameter = Integer.parseInt(this.parameters.get(2));
    • switch(this.parameters.get(1)) {
    • case "+":
    • resultUnknown = intResult-intParameter;
    • break;
    • case "-":
    • resultUnknown = intParameter+intResult;
    • break;
    • case "*":
    • resultUnknown = intResult/intParameter;
    • if(intResult == 0 || intParameter== 0) {
    • resultUnknown = 0;
    • }else {
    • resultUnknown = intResult/intParameter;
    • }
    • break;
    • case "/":
    • resultUnknown = intResult*intParameter;
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • solvedUnkowns.put(this.parameters.get(0), resultUnknown);
    • }else if(this.parameters.get(2).matches("[A-Z]+")){
    • int intResult = Integer.parseInt(result);
    • int intParameter = Integer.parseInt(this.parameters.get(0));
    • int resultUnknown;
    • switch(this.parameters.get(1)) {
    • case "+":
    • resultUnknown = intResult-intParameter;
    • break;
    • case "-":
    • resultUnknown = intParameter-intResult;
    • break;
    • case "*":
    • resultUnknown = intResult/intParameter;
    • if(intResult == 0 || intParameter== 0) {
    • resultUnknown = 0;
    • }else {
    • resultUnknown = intResult/intParameter;
    • }
    • break;
    • case "/":
    • resultUnknown = intParameter/intResult;
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • solvedUnkowns.put(this.parameters.get(2), resultUnknown);
    • }
    • }
    • }
    • public static String[][] solve(String[][] board) {
    • HashMap<String, Integer> solvedUnkowns = new HashMap<String, Integer>();
    • LinkedList<Operation> operations = new LinkedList<CrossMath.Operation>();
    • for (int row = 0; row < board.length; row += 2) {
    • ArrayList<String> parameters = new ArrayList<String>();
    • for (int col = 0; col < board.length; col++) {
    • if ("=".equals(board[row][col])) {
    • operations.add(new Operation(parameters, board[row][col+1]));
    • parameters = new ArrayList<String>();
    • } else {
    • parameters.add(board[row][col]);
    • }
    • }
    • }
    • for (int col = 0; col < board[0].length; col += 2) {
    • ArrayList<String> parameters = new ArrayList<String>();
    • for (int row = 0; row < board.length; row++) {
    • if ("=".equals(board[row][col])) {
    • operations.add(new Operation(parameters, board[row+1][col]));
    • parameters = new ArrayList<String>();
    • } else {
    • parameters.add(board[row][col]);
    • }
    • }
    • }
    • int cont = 0;
    • while (0 < operations.size()) {
    • Operation op = operations.pollFirst();
    • switch (op.unknownAmmount(solvedUnkowns)) {
    • case 0:
    • cont = 0;
    • break;
    • case 1:
    • op.calculateUnkown(solvedUnkowns);
    • cont = 0;
    • break;
    • default:
    • operations.addLast(op);
    • cont++;
    • break;
    • }
    • if (operations.size() <= cont) {
    • String[][] res = new String[5][5];
    • for(int i = 0; i < board.length; i++) {
    • for(int k = 0; k < board[i].length; k++) {
    • if(board[i][k].matches("[A-Z]")) {
    • res[i][k] = String.valueOf(solvedUnkowns.get(board[i][k]));
    • }else {
    • res[i][k] = board[i][k];
    • }
    • }
    • }
    • return res;
    • }
    • }
    • return null;
    • }
    • }
Guillermo.rfvs.gabriel.gs

Cross Math

Code
Diff
  • import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;

 
public class CrossMath {
	static class Operation {
		ArrayList<String> parameters;
		String result;
		public Operation(ArrayList<String> parameters, String result) {
			this.parameters = parameters;
			this.result = result;
		}
 
		@Override
		public String toString() {
			return "Operation [" + parameters + ", =" + result + "]";
		}
		public int unknownAmmount(HashMap<String, Integer> solvedUnkowns) {
			int ammount = 0;
			final String REGEX = "^([0-9]+)|([-+*/])$";
			for (String str : parameters) {
				if (!str.matches(REGEX) && !solvedUnkowns.containsKey(str)) {
					ammount++;
				}
			}
			if (!result.matches(REGEX) && !solvedUnkowns.containsKey(result)) {
				ammount++;
			}
			return ammount;
		}
 
		public void calculateUnkown(HashMap<String, Integer> solvedUnkowns) {
			for(int position=0;position<this.parameters.size();position++) {
				String param = this.parameters.get(position);
				if (solvedUnkowns.containsKey(param)) {
				    this.parameters.set(position, Integer.toString(solvedUnkowns.get(param)));
				}
			}

			String resultVar = result;
			if (solvedUnkowns.containsKey(resultVar)) {
			    result = Integer.toString(solvedUnkowns.get(resultVar));
			}
			
			if(result.matches("[A-Z]+")) {
				
				int resultUnknown;
				int intParameter1 = Integer.parseInt(this.parameters.get(0));
				int intParameter2 = Integer.parseInt(this.parameters.get(2));
				
					switch(this.parameters.get(1)) {
						case "+":
							resultUnknown = intParameter1+intParameter2;
							break;
						case "-":
							resultUnknown = intParameter1-intParameter2;
							break;
						case "*":
							resultUnknown = intParameter1*intParameter2;
							break;
						case "/":
							resultUnknown = intParameter1/intParameter2;
							break;
						default: 
							throw new IllegalArgumentException("Comando desconocido: ");
				}
				solvedUnkowns.put(result, resultUnknown);
			}else if(this.parameters.get(0).matches("[A-Z]+")){
				
				int resultUnknown;
				int intResult = Integer.parseInt(result);
				int intParameter = Integer.parseInt(this.parameters.get(2));
				
				switch(this.parameters.get(1)) {
				case "+":
					resultUnknown = intResult-intParameter;
					break;
				case "-":
					resultUnknown = intParameter+intResult;
					break;
				case "*":
					resultUnknown = intResult/intParameter;
					break;
				case "/":
					resultUnknown = intResult*intParameter;
					break;
				default: 
					throw new IllegalArgumentException("Comando desconocido: ");
				}
				solvedUnkowns.put(this.parameters.get(0), resultUnknown);
			}else if(this.parameters.get(2).matches("[A-Z]+")){
				
				int intResult = Integer.parseInt(result);
				int intParameter = Integer.parseInt(this.parameters.get(0));
				int resultUnknown;
				
				switch(this.parameters.get(1)) {
				case "+":
					resultUnknown = intResult-intParameter;
					break;
				case "-":
					resultUnknown = intParameter-intResult;
					break;
				case "*":
					resultUnknown = intResult/intParameter;
					break;
				case "/":
					resultUnknown = intParameter/intResult;
					break;
				default: 
					
					throw new IllegalArgumentException("Comando desconocido: ");
					
				}
				solvedUnkowns.put(this.parameters.get(2), resultUnknown);
			}
		}
	
	}
	public static String[][] solve(String[][] board) {
		HashMap<String, Integer> solvedUnkowns = new HashMap<String, Integer>();
		LinkedList<Operation> operations = new LinkedList<CrossMath.Operation>();
		for (int row = 0; row < board.length; row += 2) {
			ArrayList<String> parameters = new ArrayList<String>();
			for (int col = 0; col < board.length; col++) {
				if ("=".equals(board[row][col])) {
					operations.add(new Operation(parameters, board[row][col+1]));
					parameters = new ArrayList<String>();
				} else {
					parameters.add(board[row][col]);
				}
			}
		}
		for (int col = 0; col < board[0].length; col += 2) {
			ArrayList<String> parameters = new ArrayList<String>();
			for (int row = 0; row < board.length; row++) {
				if ("=".equals(board[row][col])) {
					operations.add(new Operation(parameters, board[row+1][col]));
					parameters = new ArrayList<String>();
				} else {
					parameters.add(board[row][col]);
				}
			}
		}
		int cont = 0;
		while (0 < operations.size()) {
			Operation op = operations.pollFirst();
			switch (op.unknownAmmount(solvedUnkowns)) {
			case 0:
				cont = 0;
				break;
			case 1:
				op.calculateUnkown(solvedUnkowns);
				cont = 0;
				break;
			default:
				operations.addLast(op);
				cont++;
				break;
			}
			if (operations.size() <= cont) {
				String[][] res = new String[5][5];
				for(int i = 0; i < board.length; i++) {
					for(int k = 0; k < board[i].length; k++) {
						if(board[i][k].matches("[A-Z]")) {
							res[i][k] = String.valueOf(solvedUnkowns.get(board[i][k]));
						}else {
							res[i][k] = board[i][k];
						}
					}
				}
				
				return res;
			}
		}
		return null;
	}
}
    • import java.util.ArrayList;
    • import java.util.HashMap;
    • import java.util.LinkedList;
    • import java.util.regex.Pattern;
    • public class CrossMath {
    • static class Operation {
    • ArrayList<String> parameters;
    • String result;
    • public Operation(ArrayList<String> parameters, String result) {
    • this.parameters = parameters;
    • this.result = result;
    • }
    • @Override
    • public String toString() {
    • return "Operation [" + parameters + ", =" + result + "]";
    • }
    • public int unknownAmmount(HashMap<String, Integer> solvedUnkowns) {
    • int ammount = 0;
    • final String REGEX = "^((-)?[0-9]+)|([-+x/])$";
    • final String REGEX = "^([0-9]+)|([-+*/])$";
    • for (String str : parameters) {
    • if (!str.matches(REGEX) && !solvedUnkowns.containsKey(str)) {
    • ammount++;
    • }
    • }
    • if (!result.matches(REGEX) && !solvedUnkowns.containsKey(result)) {
    • ammount++;
    • }
    • return ammount;
    • }
    • public void calculateUnkown(HashMap<String, Integer> solvedUnkowns) {
    • for(int position=0;position<this.parameters.size();position++) {
    • String param = this.parameters.get(position);
    • if (solvedUnkowns.containsKey(param)) {
    • this.parameters.set(position, Integer.toString(solvedUnkowns.get(param)));
    • }
    • }
    • String resultVar = result;
    • if (solvedUnkowns.containsKey(resultVar)) {
    • result = Integer.toString(solvedUnkowns.get(resultVar));
    • }
    • if(result.matches("[A-Z]+")) {
    • int resultUnknown=0;
    • int resultUnknown;
    • int intParameter1 = Integer.parseInt(this.parameters.get(0));
    • int intParameter2 = Integer.parseInt(this.parameters.get(2));
    • switch(this.parameters.get(1)) {
    • case "+":
    • resultUnknown = Integer.parseInt(this.parameters.get(0))+Integer.parseInt(this.parameters.get(2));
    • resultUnknown = intParameter1+intParameter2;
    • break;
    • case "-":
    • resultUnknown = Integer.parseInt(this.parameters.get(0))-Integer.parseInt(this.parameters.get(2));
    • resultUnknown = intParameter1-intParameter2;
    • break;
    • case "*":
    • resultUnknown = Integer.parseInt(this.parameters.get(0))*Integer.parseInt(this.parameters.get(2));
    • resultUnknown = intParameter1*intParameter2;
    • break;
    • case "/":
    • resultUnknown = Integer.parseInt(this.parameters.get(0))/Integer.parseInt(this.parameters.get(2));
    • resultUnknown = intParameter1/intParameter2;
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • solvedUnkowns.put(result, resultUnknown);
    • }else if(this.parameters.get(0).matches("[A-Z]+")){
    • int resultUnknown=0;
    • int resultUnknown;
    • int intResult = Integer.parseInt(result);
    • int intParameter = Integer.parseInt(this.parameters.get(2));
    • switch(this.parameters.get(1)) {
    • case "+":
    • resultUnknown = Integer.parseInt(result)-Integer.parseInt(this.parameters.get(2));
    • resultUnknown = intResult-intParameter;
    • break;
    • case "-":
    • resultUnknown = Integer.parseInt(this.parameters.get(2))+Integer.parseInt(result);
    • resultUnknown = intParameter+intResult;
    • break;
    • case "*":
    • resultUnknown = Integer.parseInt(result)/Integer.parseInt(this.parameters.get(2));
    • resultUnknown = intResult/intParameter;
    • break;
    • case "/":
    • resultUnknown = Integer.parseInt(result)*Integer.parseInt(this.parameters.get(2));
    • resultUnknown = intResult*intParameter;
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • solvedUnkowns.put(this.parameters.get(0), resultUnknown);
    • }else if(this.parameters.get(2).matches("[A-Z]+")){
    • int resultUnknown=0;
    • int intResult = Integer.parseInt(result);
    • int intParameter = Integer.parseInt(this.parameters.get(0));
    • int resultUnknown;
    • switch(this.parameters.get(1)) {
    • case "+":
    • resultUnknown = Integer.parseInt(result)-Integer.parseInt(this.parameters.get(0));
    • resultUnknown = intResult-intParameter;
    • break;
    • case "-":
    • resultUnknown = Integer.parseInt(this.parameters.get(0))-Integer.parseInt(result);
    • resultUnknown = intParameter-intResult;
    • break;
    • case "*":
    • resultUnknown = Integer.parseInt(result)/Integer.parseInt(this.parameters.get(0));
    • resultUnknown = intResult/intParameter;
    • break;
    • case "/":
    • resultUnknown = Integer.parseInt(this.parameters.get(0))/Integer.parseInt(result);
    • resultUnknown = intParameter/intResult;
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • solvedUnkowns.put(this.parameters.get(2), resultUnknown);
    • }
    • }
    • }
    • public static String[][] solve(String[][] board) {
    • HashMap<String, Integer> solvedUnkowns = new HashMap<String, Integer>();
    • LinkedList<Operation> operations = new LinkedList<CrossMath.Operation>();
    • for (int row = 0; row < board.length; row += 2) {
    • ArrayList<String> parameters = new ArrayList<String>();
    • for (int col = 0; col < board[row].length; col++) {
    • for (int col = 0; col < board.length; col++) {
    • if ("=".equals(board[row][col])) {
    • operations.add(new Operation(parameters, board[row][col+1]));
    • parameters = new ArrayList<String>();
    • } else {
    • parameters.add(board[row][col]);
    • }
    • }
    • }
    • for (int col = 0; col < board[0].length; col += 2) {
    • ArrayList<String> parameters = new ArrayList<String>();
    • for (int row = 0; row < board.length; row++) {
    • if ("=".equals(board[row][col])) {
    • operations.add(new Operation(parameters, board[row+1][col]));
    • parameters = new ArrayList<String>();
    • } else {
    • parameters.add(board[row][col]);
    • }
    • }
    • }
    • int cont = 0;
    • while (0 < operations.size()) {
    • Operation op = operations.pollFirst();
    • switch (op.unknownAmmount(solvedUnkowns)) {
    • case 0:
    • cont = 0;
    • break;
    • case 1:
    • op.calculateUnkown(solvedUnkowns);
    • cont = 0;
    • break;
    • default:
    • operations.addLast(op);
    • cont++;
    • break;
    • }
    • if (operations.size() <= cont) {
    • String[][] res = new String[5][5];
    • for(int i = 0; i < board.length; i++) {
    • for(int k = 0; k < board[i].length; k++) {
    • if(board[i][k].matches("[A-Z]")) {
    • res[i][k] = String.valueOf(solvedUnkowns.get(board[i][k]));
    • }else {
    • res[i][k] = board[i][k];
    • }
    • }
    • }
    • return res;
    • }
    • }
    • return null;
    • }
    • }
Guillermo.rfvs.dani.vs

Cross Math

Code
Diff
  • package com.cruci.cruci;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.regex.Pattern;
 
public class CrossMath {
	static class Operation {
		ArrayList<String> parameters;
		String result;
		public Operation(ArrayList<String> parameters, String result) {
			this.parameters = parameters;
			this.result = result;
		}
 
		@Override
		public String toString() {
			return "Operation [" + parameters + ", =" + result + "]";
		}
		public int unknownAmmount(HashMap<String, Integer> solvedUnkowns) {
			int ammount = 0;
			final String REGEX = "^((-)?[0-9]+)|([-+x/])$";
			for (String str : parameters) {
				if (!str.matches(REGEX) && !solvedUnkowns.containsKey(str)) {
					ammount++;
				}
			}
			if (!result.matches(REGEX) && !solvedUnkowns.containsKey(result)) {
				ammount++;
			}
			return ammount;
		}
 
		public void calculateUnkown(HashMap<String, Integer> solvedUnkowns) {
			for(int position=0;position<this.parameters.size();position++) {
				String param = this.parameters.get(position);
				if (solvedUnkowns.containsKey(param)) {
				    this.parameters.set(position, Integer.toString(solvedUnkowns.get(param)));
				}
			}

			String resultVar = result;
			if (solvedUnkowns.containsKey(resultVar)) {
			    result = Integer.toString(solvedUnkowns.get(resultVar));
			}
			
			if(result.matches("[A-Z]+")) {
				int resultUnknown=0;
					switch(this.parameters.get(1)) {
						case "+":
							resultUnknown = Integer.parseInt(this.parameters.get(0))+Integer.parseInt(this.parameters.get(2));
							break;
						case "-":
							resultUnknown = Integer.parseInt(this.parameters.get(0))-Integer.parseInt(this.parameters.get(2));
							break;
						case "*":
							resultUnknown = Integer.parseInt(this.parameters.get(0))*Integer.parseInt(this.parameters.get(2));
							break;
						case "/":
							resultUnknown = Integer.parseInt(this.parameters.get(0))/Integer.parseInt(this.parameters.get(2));
							break;
						default: 
							throw new IllegalArgumentException("Comando desconocido: ");
				}
				solvedUnkowns.put(result, resultUnknown);
			}else if(this.parameters.get(0).matches("[A-Z]+")){
				int resultUnknown=0;
				switch(this.parameters.get(1)) {
				case "+":
					resultUnknown = Integer.parseInt(result)-Integer.parseInt(this.parameters.get(2));
					break;
				case "-":
					resultUnknown = Integer.parseInt(this.parameters.get(2))+Integer.parseInt(result);
					break;
				case "*":
					resultUnknown = Integer.parseInt(result)/Integer.parseInt(this.parameters.get(2));
					break;
				case "/":
					resultUnknown = Integer.parseInt(result)*Integer.parseInt(this.parameters.get(2));
					break;
				default: 
					throw new IllegalArgumentException("Comando desconocido: ");
				}
				solvedUnkowns.put(this.parameters.get(0), resultUnknown);
			}else if(this.parameters.get(2).matches("[A-Z]+")){
				int resultUnknown=0;
				switch(this.parameters.get(1)) {
				case "+":
					resultUnknown = Integer.parseInt(result)-Integer.parseInt(this.parameters.get(0));
					break;
				case "-":
					resultUnknown = Integer.parseInt(this.parameters.get(0))-Integer.parseInt(result);
					break;
				case "*":
					resultUnknown = Integer.parseInt(result)/Integer.parseInt(this.parameters.get(0));
					break;
				case "/":
					resultUnknown = Integer.parseInt(this.parameters.get(0))/Integer.parseInt(result);
					break;
				default: 
					throw new IllegalArgumentException("Comando desconocido: ");
				}
				solvedUnkowns.put(this.parameters.get(2), resultUnknown);
			}
		}
	
	}
	public static String[][] solve(String[][] board) {
		HashMap<String, Integer> solvedUnkowns = new HashMap<String, Integer>();
		LinkedList<Operation> operations = new LinkedList<CrossMath.Operation>();
		for (int row = 0; row < board.length; row += 2) {
			ArrayList<String> parameters = new ArrayList<String>();
			for (int col = 0; col < board[row].length; col++) {
				if ("=".equals(board[row][col])) {
					operations.add(new Operation(parameters, board[row][col+1]));
					parameters = new ArrayList<String>();
				} else {
					parameters.add(board[row][col]);
				}
			}
		}
		for (int col = 0; col < board[0].length; col += 2) {
			ArrayList<String> parameters = new ArrayList<String>();
			for (int row = 0; row < board.length; row++) {
				if ("=".equals(board[row][col])) {
					operations.add(new Operation(parameters, board[row+1][col]));
					parameters = new ArrayList<String>();
				} else {
					parameters.add(board[row][col]);
				}
			}
		}
		int cont = 0;
		while (0 < operations.size()) {
			Operation op = operations.pollFirst();
			switch (op.unknownAmmount(solvedUnkowns)) {
			case 0:
				cont = 0;
				break;
			case 1:
				op.calculateUnkown(solvedUnkowns);
				cont = 0;
				break;
			default:
				operations.addLast(op);
				cont++;
				break;
			}
			if (operations.size() <= cont) {
				String[][] res = new String[5][5];
				for(int i = 0; i < board.length; i++) {
					for(int k = 0; k < board[i].length; k++) {
						if(board[i][k].matches("[A-Z]")) {
							res[i][k] = String.valueOf(solvedUnkowns.get(board[i][k]));
						}else {
							res[i][k] = board[i][k];
						}
					}
				}
				
				return res;
			}
		}
		return null;
	}
}
    • package com.cruci.cruci;
    • import java.util.ArrayList;
    • import java.util.HashMap;
    • import java.util.LinkedList;
    • import java.util.regex.Pattern;
    • class Crossword {
    • public class CrossMath {
    • static class Operation {
    • private static final Pattern SOLO_LETRAS = Pattern.compile("^[A-Za-z]+$");
    • ArrayList<String> parameters;
    • String result;
    • public Operation(ArrayList<String> parameters, String result) {
    • this.parameters = parameters;
    • this.result = result;
    • }
    • @Override
    • public String toString() {
    • return "Operation [" + parameters + ", =" + result + "]";
    • }
    • public int unknownAmmount(HashMap<String, Integer> solvedUnkowns) {
    • int ammount = 0;
    • final String REGEX = "^((-)?[0-9]+)|([-+x/])$";
    • for (String str : parameters) {
    • if (!str.matches(REGEX) && !solvedUnkowns.containsKey(str)) {
    • ammount++;
    • }
    • }
    • if (!result.matches(REGEX) && !solvedUnkowns.containsKey(result)) {
    • ammount++;
    • }
    • return ammount;
    • }
    • public void calculateUnkown(HashMap<String, Integer> solvedUnkowns) {
    • for(int position=0;position<this.parameters.size();position++) {
    • String param = this.parameters.get(position);
    • if (solvedUnkowns.containsKey(param)) {
    • this.parameters.set(position, Integer.toString(solvedUnkowns.get(param)));
    • }
    • }
    • String resultVar = result;
    • if (solvedUnkowns.containsKey(resultVar)) {
    • result = Integer.toString(solvedUnkowns.get(resultVar));
    • }
    • if(result.matches("[A-Z]+")) {
    • int resultUnknown = Integer.parseInt(this.parameters.get(0));
    • for(int operador=1;operador<this.parameters.size();operador+=2) {
    • switch(this.parameters.get(operador)) {
    • int resultUnknown=0;
    • switch(this.parameters.get(1)) {
    • case "+":
    • resultUnknown+=Integer.parseInt(this.parameters.get(operador+1));
    • resultUnknown = Integer.parseInt(this.parameters.get(0))+Integer.parseInt(this.parameters.get(2));
    • break;
    • case "-":
    • resultUnknown-=Integer.parseInt(this.parameters.get(operador+1));
    • resultUnknown = Integer.parseInt(this.parameters.get(0))-Integer.parseInt(this.parameters.get(2));
    • break;
    • case "*":
    • resultUnknown*=Integer.parseInt(this.parameters.get(operador+1));
    • resultUnknown = Integer.parseInt(this.parameters.get(0))*Integer.parseInt(this.parameters.get(2));
    • break;
    • case "/":
    • resultUnknown/=Integer.parseInt(this.parameters.get(operador+1));
    • resultUnknown = Integer.parseInt(this.parameters.get(0))/Integer.parseInt(this.parameters.get(2));
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • }
    • solvedUnkowns.put(result, resultUnknown);
    • }else if(containsVariable(this.parameters)){
    • int resultUnknown = Integer.parseInt(result);
    • String result;
    • int route=1;
    • while(!this.parameters.get(route).matches("[A-Z]+")) {
    • switch(this.parameters.get(route+1)) {
    • case "-":
    • resultUnknown+=Integer.parseInt(this.parameters.get(route-1));
    • break;
    • case "+":
    • resultUnknown-=Integer.parseInt(this.parameters.get(route-1));
    • break;
    • case "/":
    • resultUnknown*=Integer.parseInt(this.parameters.get(route-1));
    • break;
    • case "*":
    • resultUnknown/=Integer.parseInt(this.parameters.get(route-1));
    • break;
    • }
    • route+=2;
    • }else if(this.parameters.get(0).matches("[A-Z]+")){
    • int resultUnknown=0;
    • switch(this.parameters.get(1)) {
    • case "+":
    • resultUnknown = Integer.parseInt(result)-Integer.parseInt(this.parameters.get(2));
    • break;
    • case "-":
    • resultUnknown = Integer.parseInt(this.parameters.get(2))+Integer.parseInt(result);
    • break;
    • case "*":
    • resultUnknown = Integer.parseInt(result)/Integer.parseInt(this.parameters.get(2));
    • break;
    • case "/":
    • resultUnknown = Integer.parseInt(result)*Integer.parseInt(this.parameters.get(2));
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • solvedUnkowns.put(this.parameters.get(0), resultUnknown);
    • }else if(this.parameters.get(2).matches("[A-Z]+")){
    • int resultUnknown=0;
    • switch(this.parameters.get(1)) {
    • case "+":
    • resultUnknown = Integer.parseInt(result)-Integer.parseInt(this.parameters.get(0));
    • break;
    • case "-":
    • resultUnknown = Integer.parseInt(this.parameters.get(0))-Integer.parseInt(result);
    • break;
    • case "*":
    • resultUnknown = Integer.parseInt(result)/Integer.parseInt(this.parameters.get(0));
    • break;
    • case "/":
    • resultUnknown = Integer.parseInt(this.parameters.get(0))/Integer.parseInt(result);
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • result=this.parameters.get(route);
    • route+=2;
    • while(route<this.parameters.size()) {
    • switch(this.parameters.get(route)) {
    • case "-":
    • resultUnknown+=Integer.parseInt(this.parameters.get(route+1));
    • break;
    • case "+":
    • resultUnknown-=Integer.parseInt(this.parameters.get(route+1));
    • break;
    • case "/":
    • resultUnknown*=Integer.parseInt(this.parameters.get(route+1));
    • break;
    • case "*":
    • resultUnknown/=Integer.parseInt(this.parameters.get(route+1));
    • break;
    • default:
    • throw new IllegalArgumentException("Comando desconocido: ");
    • }
    • route+=2;
    • }
    • solvedUnkowns.put(result, resultUnknown);
    • }else {
    • throw new IllegalArgumentException("Ninguna parte contiene una variable");
    • solvedUnkowns.put(this.parameters.get(2), resultUnknown);
    • }
    • }
    • public static Boolean containsVariable(ArrayList<String> array) {
    • return array.stream()
    • .anyMatch(palabra -> SOLO_LETRAS.matcher(palabra).matches());
    • }
    • }
    • public static HashMap<String, Integer> solve(String[][] board) {
    • }
    • public static String[][] solve(String[][] board) {
    • HashMap<String, Integer> solvedUnkowns = new HashMap<String, Integer>();
    • LinkedList<Operation> operations = new LinkedList<Crossword.Operation>();
    • LinkedList<Operation> operations = new LinkedList<CrossMath.Operation>();
    • for (int row = 0; row < board.length; row += 2) {
    • ArrayList<String> parameters = new ArrayList<String>();
    • for (int col = 0; col < board[row].length; col++) {
    • if ("=".equals(board[row][col])) {
    • operations.add(new Operation(parameters, board[row][col+1]));
    • parameters = new ArrayList<String>();
    • } else {
    • parameters.add(board[row][col]);
    • }
    • }
    • }
    • for (int col = 0; col < board[0].length; col += 2) {
    • ArrayList<String> parameters = new ArrayList<String>();
    • for (int row = 0; row < board.length; row++) {
    • if ("=".equals(board[row][col])) {
    • operations.add(new Operation(parameters, board[row+1][col]));
    • parameters = new ArrayList<String>();
    • } else {
    • parameters.add(board[row][col]);
    • }
    • }
    • }
    • System.out.println("lista" + operations.toString());
    • int cont = 0;
    • while (0 < operations.size()) {
    • Operation op = operations.pollFirst();
    • switch (op.unknownAmmount(solvedUnkowns)) {
    • case 0:
    • // not doing anything, just removing it from the queue
    • cont = 0;
    • break;
    • case 1:
    • op.calculateUnkown(solvedUnkowns);
    • cont = 0;
    • break;
    • default:
    • operations.addLast(op);
    • cont++;
    • break;
    • }
    • if (operations.size() <= cont) {
    • return solvedUnkowns;
    • String[][] res = new String[5][5];
    • for(int i = 0; i < board.length; i++) {
    • for(int k = 0; k < board[i].length; k++) {
    • if(board[i][k].matches("[A-Z]")) {
    • res[i][k] = String.valueOf(solvedUnkowns.get(board[i][k]));
    • }else {
    • res[i][k] = board[i][k];
    • }
    • }
    • }
    • return res;
    • }
    • }
    • return solvedUnkowns;
    • return null;
    • }