Rotar matriz 90º. Uso de librería "Apache Commons Math".

Objetivo:

El objetivo del algoritmo es rotar una matriz o tabla de distancias 90 grados en sentido horario utilizando la librería Apache Commons Math.
La librería Apache Commons Math se utiliza para manejar eficientemente las operaciones matriciales, proporcionando una estructura de datos robusta (RealMatrix) y métodos optimizados para acceder y modificar los elementos de la matriz.

Requisitos:

- NetBeans IDE
- Apache Commons Math (versión 3.6.1)

Pasos:

1. Descarga la librería Apache Commons Math 3.6.1 desde:
   https://archive.apache.org/dist/commons/math/binaries/
2. Buscar, descargar y descomprimir el archivo "commons-math3-3.6.1-bin.zip".
3. En NetBeans, añadir la librería "commons-math3-3.6.1.jar" al proyecto.

Código Java (MatrixRotator.java):

package matrixrotator;

import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.RealMatrix;

public class MatrixRotator {

    public static RealMatrix rotate90Degrees(RealMatrix matrix) {
        int rows = matrix.getRowDimension();
        int cols = matrix.getColumnDimension();

        RealMatrix rotatedMatrix = new Array2DRowRealMatrix(cols, rows);

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                rotatedMatrix.setEntry(j, rows - 1 - i, matrix.getEntry(i, j));
            }
        }

        return rotatedMatrix;
    }

    public static void printMatrix(RealMatrix matrix) {
        for (int i = 0; i < matrix.getRowDimension(); i++) {
            for (int j = 0; j < matrix.getColumnDimension(); j++) {
                System.out.printf("%6d", (int) matrix.getEntry(i, j));
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        double[][] data = {
            {0, 610, 703, 319, 90, 290, 219, 564},
            {12, 0, 897, 165, 549, 786, 859, 303},
            {505, 115, 0, 535, 445, 677, 639, 44},
            {359, 366, 581, 0, 848, 322, 841, 165},
            {500, 128, 653, 500, 0, 903, 789, 449},
            {559, 93, 314, 176, 404, 0, 130, 964},
            {55, 349, 2, 787, 622, 425, 0, 58},
            {909, 447, 276, 860, 388, 624, 666, 0}
        };

        RealMatrix matrix = new Array2DRowRealMatrix(data);

        System.out.println("Matriz original:");
        printMatrix(matrix);

        RealMatrix rotatedMatrix = rotate90Degrees(matrix);

        System.out.println("\nMatriz rotada 90 grados:");
        printMatrix(rotatedMatrix);
    }
}


Resultado:

run:
Matriz original:
     0   610   703   319    90   290   219   564
    12     0   897   165   549   786   859   303
   505   115     0   535   445   677   639    44
   359   366   581     0   848   322   841   165
   500   128   653   500     0   903   789   449
   559    93   314   176   404     0   130   964
    55   349     2   787   622   425     0    58
   909   447   276   860   388   624   666     0

Matriz rotada 90 grados:
   909    55   559   500   359   505    12     0
   447   349    93   128   366   115     0   610
   276     2   314   653   581     0   897   703
   860   787   176   500     0   535   165   319
   388   622   404     0   848   445   549    90
   624   425     0   903   322   677   786   290
   666     0   130   789   841   639   859   219
     0    58   964   449   165    44   303   564
BUILD SUCCESSFUL (total time: 0 seconds)

Conversor matriz de distancias a coordenadas cartesianas(MDS) usando librería "Apache Commons Math".

 Este algoritmo implementa el algoritmo de Escalamiento Multidimensional (MDS) para transformar matrices de distancias en coordenadas cartesianas utilizando la librería "Apache Commons Math".

Requisitos:
- NetBeans IDE
- Apache Commons Math (versión 3.6.1)

Pasos:
1. Descarga la librería Apache Commons Math 3.6.1 desde:
   https://archive.apache.org/dist/commons/math/binaries/
2. Busca y descarga el archivo "commons-math3-3.6.1-bin.zip".
3. En NetBeans, añadir la librería al proyecto.



Código Java (DistanceToCoordinates.java):

package distancetocoordinates;

import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.EigenDecomposition;
import org.apache.commons.math3.linear.RealMatrix;

public class DistanceToCoordinates {

    private final double[][] distanceMatrix;
    private final int dimensions;

    public DistanceToCoordinates(double[][] distanceMatrix) {
        this.distanceMatrix = distanceMatrix;
        this.dimensions = distanceMatrix.length;
    }

    public double[][] calculateCoordinates() {
        // Paso 1: Calcular la matriz B
        double[][] B = calculateBMatrix();

        // Paso 2: Realizar la descomposición en valores propios de B
        EigenDecomposition eigen = new EigenDecomposition(new Array2DRowRealMatrix(B));

        // Paso 3: Obtener los valores propios y vectores propios
        double[] eigenvalues = eigen.getRealEigenvalues();
        RealMatrix eigenvectors = eigen.getV();

        // Paso 4: Ordenar los valores propios en orden descendente
        Integer[] indices = new Integer[dimensions];
        for (int i = 0; i < dimensions; i++) {
            indices[i] = i;
        }
        java.util.Arrays.sort(indices, (a, b) -> Double.compare(eigenvalues[b], eigenvalues[a]));

        // Paso 5: Calcular las coordenadas
        double[][] coordinates = new double[dimensions][dimensions];
        for (int i = 0; i < dimensions; i++) {
            for (int j = 0; j < dimensions; j++) {
                coordinates[i][j] = Math.sqrt(Math.max(0, eigenvalues[indices[j]])) * eigenvectors.getEntry(i, indices[j]);
            }
        }

        return coordinates;
    }

    private double[][] calculateBMatrix() {
        double[][] B = new double[dimensions][dimensions];
        double[] rowMeans = new double[dimensions];
        double totalMean = 0;

        // Calcular los cuadrados de las distancias
        for (int i = 0; i < dimensions; i++) {
            for (int j = 0; j < dimensions; j++) {
                B[i][j] = -0.5 * distanceMatrix[i][j] * distanceMatrix[i][j];
                rowMeans[i] += B[i][j];
                totalMean += B[i][j];
            }
            rowMeans[i] /= dimensions;
        }
        totalMean /= (dimensions * dimensions);

        // Centrar la matriz B
        for (int i = 0; i < dimensions; i++) {
            for (int j = 0; j < dimensions; j++) {
                B[i][j] = B[i][j] - rowMeans[i] - rowMeans[j] + totalMean;
            }
        }

        return B;
    }

    public static void main(String[] args) {
        double[][] distanceMatrix = {
            {0, 3538196.0, 3735982.0, 6458578.0, 4011596.0, 1278244.0, 4456652.0, 7001752.0},
            {3538196.0, 0, 6073624.0, 9765551.0, 5373577.0, 8563521.0, 9075418.0, 7378972.0},
            {3735982.0, 6073624.0, 0, 4434730.0, 1077102.0, 1125242.0, 3435080.0, 2347484.0},
            {6458578.0, 9765551.0, 4434730.0, 0, 7999311.0, 3946544.0, 1846094.0, 1283370.0},
            {4011596.0, 5373577.0, 1077102.0, 7999311.0, 0, 8920411.0, 1777521.0, 7183199.0},
            {1278244.0, 8563521.0, 1125242.0, 3946544.0, 8920411.0, 0, 6221466.0, 7883823.0},
            {4456652.0, 9075418.0, 3435080.0, 1846094.0, 1777521.0, 6221466.0, 0, 2385324.0},
            {7001752.0, 7378972.0, 2347484.0, 1283370.0, 7183199.0, 7883823.0, 2385324.0, 0}
        };

        DistanceToCoordinates calculator = new DistanceToCoordinates(distanceMatrix);
        double[][] coordinates = calculator.calculateCoordinates();

        // Imprimir las coordenadas
        for (int i = 0; i < coordinates.length; i++) {
            System.out.print("Nodo " + (char) ('A' + i) + ": [ ");
            for (int j = 0; j < coordinates[i].length; j++) {
                System.out.printf("%.4f ", coordinates[i][j]);
            }
            System.out.println("]");
        }
    }
}


Resultado:

run:
Nodo A: [ -2109176,7652 -2280795,2868 943542,6755 1167238,5398 -0,0000 -0,0000 -0,0000 0,0000 ]
Nodo B: [ -5501880,3926 -340732,2628 -2558730,8576 335704,8847 -0,0000 0,0000 0,0000 0,0000 ]
Nodo C: [ 100046,1854 -133636,2798 255465,7042 -1991154,7275 -0,0000 -0,0000 -0,0000 0,0000 ]
Nodo D: [ 4430934,9160 -101468,6811 -792915,6722 616290,8194 -0,0000 0,0000 -0,0000 0,0000 ]
Nodo E: [ -2944669,9418 2839449,1084 2485778,2633 -376992,5883 -0,0000 0,0000 -0,0000 -0,0000 ]
Nodo F: [ 1720031,9254 -4810714,6137 579380,6506 -443374,3002 -0,0000 -0,0000 0,0000 -0,0000 ]
Nodo G: [ 2087917,4093 2241964,4880 1969418,4176 812990,9949 -0,0000 -0,0000 0,0000 0,0000 ]
Nodo H: [ 2216796,6634 2585933,5278 -2881939,1813 -120703,6228 -0,0000 -0,0000 -0,0000 -0,0000 ]
BUILD SUCCESSFUL (total time: 0 seconds)

Conversor matriz de distancias a coordenadas cartesianas (MDS).

El algoritmo es conocido como Escalamiento Multidimensional(MDS) y puede ser utilizado para:

   . Reconstrucción de coordenadas: A partir de las distancias entre puntos, reconstruye sus posiciones relativas en un espacio en coordenadas cartesianas.
   . Visualización de datos: Permite representar en un espacio de menor dimensión (generalmente 2D o 3D) datos que originalmente están en un espacio de mayor dimensión.


Funcionamiento:

   1. Entrada: El algoritmo toma como entrada las distancias entre cuatro puntos o nodos en un espacio tridimensional.
   2. Proceso: Utiliza estas distancias para construir una matriz de distancias, la cual se transforma y se somete a una descomposición en valores singulares (SVD).
   3. Salida: Produce las coordenadas cartesianas (x, y, z) de los cuatro puntos (en el espacio 3D).


Código Java (CalculadorCoordenadasMDS.java):

package calculadorcoordenadasmds;

public class CalculadorCoordenadasMDS {

    public static void main(String[] args) {
        // Distancias dadas entre los nodos
        double d12 = 17;
        double d13 = 40;
        double d14 = 12;
        double d23 = 64;
        double d24 = 88;
        double d34 = 12;

        try {
            double[][] coordinates = calculateCoordinates(d12, d13, d14, d23, d24, d34);
            for (int i = 0; i < coordinates.length; i++) {
                System.out.printf("Nodo %d: (%.4f, %.4f, %.4f)%n",
                        i + 1, coordinates[i][0], coordinates[i][1], coordinates[i][2]);
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }

    public static double[][] calculateCoordinates(double d12, double d13, double d14, double d23, double d24, double d34) {
        double[][] distances = {
            {0, d12, d13, d14},
            {d12, 0, d23, d24},
            {d13, d23, 0, d34},
            {d14, d24, d34, 0}
        };

        double[][] b = new double[4][4];
        // Doble centrado de la matriz de distancias
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                b[i][j] = -0.5 * (distances[i][j] * distances[i][j]);
            }
        }

        double[] rowMeans = new double[4];
        double[] colMeans = new double[4];
        double totalMean = 0.0;

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                rowMeans[i] += b[i][j];
                colMeans[j] += b[i][j];
            }
            rowMeans[i] /= 4.0;
            totalMean += rowMeans[i];
        }
        totalMean /= 4.0;

        for (int i = 0; i < 4; i++) {
            colMeans[i] /= 4.0;
        }

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                b[i][j] += totalMean - rowMeans[i] - colMeans[j];
            }
        }

        SVDResult svd = svd(b);
        double[][] coordinates = new double[4][3];

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 3; j++) {
                coordinates[i][j] = svd.u[i][j] * Math.sqrt(svd.s[j]);
            }
        }

        return coordinates;
    }

    // Implementación simple de SVD
    private static SVDResult svd(double[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        double[][] u = new double[m][m];
        double[] s = new double[Math.min(m, n)];
        double[][] v = new double[n][n];

        // Implementación simplificada de SVD (no es una implementación completa)
        // Esta implementación asume que la matriz es simétrica y positiva semidefinida
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                u[i][j] = matrix[i][j];
            }
        }

        // Calculamos los valores propios (que serán nuestros valores singulares)
        for (int i = 0; i < s.length; i++) {
            double sum = 0;
            for (int j = 0; j < n; j++) {
                sum += matrix[i][j] * matrix[i][j];
            }
            s[i] = Math.sqrt(sum);
        }

        // Normalizamos las columnas de U
        for (int j = 0; j < m; j++) {
            double norm = 0;
            for (int i = 0; i < m; i++) {
                norm += u[i][j] * u[i][j];
            }
            norm = Math.sqrt(norm);
            if (norm > 0) {
                for (int i = 0; i < m; i++) {
                    u[i][j] /= norm;
                }
            }
        }

        return new SVDResult(u, s, v);
    }

    private static class SVDResult {

        double[][] u;
        double[] s;
        double[][] v;

        SVDResult(double[][] u, double[] s, double[][] v) {
            this.u = u;
            this.s = s;
            this.v = v;
        }
    }
}


Resultado:

run:
Nodo 1: (-10,9518, 13,1281, -18,6443)
Nodo 2: (22,3223, 37,7579, -18,2671)
Nodo 3: (-20,6027, -11,8716, 15,7343)
Nodo 4: (9,2322, -39,0143, 21,1772)
BUILD SUCCESSFUL (total time: 0 seconds)

Juegos IV.2. Tres en Raya (GUI).

Esta versión del código crea una interfaz gráfica para el juego de tres en raya con las siguientes características:

1- Usa una imagen para representar el tablero.
2- Los jugadores hacen clic directamente en las casillas para realizar sus jugadas.
3- Las X's y O's se dibujan en el tablero con diferentes colores.
4- Detecta automáticamente cuando hay un ganador o un empate.
5- Muestra mensajes de victoria o empate y reinicia el juego.


Código Java (TresEnRayaGUI.java):

package tresenrayagui;

import javax.swing.*;
import javax.swing.border.CompoundBorder;
import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

public class TresEnRayaGUI extends JFrame {

    private static final int CELL_SIZE = 100;
    private static final int BOARD_SIZE = 3;
    private static final int WINDOW_WIDTH = CELL_SIZE * BOARD_SIZE + 40;
    private static final int WINDOW_HEIGHT = CELL_SIZE * BOARD_SIZE + 160;

    private final char[][] tablero = new char[BOARD_SIZE][BOARD_SIZE];
    private char jugadorActual = 'X';
    private final JPanel boardPanel;
    private final JLabel turnoLabel;
    private final JLabel puntajeLabel;
    private int puntosX = 0, puntosO = 0;

    public TresEnRayaGUI() {
        setTitle("Tres en Raya");
        setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);
        setLocationRelativeTo(null);

        // Panel de información mejorado
        JPanel infoPanel = new JPanel(new GridLayout(2, 1, 0, 5));
        infoPanel.setBackground(new Color(230, 230, 250));
        infoPanel.setBorder(new CompoundBorder(
                new LineBorder(new Color(100, 100, 100), 2),
                new EmptyBorder(10, 10, 10, 10)
        ));

        Font mathFont = new Font("Cambria Math", Font.BOLD, 18);
        if (mathFont.getFamily().equals("Dialog")) {
            mathFont = new Font("Arial", Font.BOLD, 18);
        }

        turnoLabel = new JLabel("Turno del jugador: X", SwingConstants.CENTER);
        turnoLabel.setFont(mathFont);
        puntajeLabel = new JLabel("X: 0 | O: 0", SwingConstants.CENTER);
        puntajeLabel.setFont(mathFont);

        infoPanel.add(turnoLabel);
        infoPanel.add(puntajeLabel);
        add(infoPanel, BorderLayout.NORTH);

        inicializarTablero();

        boardPanel = new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                dibujarTablero(g);
            }
        };
        boardPanel.setPreferredSize(new Dimension(CELL_SIZE * BOARD_SIZE, CELL_SIZE * BOARD_SIZE));
        boardPanel.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                int col = e.getX() / CELL_SIZE;
                int row = e.getY() / CELL_SIZE;
                realizarJugada(row, col);
            }
        });

        JPanel centerPanel = new JPanel(new GridBagLayout());
        centerPanel.setBackground(new Color(230, 230, 250));
        centerPanel.add(boardPanel);

        add(centerPanel, BorderLayout.CENTER);
    }

    private void inicializarTablero() {
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                tablero[i][j] = ' ';
            }
        }
    }

    private void dibujarTablero(Graphics g) {
        Graphics2D g2d = (Graphics2D) g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        // Dibujar fondo degradado
        GradientPaint gp = new GradientPaint(0, 0, new Color(200, 220, 240), CELL_SIZE * BOARD_SIZE, CELL_SIZE * BOARD_SIZE, new Color(220, 240, 255));
        g2d.setPaint(gp);
        g2d.fillRect(0, 0, CELL_SIZE * BOARD_SIZE, CELL_SIZE * BOARD_SIZE);

        // Dibujar líneas del tablero
        g2d.setColor(new Color(100, 100, 100));
        g2d.setStroke(new BasicStroke(2));
        for (int i = 1; i < BOARD_SIZE; i++) {
            g2d.drawLine(i * CELL_SIZE, 0, i * CELL_SIZE, BOARD_SIZE * CELL_SIZE);
            g2d.drawLine(0, i * CELL_SIZE, BOARD_SIZE * CELL_SIZE, i * CELL_SIZE);
        }

        // Dibujar X y O
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (tablero[i][j] == 'X') {
                    dibujarX(g2d, j * CELL_SIZE, i * CELL_SIZE);
                } else if (tablero[i][j] == 'O') {
                    dibujarO(g2d, j * CELL_SIZE, i * CELL_SIZE);
                }
            }
        }
    }

    private void dibujarX(Graphics2D g2d, int x, int y) {
        g2d.setColor(new Color(220, 20, 60));
        g2d.setStroke(new BasicStroke(4, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        g2d.draw(new Line2D.Double(x + 20, y + 20, x + CELL_SIZE - 20, y + CELL_SIZE - 20));
        g2d.draw(new Line2D.Double(x + CELL_SIZE - 20, y + 20, x + 20, y + CELL_SIZE - 20));
    }

    private void dibujarO(Graphics2D g2d, int x, int y) {
        g2d.setColor(new Color(30, 144, 255));
        g2d.setStroke(new BasicStroke(4));
        g2d.draw(new Ellipse2D.Double(x + 20, y + 20, CELL_SIZE - 40, CELL_SIZE - 40));
    }

    private void realizarJugada(int row, int col) {
        if (tablero[row][col] == ' ') {
            tablero[row][col] = jugadorActual;
            boardPanel.repaint();
            if (verificarGanador(row, col)) {
                if (jugadorActual == 'X') {
                    puntosX++;
                } else {
                    puntosO++;
                }
                JOptionPane.showMessageDialog(this, "¡El jugador " + jugadorActual + " ha ganado!");
                reiniciarJuego();
            } else if (tableroLleno()) {
                JOptionPane.showMessageDialog(this, "¡Empate!");
                reiniciarJuego();
            } else {
                jugadorActual = (jugadorActual == 'X') ? 'O' : 'X';
                actualizarInfoLabel();
            }
        }
    }

    private boolean verificarGanador(int row, int col) {
        return (tablero[row][0] == jugadorActual && tablero[row][1] == jugadorActual && tablero[row][2] == jugadorActual)
                || (tablero[0][col] == jugadorActual && tablero[1][col] == jugadorActual && tablero[2][col] == jugadorActual)
                || (row == col && tablero[0][0] == jugadorActual && tablero[1][1] == jugadorActual && tablero[2][2] == jugadorActual)
                || (row + col == 2 && tablero[0][2] == jugadorActual && tablero[1][1] == jugadorActual && tablero[2][0] == jugadorActual);
    }

    private boolean tableroLleno() {
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (tablero[i][j] == ' ') {
                    return false;
                }
            }
        }
        return true;
    }

    private void reiniciarJuego() {
        inicializarTablero();
        jugadorActual = 'X';
        actualizarInfoLabel();
        boardPanel.repaint();
    }

    private void actualizarInfoLabel() {
        turnoLabel.setText("Turno del jugador: " + jugadorActual);
        puntajeLabel.setText("X: " + puntosX + " | O: " + puntosO);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new TresEnRayaGUI().setVisible(true));
    }
}


Resultado:

Juegos IV. Tres en Raya.

Código Java (TresEnRaya.java):

package tresenraya;

import java.util.Scanner;

public class TresEnRaya {

    private static final char[] JUGADORES = {'X', 'O'};
    private static final String LINEA_SUPERIOR = "  ╔═══╦═══╦═══╗";
    private static final String LINEA_MEDIA = "  ╠═══╬═══╬═══╣";
    private static final String LINEA_INFERIOR = "  ╚═══╩═══╩═══╝";

    private static final char[][] tablero = new char[3][3];
    private static final Scanner scanner = new Scanner(System.in);
    private static int jugadorActual = 0;

    public static void main(String[] args) {
        try (scanner) {
            while (true) {
                if (jugar()) {
                    break;
                }
            }
        }
    }

    private static boolean jugar() {
        inicializarTablero();
        while (true) {
            dibujarTablero();
            if (!realizarJugada()) {
                return false;
            }
            if (verificarGanador()) {
                dibujarTablero();
                System.out.println("¡El jugador " + JUGADORES[jugadorActual] + " ha ganado!");
                return true;
            }
            if (tableroLleno()) {
                dibujarTablero();
                System.out.println("¡Empate!");
                return true;
            }
            jugadorActual = 1 - jugadorActual;
        }
    }

    private static void inicializarTablero() {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                tablero[i][j] = ' ';
            }
        }
    }

    private static void dibujarTablero() {
        System.out.println(LINEA_SUPERIOR);
        for (int i = 2; i >= 0; i--) {
            System.out.print((i + 1) + "-║");
            for (int j = 0; j < 3; j++) {
                System.out.print(" " + tablero[i][j] + " ║");
            }
            System.out.println();
            if (i > 0) {
                System.out.println(LINEA_MEDIA);
            }
        }
        System.out.println(LINEA_INFERIOR);
        System.out.println("    A   B   C");
    }

    private static boolean realizarJugada() {
        System.out.println("Jugador " + JUGADORES[jugadorActual] + ", ingresa coordenada: ");
        try {
            String entrada = scanner.nextLine().toUpperCase().trim();
            if (entrada.length() != 2) {
                throw new IllegalArgumentException();
            }

            int columna = entrada.charAt(0) - 'A';
            int fila = Character.getNumericValue(entrada.charAt(1)) - 1;

            if (fila < 0 || fila > 2 || columna < 0 || columna > 2 || tablero[fila][columna] != ' ') {
                System.out.println("Jugada inválida. Intenta de nuevo.");
                return true;
            }
            tablero[fila][columna] = JUGADORES[jugadorActual];
            return true;
        } catch (IllegalArgumentException e) {
            System.out.println("Entrada inválida. ¿Deseas salir? (s/n)");
            return !scanner.nextLine().trim().equalsIgnoreCase("s");
        }
    }

    private static boolean verificarGanador() {
        for (int i = 0; i < 3; i++) {
            if (tablero[i][0] != ' ' && tablero[i][0] == tablero[i][1] && tablero[i][1] == tablero[i][2]) {
                return true;
            }
            if (tablero[0][i] != ' ' && tablero[0][i] == tablero[1][i] && tablero[1][i] == tablero[2][i]) {
                return true;
            }
        }
        return (tablero[0][0] != ' ' && tablero[0][0] == tablero[1][1] && tablero[1][1] == tablero[2][2])
                || (tablero[0][2] != ' ' && tablero[0][2] == tablero[1][1] && tablero[1][1] == tablero[2][0]);
    }

    private static boolean tableroLleno() {
        for (char[] fila : tablero) {
            for (char celda : fila) {
                if (celda == ' ') {
                    return false;
                }
            }
        }
        return true;
    }
}


Resultado:

run:
  ╔═══╦═══╦═══╗
3-║   ║   ║   ║
  ╠═══╬═══╬═══╣
2-║   ║   ║   ║
  ╠═══╬═══╬═══╣
1-║   ║   ║   ║
  ╚═══╩═══╩═══╝
    A   B   C
Jugador X, ingresa coordenada:
b1
  ╔═══╦═══╦═══╗
3-║   ║   ║   ║
  ╠═══╬═══╬═══╣
2-║   ║   ║   ║
  ╠═══╬═══╬═══╣
1-║   ║ X ║   ║
  ╚═══╩═══╩═══╝
    A   B   C
Jugador O, ingresa coordenada:
b2
  ╔═══╦═══╦═══╗
3-║   ║   ║   ║
  ╠═══╬═══╬═══╣
2-║   ║ O ║   ║
  ╠═══╬═══╬═══╣
1-║   ║ X ║   ║
  ╚═══╩═══╩═══╝
    A   B   C
Jugador X, ingresa coordenada:
c3
  ╔═══╦═══╦═══╗
3-║   ║   ║ X ║
  ╠═══╬═══╬═══╣
2-║   ║ O ║   ║
  ╠═══╬═══╬═══╣
1-║   ║ X ║   ║
  ╚═══╩═══╩═══╝
    A   B   C
Jugador O, ingresa coordenada:
 

Generación de laberintos I.2. Algoritmo de Aldous-Broder.

El Algoritmo de Aldous-Broder es otro método para generar un laberinto aleatorio. Funcionamiento para la generación es el siguiente:

    1. Comenzar en un vértice aleatorio del grafo.
    2. Elegir un vecino aleatorio del vértice actual.
    3. Si el vecino no ha sido visitado, añadir la arista entre el vértice actual y el vecino al árbol de expansión.
    4. Moverse al vecino elegido (sea visitado o no).
    5. Repetir los pasos 2-4 hasta que todos los vértices hayan sido visitados.

Este algoritmo es simple pero ineficiente, especialmente para grafos grandes, ya que puede tomar mucho tiempo para visitar todos los vértices.

 

Código (AldousBroderMaze.java):

package aldousbrodermaze;

import java.util.*;

public class AldousBroderMaze {

    private static final int[][] DIRECTIONS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    private final int width;
    private final int height;
    private final boolean[][] maze;

    public AldousBroderMaze(int width, int height) {
        this.width = width;
        this.height = height;
        this.maze = new boolean[height * 2 + 1][width * 2 + 1];
    }

    public void generateMaze() {
        Random rand = new Random();
        int x = rand.nextInt(width) * 2 + 1;
        int y = rand.nextInt(height) * 2 + 1;
        int unvisited = width * height - 1;

        maze[y][x] = true;

        while (unvisited > 0) {
            int[] direction = DIRECTIONS[rand.nextInt(DIRECTIONS.length)];
            int newX = x + direction[0] * 2;
            int newY = y + direction[1] * 2;

            if (newX > 0 && newX < maze[0].length && newY > 0 && newY < maze.length) {
                if (!maze[newY][newX]) {
                    maze[newY][newX] = true;
                    maze[y + direction[1]][x + direction[0]] = true;
                    unvisited--;
                }
                x = newX;
                y = newY;
            }
        }
    }

    public void printMaze() {
        for (boolean[] row : maze) {
            for (boolean cell : row) {
                System.out.print(cell ? "  " : "██");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        AldousBroderMaze maze = new AldousBroderMaze(10, 10);
        maze.generateMaze();
        maze.printMaze();
    }
}


Resultado:

run:
██████████████████████████████████████████
██              ██  ██      ██          ██
██  ██████████████  ██████  ██  ██████████
██              ██      ██  ██      ██  ██
██  ██  ██████████████  ██  ██  ██████  ██
██  ██      ██          ██  ██          ██
██  ██████████████  ██████  ██  ██████  ██
██              ██  ██          ██  ██  ██
██  ██████████  ██  ██████  ██  ██  ██████
██  ██  ██              ██  ██      ██  ██
██  ██  ██████████████████  ██████  ██  ██
██          ██  ██      ██  ██          ██
██████████  ██  ██████  ██  ██  ██  ██████
██          ██  ██  ██      ██  ██      ██
██████████  ██  ██  ██████████  ██████████
██              ██      ██  ██      ██  ██
██████████████  ██  ██████  ██  ██████  ██
██                      ██  ██  ██      ██
██████████  ██  ██████  ██  ██  ██████  ██
██          ██  ██                      ██
██████████████████████████████████████████
BUILD SUCCESSFUL (total time: 0 seconds)

Proyecto Ajedrez I.0: Descripción de las reglas

Objetivo del Juego de Ajedrez

El objetivo del ajedrez es dar jaque mate al rey oponente, lo que significa que el rey está en una posición de ataque y no puede escapar.

El Tablero

    El tablero es una cuadrícula de 8x8, con 64 casillas alternadas en colores claros y oscuros.
    Las columnas se denominan de la 'a' a la 'h', y las filas del '1' al '8'.

Colocación de las Piezas

    Fila 1 (de las blancas) y Fila 8 (de las negras): Torre (T), Caballo (C), Alfil (A), Dama (Q), Rey (K), Alfil (A), Caballo (C), Torre (T).
    Filas 2 (blancas) y 7 (negras): Peones (P).
    Las piezas blancas empiezan en las filas 1 y 2, las negras en las filas 7 y 8.

     ┌─────────────────┐
    8┤ t c a q k a c t │
    7┤ p p p p p p p p │
    6┤ . . . . . . . . │
    5┤ . . . . . . . . │
    4┤ . . . . . . . . │
    3┤ . . . . . . . . │
    2┤ P P P P P P P P │
    1┤ T C A Q K A C T │
     └─┬─┬─┬─┬─┬─┬─┬─┬─┘
       A B C D E F G H


Movimientos de las Piezas

    Peón (P)
        Movimiento: Avanza una casilla hacia adelante. En su primer movimiento, puede avanzar dos casillas.
        Captura: Una casilla en diagonal hacia adelante.
        Captura al paso: Un peón que avanza dos casillas desde su posición inicial puede ser capturado "al paso" por un peón enemigo como si solo hubiera avanzado una casilla. Esto solo es posible inmediatamente después del movimiento del peón.

    Torre (T)
        Movimiento: Vertical y horizontalmente, tantas casillas como desee.
        Captura: Igual que el movimiento.

    Caballo (C)
        Movimiento: Forma de 'L' (dos casillas en una dirección y una en perpendicular). Puede saltar sobre otras piezas.
        Captura: Igual que el movimiento.

    Alfil (A)
        Movimiento: Diagonalmente, tantas casillas como desee.
        Captura: Igual que el movimiento.

    Dama (Q)
        Movimiento: Vertical, horizontal y diagonalmente, tantas casillas como desee.
        Captura: Igual que el movimiento.

    Rey (K)
        Movimiento: Una casilla en cualquier dirección.
        Captura: Igual que el movimiento.
        Enroque: Movimiento especial en colaboración con una torre (ver detalles abajo).

Movimientos Especiales

    Enroque:
        Condiciones:
            El rey y la torre implicada no deben haberse movido previamente.
            No debe haber piezas entre el rey y la torre.
            El rey no puede estar en jaque, pasar por casillas bajo ataque, ni terminar en jaque.
        Movimiento:
            Enroque corto: Rey mueve dos casillas hacia la torre del lado rey, y la torre se coloca a su lado.
            Enroque largo: Rey mueve dos casillas hacia la torre del lado dama, y la torre se coloca a su lado.

    Captura al paso: Un peón que avanza dos casillas desde su posición inicial puede ser capturado al paso por un peón enemigo en la columna adyacente que se encuentra en la quinta fila (blancas) o cuarta fila (negras).

    Promoción de Peón: Cuando un peón alcanza la octava fila, debe ser promovido a una dama, torre, alfil o caballo, a elección del jugador.

Reglas de Jaque y Jaque Mate

    Jaque: El rey está bajo ataque. El jugador debe mover el rey, capturar la pieza atacante o interponer otra pieza para bloquear el ataque.
    Jaque Mate: El rey está bajo ataque y no puede escapar. El juego termina y el jugador que dio el jaque mate gana.

Otras Reglas

    Tablas: El juego puede terminar en empate por varias razones, como repetición de jugadas, rey ahogado (rey no está en jaque pero no tiene movimientos legales), acuerdo mutuo, o si 50 movimientos han pasado sin captura ni movimiento de peón.

 

Gráfica de un mapa de calor a partir de una matriz.

Este programa crea una ventana que muestra un mapa de calor basado en los valores de la matriz proporcionada. Los valores más bajos se representan en negro y los valores más altos en blanco, con una escala de grises entre ellos.

Matriz de distancias:

    0  185  905  911  236  173  549   85  506  972  911  681
  185    0  421  824  270  350   79  275  666  831  259  251
  905  421    0  286  136  338  764  249  881  508  902  798
  911  824  286    0  924  282  815   40  242  571  448  886
  236  270  136  924    0   88  521  140  345  799  544  295
  173  350  338  282   88    0  584  254   61   76  931  870
  549   79  764  815  521  584    0  353  795  547  213  198
   85  275  249   40  140  254  353    0  181  682  427  539
  506  666  881  242  345   61  795  181    0  618  775  521
  972  831  508  571  799   76  547  682  618    0  734  462
  911  259  902  448  544  931  213  427  775  734    0  162
  681  251  798  886  295  870  198  539  521  462  162    0


Código Java (HeatMap.java):

import javax.swing.*;
import java.awt.*;

public class HeatMap extends JPanel {
    private final int[][] data;
    private final int maxValue;
    private final int minValue;

    public HeatMap(int[][] data) {
        this.data = data;
        this.maxValue = findMaxValue(data);
        this.minValue = findMinValue(data);
    }

    private int findMaxValue(int[][] data) {
        int max = Integer.MIN_VALUE;
        for (int[] row : data) {
            for (int value : row) {
                if (value > max) {
                    max = value;
                }
            }
        }
        return max;
    }

    private int findMinValue(int[][] data) {
        int min = Integer.MAX_VALUE;
        for (int[] row : data) {
            for (int value : row) {
                if (value < min) {
                    min = value;
                }
            }
        }
        return min;
    }

    private Color getColor(int value) {
        float normalizedValue = (float)(value - minValue) / (maxValue - minValue);
        int gray = (int)(normalizedValue * 255);
        return new Color(gray, gray, gray);
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        int cellWidth = getWidth() / data[0].length;
        int cellHeight = getHeight() / data.length;
        for (int row = 0; row < data.length; row++) {
            for (int col = 0; col < data[row].length; col++) {
                g.setColor(getColor(data[row][col]));
                g.fillRect(col * cellWidth, row * cellHeight, cellWidth, cellHeight);
            }
        }
    }

    @Override
    public Dimension getPreferredSize() {
        return new Dimension(600, 600);
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Heat Map");
        int[][] data = {
            {0, 185, 905, 911, 236, 173, 549, 85, 506, 972, 911, 681},
            {185, 0, 421, 824, 270, 350, 79, 275, 666, 831, 259, 251},
            {905, 421, 0, 286, 136, 338, 764, 249, 881, 508, 902, 798},
            {911, 824, 286, 0, 924, 282, 815, 40, 242, 571, 448, 886},
            {236, 270, 136, 924, 0, 88, 521, 140, 345, 799, 544, 295},
            {173, 350, 338, 282, 88, 0, 584, 254, 61, 76, 931, 870},
            {549, 79, 764, 815, 521, 584, 0, 353, 795, 547, 213, 198},
            {85, 275, 249, 40, 140, 254, 353, 0, 181, 682, 427, 539},
            {506, 666, 881, 242, 345, 61, 795, 181, 0, 618, 775, 521},
            {972, 831, 508, 571, 799, 76, 547, 682, 618, 0, 734, 462},
            {911, 259, 902, 448, 544, 931, 213, 427, 775, 734, 0, 162},
            {681, 251, 798, 886, 295, 870, 198, 539, 521, 462, 162, 0}
        };

        HeatMap heatMap = new HeatMap(data);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(heatMap);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}

Resultado: