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.

El autómata de clase 4. Patrón 110.

El autómata celular unidimensional basado en la regla 110 de Stephen Wolfram, es un sistema de evolución discreto que sigue reglas simples para generar patrones complejos a partir de una serie inicial de células.

El ejemplo de autómata de clase 4 aquí descrito, produce patrones complejos y no periódicos que pueden ser difíciles de predecir. Estos patrones pueden tener aplicaciones en la generación de números pseudoaleatorios, criptografía y en simulación de sistemas complejos.


Código Java (Regla110.java):

public class Regla110 {
    public static void main(String[] args) {
        int[] cells = new int[64];
        cells[cells.length / 2] = 1;
        int[] newCells = new int[cells.length];

        for (int t = 0; t < 32; t++) {
            printCells(cells);

            for (int i = 1; i < cells.length - 1; i++) {
                int left = cells[i - 1];
                int center = cells[i];
                int right = cells[i + 1];
                newCells[i] = applyRule110(left, center, right);
            }

            System.arraycopy(newCells, 0, cells, 0, cells.length);
        }
    }

    private static void printCells(int[] cells) {
        for (int cell : cells) {
            System.out.print(cell == 0 ? "." : "┼");
        }
        System.out.println();
    }

    private static int applyRule110(int left, int center, int right) {
        int rule = (left << 2) | (center << 1) | right;
        int rule110 = 0b01110110;
        return (rule110 >> rule) & 1;
    }
}


Resultado:

run:
................................┼...............................
...............................┼┼┼..............................
..............................┼..┼┼.............................
.............................┼┼┼┼.┼┼............................
............................┼...┼┼.┼┼...........................
...........................┼┼┼.┼.┼┼.┼┼..........................
..........................┼..┼┼┼┼.┼┼.┼┼.........................
.........................┼┼┼┼...┼┼.┼┼.┼┼........................
........................┼...┼┼.┼.┼┼.┼┼.┼┼.......................
.......................┼┼┼.┼.┼┼┼┼.┼┼.┼┼.┼┼......................
......................┼..┼┼┼┼...┼┼.┼┼.┼┼.┼┼.....................
.....................┼┼┼┼...┼┼.┼.┼┼.┼┼.┼┼.┼┼....................
....................┼...┼┼.┼.┼┼┼┼.┼┼.┼┼.┼┼.┼┼...................
...................┼┼┼.┼.┼┼┼┼...┼┼.┼┼.┼┼.┼┼.┼┼..................
..................┼..┼┼┼┼...┼┼.┼.┼┼.┼┼.┼┼.┼┼.┼┼.................
.................┼┼┼┼...┼┼.┼.┼┼┼┼.┼┼.┼┼.┼┼.┼┼.┼┼................
................┼...┼┼.┼.┼┼┼┼...┼┼.┼┼.┼┼.┼┼.┼┼.┼┼...............
...............┼┼┼.┼.┼┼┼┼...┼┼.┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼..............
..............┼..┼┼┼┼...┼┼.┼.┼┼┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.............
.............┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼............
............┼...┼┼.┼.┼┼┼┼...┼┼.┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼...........
...........┼┼┼.┼.┼┼┼┼...┼┼.┼.┼┼┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼..........
..........┼..┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.........
.........┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼........
........┼...┼┼.┼.┼┼┼┼...┼┼.┼.┼┼┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.......
.......┼┼┼.┼.┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼......
......┼..┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.....
.....┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼.┼┼┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼....
....┼...┼┼.┼.┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼...
...┼┼┼.┼.┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼..
..┼..┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼.┼┼┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.
.┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼.┼┼┼┼...┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼┼.┼.
BUILD SUCCESSFUL (total time: 0 seconds)

Espirales. Graficar Espiral de Fermat.

La espiral de Fermat es una curva logarítmica que se describe mediante una ecuación polar. Esta espiral se caracteriza por tener radios que se expanden logarítmicamente con respecto al ángulo polar. La ecuación de la espiral de Fermat es:

r = a * t^(1/n)

r: Distancia del origen a un punto en la espiral.
a: Constante positiva. Controla la tasa de expansión de los radios en la espiral.
t: Ángulo polar.
n: Exponente de la constante. Determina el grado de curvatura de la espiral y cómo se relaciona con el ángulo polar.


Código Java (FermatSpiral.java):

package fermatspiral;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.Line2D;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class FermatSpiral extends JPanel {

    private static final long serialVersionUID = 1L;
    private static final int MAX_ITER = 512;
    private static final double SCALE = 80;
    private static final double A = 1;
    private static final int N = 3;

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.translate(getWidth() / 2, getHeight() / 2);
        float lineWidth = 0.1f;
        double theta = 0;
        double r;
        g2d.setColor(Color.BLUE);
        double x1 = 0, y1 = 0, x2, y2;
        for (int i = 0; i < MAX_ITER; i++) {
            r = A * Math.pow(theta, 1.0 / N);
            x2 = SCALE * r * Math.cos(theta);
            y2 = SCALE * r * Math.sin(theta);
            g2d.setStroke(new BasicStroke(lineWidth));
            g2d.draw(new Line2D.Double(x1, y1, x2, y2));
            theta += 0.1;
            lineWidth += 0.01;
            x1 = x2;
            y1 = y2;
        }
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Spiral Fermat");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(new FermatSpiral());
        frame.setSize(new Dimension(800, 800));
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
    
}

Resultado: