Juegos III.1. Generador de Sudokus aleatorios.

En esta versión se añade formato al tablero de juego mediante caracteres ASCII.


Código Java (SudokuGenerator.java):

package sudokugenerator;

import java.util.Random;

public class SudokuGenerator {

    private static final int BOARD_SIZE = 9;
    private static final int SUB_GRID_SIZE = 3;
    private static final int NUM_REMOVES = 20;

    public static void main(String[] args) {
        int[][] board = generateSudoku();
        printBoard(board);
    }

    public static int[][] generateSudoku() {
        int[][] board = new int[BOARD_SIZE][BOARD_SIZE];
        populateBoard(board);
        removeCells(board);
        return board;
    }

    private static void populateBoard(int[][] board) {
        if (!solve(board, 0, 0)) {
            throw new IllegalStateException("No se pudo generar un sudoku válido.");
        }
    }

    private static boolean solve(int[][] board, int row, int col) {
        if (col == BOARD_SIZE) {
            col = 0;
            row++;
            if (row == BOARD_SIZE) {
                return true;
            }
        }

        if (board[row][col] != 0) {
            return solve(board, row, col + 1);
        }

        Random rand = new Random();
        for (int num : rand.ints(1, BOARD_SIZE + 1).distinct().limit(BOARD_SIZE).toArray()) {
            if (isValid(board, row, col, num)) {
                board[row][col] = num;
                if (solve(board, row, col + 1)) {
                    return true;
                }
            }
        }

        board[row][col] = 0;
        return false;
    }

    private static boolean isValid(int[][] board, int row, int col, int num) {
        for (int i = 0; i < BOARD_SIZE; i++) {
            if (board[row][i] == num || board[i][col] == num) {
                return false;
            }
        }

        int r = row - row % SUB_GRID_SIZE;
        int c = col - col % SUB_GRID_SIZE;
        for (int i = r; i < r + SUB_GRID_SIZE; i++) {
            for (int j = c; j < c + SUB_GRID_SIZE; j++) {
                if (board[i][j] == num) {
                    return false;
                }
            }
        }

        return true;
    }

    private static void removeCells(int[][] board) {
        Random rand = new Random();
        for (int i = 0; i < NUM_REMOVES; i++) {
            int row = rand.nextInt(BOARD_SIZE);
            int col = rand.nextInt(BOARD_SIZE);
            board[row][col] = 0;
        }
    }

    private static void printBoard(int[][] board) {
        System.out.println("+-------+-------+-------+");
        for (int i = 0; i < BOARD_SIZE; i++) {
            System.out.print("| ");
            for (int j = 0; j < BOARD_SIZE; j++) {
                if (board[i][j] == 0) {
                    System.out.print("▓ ");
                } else {
                    System.out.print(board[i][j] + " ");
                }
                if (j % 3 == 2) {
                    System.out.print("| ");
                }
            }
            System.out.println();
            if (i % 3 == 2) {
                System.out.println("+-------+-------+-------+");
            }
        }
    }
}


Resultado:

run:
+-------+-------+-------+
| ▓ 6 3 | 9 7 8 | 1 2 5 |
| 9 7 8 | 5 ▓ ▓ | 6 3 4 |
| 5 2 1 | 4 6 3 | 8 ▓ 9 |
+-------+-------+-------+
| 3 5 9 | 7 2 ▓ | ▓ 1 ▓ |
| 2 1 ▓ | 8 ▓ 4 | 3 9 ▓ |
| ▓ ▓ 4 | 1 3 9 | ▓ 5 7 |
+-------+-------+-------+
| 8 ▓ 2 | 3 4 7 | 5 6 1 |
| 1 4 6 | 2 9 ▓ | 7 ▓ 3 |
| 7 ▓ 5 | ▓ 8 1 | ▓ 4 2 |
+-------+-------+-------+
BUILD SUCCESSFUL (total time: 0 seconds)

Juegos III. Generador de Sudokus aleatorios.

Este generador crea un tablero de Sudoku completamente resuelto utilizando backtracking y luego elimina un número específico de celdas (en este caso 20) para crear el puzzle. Puedes ajustar el número de celdas eliminadas (NUM_REMOVES) para controlar la dificultad del sudoku generado.


Código Java (SudokuGenerator.java):

package sudokugenerator;

import java.util.Random;

public class SudokuGenerator {

    private static final int BOARD_SIZE = 9;
    private static final int SUB_GRID_SIZE = 3;
    private static final int NUM_REMOVES = 20;

    public static void main(String[] args) {
        int[][] board = generateSudoku();
        printBoard(board);
    }

    public static int[][] generateSudoku() {
        int[][] board = new int[BOARD_SIZE][BOARD_SIZE];
        populateBoard(board);
        removeCells(board);
        return board;
    }

    private static void populateBoard(int[][] board) {
        if (!solve(board, 0, 0)) {
            throw new IllegalStateException("No se pudo generar un sudoku válido.");
        }
    }

    private static boolean solve(int[][] board, int row, int col) {
        if (col == BOARD_SIZE) {
            col = 0;
            row++;
            if (row == BOARD_SIZE) {
                return true;
            }
        }

        if (board[row][col] != 0) {
            return solve(board, row, col + 1);
        }

        Random rand = new Random();
        for (int num : rand.ints(1, BOARD_SIZE + 1).distinct().limit(BOARD_SIZE).toArray()) {
            if (isValid(board, row, col, num)) {
                board[row][col] = num;
                if (solve(board, row, col + 1)) {
                    return true;
                }
            }
        }

        board[row][col] = 0;
        return false;
    }

    private static boolean isValid(int[][] board, int row, int col, int num) {
        for (int i = 0; i < BOARD_SIZE; i++) {
            if (board[row][i] == num || board[i][col] == num) {
                return false;
            }
        }

        int r = row - row % SUB_GRID_SIZE;
        int c = col - col % SUB_GRID_SIZE;
        for (int i = r; i < r + SUB_GRID_SIZE; i++) {
            for (int j = c; j < c + SUB_GRID_SIZE; j++) {
                if (board[i][j] == num) {
                    return false;
                }
            }
        }

        return true;
    }

    private static void removeCells(int[][] board) {
        Random rand = new Random();
        for (int i = 0; i < NUM_REMOVES; i++) {
            int row = rand.nextInt(BOARD_SIZE);
            int col = rand.nextInt(BOARD_SIZE);
            board[row][col] = 0;
        }
    }

    private static void printBoard(int[][] board) {
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
    }
}


Resultado:

2 7 9 4 3 8 1 5 0
3 4 1 0 7 6 2 8 0
6 8 5 2 1 0 7 3 4
9 0 8 3 0 7 0 6 0
4 1 3 9 6 0 8 7 2
5 0 0 1 0 2 4 9 3
7 9 2 6 0 1 3 4 0
0 3 6 7 2 4 9 1 5
1 5 4 0 9 3 0 2 7

Juegos II. Piedra papel tijeras.

Es un juego de manos en el que se selecciona entre piedra, papel o tijeras, con el objetivo de vencer al oponente. La piedra vence a las tijeras, las tijeras vencen al papel y el papel vence a la piedra.


Código Java (PiedraPapelTijeras.java):

import java.util.Random;
import java.util.Random;
import java.util.Scanner;

public class PiedraPapelTijeras {

    public static void main(String[] args) {
        String[] opciones = {"piedra", "papel", "tijeras"};
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();
        int puntajeJugador = 0;
        int puntajeComputadora = 0;
        String respuesta;
        do {
            String computadora = opciones[random.nextInt(opciones.length)];
            System.out.print("Elige Piedra, Papel o Tijeras: ");
            String jugador = scanner.nextLine().toLowerCase();
            System.out.println("Jugador: " + jugador);
            System.out.println("Computadora: " + computadora);
            if (jugador.equals(computadora)) {
                System.out.println("Empate.");
            } else if ((jugador.equals("piedra") && computadora.equals("tijeras"))
                    || (jugador.equals("papel") && computadora.equals("piedra"))
                    || (jugador.equals("tijeras") && computadora.equals("papel"))) {
                System.out.println("Ganaste.");
                puntajeJugador++;
            } else {
                System.out.println("Perdiste.");
                puntajeComputadora++;
            }
            System.out.println("Puntuacion: Jugador " + puntajeJugador + ", Computadora " + puntajeComputadora);
            System.out.print("Quieres jugar de nuevo? (s/n): ");
            respuesta = scanner.nextLine();
        } while (respuesta.equalsIgnoreCase("s"));
    }
}


Resultado:

Elige Piedra, Papel o Tijeras: piedra
Jugador: piedra
Computadora: tijeras
Ganaste.
Puntuacion: Jugador 1, Computadora 0
Quieres jugar de nuevo? (s/n): s
Elige Piedra, Papel o Tijeras: tijeras
Jugador: tijeras
Computadora: papel
Ganaste.
Puntuacion: Jugador 2, Computadora 0
Quieres jugar de nuevo? (s/n): s
Elige Piedra, Papel o Tijeras: papel
Jugador: papel
Computadora: papel
Empate.
Puntuacion: Jugador 2, Computadora 0
Quieres jugar de nuevo? (s/n): s
Elige Piedra, Papel o Tijeras: tijeras
Jugador: tijeras
Computadora: piedra
Perdiste.
Puntuacion: Jugador 2, Computadora 1
Quieres jugar de nuevo? (s/n): n

Juegos I. Guess the number.

En este ejemplo, el programa genera un número aleatorio entre 1 y 100 y le da al usuario un máximo de 10 intentos para adivinar el número correcto. Cada vez que el usuario ingresa un número, el programa verifica si es mayor o menor que el número aleatorio y proporciona una pista.


Código Java (AdivinaNumero.java):

import java.util.Random;
import java.util.Scanner;

public class AdivinaNumero {
    public static void main(String[] args) {
        Random rand = new Random();
        int numeroAleatorio = rand.nextInt(100) + 1; // Genera un numero aleatorio entre 1 y 100
        Scanner sc = new Scanner(System.in);
        int intentos = 0;
        int numeroIngresado = 0;
        while (intentos < 10) { // El usuario tiene un maximo de 10 intentos
            System.out.print("Adivina el numero (entre 1 y 100): ");
            numeroIngresado = sc.nextInt();
            intentos++;
            if (numeroIngresado == numeroAleatorio) { // Si el usuario adivina el numero, sale del loop
                System.out.println("Felicidades! Adivinaste el numero en " + intentos + " intentos.");
                break;
            } else if (numeroIngresado < numeroAleatorio) {
                System.out.println("El numero es mayor.");
            } else {
                System.out.println("El numero es menor.");
            }
        }
        if (intentos == 10) { // Si el usuario agota sus 10 intentos, muestra el numero aleatorio
            System.out.println("Lo siento, agotaste tus intentos. El numero era " + numeroAleatorio + ".");
        }
    }
}


Resultado:

Adivina el numero (entre 1 y 100): 50
El numero es menor.
Adivina el numero (entre 1 y 100): 25
El numero es mayor.
Adivina el numero (entre 1 y 100): 42
El numero es menor.
Adivina el numero (entre 1 y 100): 35
Felicidades! Adivinaste el numero en 4 intentos.