import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class EvaluadorAritmetico {
// Expresión regular para evaluar la expresión aritmética
private static final String EXPRESION_REGULAR = "(\\d+\\.\\d+|\\d+|[+\\-])";
// Arreglo que contendrá los componentes de la expresión aritmética (operandos y operadores)
private static String[] componentes = null;
/**
* Método que calcula el número de componentes de una expresión aritmética.
* @param expresion expresión aritmética a evaluar.
* @return número de componentes de la expresión.
*/
private static int obtenerNumeroDeComponentes(String expresion) {
int contador = 0;
for (char c : expresion.toCharArray()) {
if (c == '+' || c == '-') contador++;
}
return contador * 2 + 1;
}
/**
* Método que desagrega la expresión aritmética en sus componentes (operandos y operadores).
* @param expresion la expresión a parsear.
*/
private static void parsearExpresion(String expresion) {
componentes = new String[obtenerNumeroDeComponentes(expresion)];
Pattern patronExpresion = Pattern.compile(EXPRESION_REGULAR);
Matcher coincidencias = patronExpresion.matcher(expresion);
int indice = 0;
while (coincidencias.find()) {
String componente = coincidencias.group();
if (componente != null && !componente.isEmpty()) {
componentes[indice++] = componente;
}
}
}
/**
* Método que realiza el cálculo basado en los componentes de la expresión.
* @return resultado del cálculo de la expresión.
*/
private static double procesarExpresion() {
double resultado = Double.parseDouble(componentes[0]);
for (int i = 1; i < componentes.length; i += 2) {
resultado = componentes[i].charAt(0) == '+' ?
resultado + Double.parseDouble(componentes[i + 1]) :
resultado - Double.parseDouble(componentes[i + 1]);
}
return resultado;
}
/**
* Método público para evaluar una expresión aritmética.
* @param expresion la expresión a evaluar.
* @return resultado de la evaluación.
*/
public static double evaluarExpresion(String expresion) {
parsearExpresion(expresion);
return procesarExpresion();
}
// Clase para pruebas
public static void main(String[] args) {
if (args.length > 0) {
String expresion = args[0];
double resultado = EvaluadorAritmetico.evaluarExpresion(expresion);
System.out.printf("Resultado: %f%n", resultado);
} else {
System.out.println("Por favor, proporcione una expresión aritmética como argumento.");
}
}
}
Clase principal
public class TicTacToe {
private char[][] board;
private char currentPlayer;
public TicTacToe() {
board = new char[3][3];
currentPlayer = 'X';
initializeBoard();
}
// Inicializa el tablero con espacios vacíos
public void initializeBoard() {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
board[i][j] = '-';
}
}
}
// Imprime el tablero en la consola
public void printBoard() {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(board[i][j] + " ");
}
System.out.println();
}
}
// Verifica si el tablero está lleno
public boolean isBoardFull() {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (board[i][j] == '-') {
return false;
}
}
}
return true;
}
// Verifica si hay un ganador
public boolean checkForWin() {
return (checkRowsForWin() || checkColumnsForWin() || checkDiagonalsForWin());
}
// Verifica las filas para un ganador
private boolean checkRowsForWin() {
for (int i = 0; i < 3; i++) {
if (checkRowCol(board[i][0], board[i][1], board[i][2])) {
return true;
}
}
return false;
}
// Verifica las columnas para un ganador
private boolean checkColumnsForWin() {
for (int i = 0; i < 3; i++) {
if (checkRowCol(board[0][i], board[1][i], board[2][i])) {
return true;
}
}
return false;
}
// Verifica las diagonales para un ganador
private boolean checkDiagonalsForWin() {
return ((checkRowCol(board[0][0], board[1][1], board[2][2]) || (checkRowCol(board[0][2], board[1][1], board[2][0]))));
}
// Verifica si todos los valores son iguales y no vacíos
private boolean checkRowCol(char c1, char c2, char c3) {
return ((c1 != '-') && (c1 == c2) && (c2 == c3));
}
// Cambia el jugador actual
public void changePlayer() {
currentPlayer = (currentPlayer == 'X') ? 'O' : 'X';
}
// Marca una celda en el tablero
public boolean placeMark(int row, int col) {
if ((row >= 0) && (row < 3)) {
if ((col >= 0) && (col < 3)) {
if (board[row][col] == '-') {
board[row][col] = currentPlayer;
return true;
}
}
}
return false;
}
public char getCurrentPlayer() {
return currentPlayer;
}
}Clase de ejecución
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
TicTacToe game = new TicTacToe();
game.printBoard();
while (true) {
int row, col;
System.out.println("Jugador " + game.getCurrentPlayer() + ", ingresa tu movimiento (fila y columna): ");
row = scanner.nextInt();
col = scanner.nextInt();
if (game.placeMark(row, col)) {
game.printBoard();
if (game.checkForWin()) {
System.out.println("¡Felicidades! El jugador " + game.getCurrentPlayer() + " ha ganado.");
break;
}
if (game.isBoardFull()) {
System.out.println("El juego es un empate.");
break;
}
game.changePlayer();
} else {
System.out.println("Este movimiento no es válido. Inténtalo de nuevo.");
}
}
scanner.close();
}
}