Freestyle Sparring

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.regex.Pattern;
	
class Crossword {
	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) {
			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)) {
						case "+":
							resultUnknown+=Integer.parseInt(this.parameters.get(operador+1));
							break;
						case "-":
							resultUnknown-=Integer.parseInt(this.parameters.get(operador+1));
							break;
						case "*":
							resultUnknown*=Integer.parseInt(this.parameters.get(operador+1));
							break;
						case "/":
							resultUnknown/=Integer.parseInt(this.parameters.get(operador+1));
							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;
				}
				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");
			}
			
		}
		
	    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) {
		
		HashMap<String, Integer> solvedUnkowns = new HashMap<String, Integer>();
		LinkedList<Operation> operations = new LinkedList<Crossword.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;
			}
		}
		
		return solvedUnkowns;
	}
}

public class DrivingTestEvaluator{
  public static boolean evaluate(String road, String exam){
    //your code here
//test
    return true;
    }
}

#If it is not true currently, I shall make it true
def above_two(arg):
    return abs(arg)+3>2

is_perfect_square:=>@^.5%1==0

extern malloc
global reverse_string
reverse_string:
  mov rcx, -1
rs_continue:
  inc rcx
  cmp byte [rdi+rcx], 0
  jnz rs_continue
  
  push rcx
  push rdi
  call malloc
  pop rdi
  pop rbx
  mov rcx, 0


rs_copy:
  dec rbx
  
  mov dl, [rdi+rbx]
  mov [rax+rcx], dl
  inc rcx
  cmp rbx, 0
  jnz rs_copy
  
  mov byte [rax+rcx], 0
  ret

a=lambda:'⚀'