En esta nueva versión añadimos el operador de potencia ^ que faltaba.
Hay que tener en cuenta que el operador de potencia ^ tiene una prioridad muy alta en las expresiones matemáticas, lo que significa que se evalúa antes que los otros operadores.
Código Java (InfijoPostfijo,java):
package infijopostfijo;
import java.util.Scanner;
import java.util.Stack;
public class InfijoPostfijo {
public static void main(String[] args) {
// Declaración de las pilas
Stack<String> E = new Stack<>(); // Pila entrada
Stack<String> P = new Stack<>(); // Pila temporal para operadores
Stack<String> S = new Stack<>(); // Pila salida
// Entrada de datos
System.out.println("> Ingresa expresión algebraica a convertir:");
Scanner leer = new Scanner(System.in);
// Pasar expresión algebraica a la Pila de entrada (E)
String[] arrayInfix = formato(leer.nextLine()).split(" ");
for (int i = arrayInfix.length - 1; i >= 0; i--) {
E.push(arrayInfix[i]);
}
// Conversor Infijo a Postfijo
while (!E.isEmpty()) {
switch (prioridad(E.peek())) {
case 1 -> P.push(E.pop());
case 2 -> {
while (!P.peek().equals("(")) {
S.push(P.pop());
}
P.pop();
E.pop();
}
case 3, 4 -> {
while (prioridad(P.peek()) >= prioridad(E.peek())) {
S.push(P.pop());
}
P.push(E.pop());
}
case 5 -> P.push(E.pop());
default -> S.push(E.pop());
}
}
// Mostrar resultado:
System.out.println("> Resultado en notación postfija:\n" + S.toString().replaceAll("[\\]\\[,]", ""));
}
// Prioridad de los operadores
private static int prioridad(String op) {
return switch (op) {
case "^" -> 5;
case "*", "/" -> 4;
case "+", "-" -> 3;
case ")" -> 2;
case "(" -> 1;
default -> 99;
};
}
// Formato expresión algebraica
private static String formato(String s) {
return "( " + s.replaceAll("([\\+|\\-|\\*|\\/|\\(|\\)|\\^|])", " $1 ").replaceAll("\\s+", " ") + " )";
}
}
Resultado:
run:
> Ingresa expresión algebraica a convertir:
(((34/2)+(43-5-32))^2*2+45-3+(34*2)/5)-1
> Resultado en notación postfija:
34 2 / 43 5 - 32 - + 2 ^ 2 * 45 + 3 - 34 2 * 5 / + 1 -
BUILD SUCCESSFUL (total time: 3 seconds)
lunes, 26 de diciembre de 2022
Conversión de Infijo a Postfijo usando pilas (v.3). Añadir operador de potencia ^.
domingo, 25 de diciembre de 2022
Conversión de Infijo a Postfijo usando pilas (v.2)
package infijopostfijo;
import java.util.Scanner;
import java.util.Stack;
public class InfijoPostfijo {
public static void main(String[] args) {
// Declaración de las pilas
Stack<String> E = new Stack<>(); // Pila entrada
Stack<String> P = new Stack<>(); // Pila temporal para operadores
Stack<String> S = new Stack<>(); // Pila salida
// Entrada de datos
System.out.println("> Ingresa una expresión algebraica: ");
Scanner leer = new Scanner(System.in);
// Pasar expresión algebraica a la Pila de entrada (E)
String[] arrayInfix = formato(leer.nextLine()).split(" ");
for (int i = arrayInfix.length - 1; i >= 0; i--) {
E.push(arrayInfix[i]);
}
// Conversor Infijo a Postfijo
while (!E.isEmpty()) {
switch (prioridad(E.peek())) {
case 1 -> P.push(E.pop());
case 2 -> {
while (!P.peek().equals("(")) {
S.push(P.pop());
}
P.pop();
E.pop();
}
case 3, 4 -> {
while (prioridad(P.peek()) >= prioridad(E.peek())) {
S.push(P.pop());
}
P.push(E.pop());
}
default -> S.push(E.pop());
}
}
// Mostrar resultado:
System.out.println("> Expresión Postfija:\n" + S.toString().replaceAll("[\\]\\[,]", ""));
}
// Prioridad de los operadores
private static int prioridad(String op) {
return switch (op) {
case "*", "/" -> 4;
case "+", "-" -> 3;
case ")" -> 2;
case "(" -> 1;
default -> 99;
};
}
// Formato expresión algebraica
private static String formato(String s) {
return "( " + s.replaceAll("([\\+|\\-|\\*|\\/|\\(|\\)])", " $1 ").replaceAll("\\s+", " ") + " )";
}
}
Resultado:
run:
> Ingresa una expresión algebraica:
2*(23+6)-1
> Expresión Postfija:
2 23 6 + * 1 -
BUILD SUCCESSFUL (total time: 7 seconds)
Validación DNI de España.
Código java (AI_DniValidator.java):
package ai_dnivalidator;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class AI_DniValidator {
private static final String DNI_PATTERN = "^[0-9]{8}[A-Z]$";
public static boolean isValid(String dni) {
Pattern pattern = Pattern.compile(DNI_PATTERN);
Matcher matcher = pattern.matcher(dni);
if (!matcher.matches()) {
return false;
}
String letras = "TRWAGMYFPDXBNJZSQVHLCKE";
int modulo = Integer.parseInt(dni.substring(0, 8)) % 23;
char letraEsperada = letras.charAt(modulo);
char letraObtenida = dni.charAt(8);
return letraEsperada == letraObtenida;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Ingresa un DNI: ");
String dni = scanner.nextLine().toUpperCase();
System.out.println(isValid(dni) ? "DNI válido" : "DNI inválido");
}
}
Resultado:
run:
Ingresa un DNI: 12345678z
DNI válido
BUILD SUCCESSFUL (total time: 5 seconds)
sábado, 24 de diciembre de 2022
Dibujar fractal de Mandelbrot
Un fractal de Mandelbrot es una imagen matemática que se crea a partir de una fórmula iterativa y se representa gráficamente en un plano complejo. Cada punto del plano se asigna un color en función de la cantidad de iteraciones que se necesitan para que el valor del número complejo alcance un cierto umbral.
Código java (AI_MandelbrotG.java):
package ai_mandelbrotg;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class AI_MandelbrotG extends JPanel {
public static int WIDTH = 480;
public static int HEIGHT = 300;
public static final int MAX_ITERATIONS = 64;
@Override
public void paintComponent(Graphics graphics) {
super.paintComponent(graphics);
for (int x = 0; x < WIDTH; x++) {
for (int y = 0; y < HEIGHT; y++) {
// Calcula el valor de c para el punto (x, y)
double cReal = (x - WIDTH / 2) * 4.0 / WIDTH;
double cImag = (y - HEIGHT / 2) * 4.0 / WIDTH;
// Calcula el valor de z para el punto (x, y)
double zReal = 0;
double zImag = 0;
// Itera hasta encontrar el valor de z para el punto (x, y)
int iterations = 0;
while (zReal * zReal + zImag * zImag < 4 && iterations < MAX_ITERATIONS) {
double zRealTemp = zReal * zReal - zImag * zImag + cReal;
zImag = 2 * zReal * zImag + cImag;
zReal = zRealTemp;
iterations++;
}
// Establece el color para el punto (x, y) en función del número de iteraciones
int colorValue = 255 * iterations / MAX_ITERATIONS;
graphics.setColor(new Color(colorValue, colorValue, colorValue));
graphics.drawLine(x, y, x, y);
}
}
}
public static void main(String[] args) {
JFrame frame = new JFrame("Fractal de Mandelbrot");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
AI_MandelbrotG panel = new AI_MandelbrotG();
panel.setPreferredSize(new Dimension(WIDTH, HEIGHT));
frame.add(panel);
frame.pack();
frame.setVisible(true);
}
}
Resultado:
viernes, 23 de diciembre de 2022
Crear curva Bézier. Uso de método curveTo de GeneralPath.
Código (Bezier.java):
package bezier;
import java.awt.BasicStroke;
import java.awt.Graphics;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.GeneralPath;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Bezier extends JPanel {
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g;
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2d.setStroke(new BasicStroke(4.0f));
int ancho = getWidth();
int alto = getHeight();
int x1 = ancho / 4;
int y1 = alto / 4;
int x2 = 3 * ancho / 4;
int y2 = alto / 4;
int x3 = ancho / 4;
int y3 = 3 * alto / 4;
int x4 = 3 * ancho / 4;
int y4 = 3 * alto / 4;
GeneralPath path = new GeneralPath();
path.moveTo(x1, y1);
path.curveTo(x2, y2, x3, y3, x4, y4);
g2d.setColor(Color.BLUE);
g2d.draw(path);
}
public static void main(String[] args) {
JFrame ventana = new JFrame("Curva Bézier");
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
ventana.add(new Bezier());
ventana.setSize(256, 256);
ventana.setVisible(true);
}
}
Resultado:
jueves, 27 de octubre de 2022
Mezlar, ordenar, rotar e invertir un listado. Uso "Collections".
Código (EjemploColecciones.java):
package ejemplocolecciones;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class EjemploColecciones {
public static void main(String[] args) {
List<Integer> cuadrante = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
//mostrar
System.out.println("lista inicial:\n" + cuadrante);
//mezclar
Collections.shuffle(cuadrante);
System.out.println("\nmezclar:\n" + cuadrante);
//ordenar
Collections.sort(cuadrante);
System.out.println("\nordenar\n" + cuadrante);
//rotar hacia la derecha
Collections.rotate(cuadrante, 1);
System.out.println("\ndesplazar hacia la derecha:\n" + cuadrante);
//rotar hacia la izquierda
Collections.rotate(cuadrante, -1);
System.out.println("\ndesplazar hacia la izquierda:\n" + cuadrante);
//invertir
Collections.reverse(cuadrante);
System.out.println("\ninvertir:\n" + cuadrante);
}
}
Resultado:
run:
lista inicial:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
mezclar:
[7, 9, 8, 6, 1, 5, 4, 2, 3]
ordenar
[1, 2, 3, 4, 5, 6, 7, 8, 9]
desplazar hacia la derecha:
[9, 1, 2, 3, 4, 5, 6, 7, 8]
desplazar hacia la izquierda:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
invertir:
[9, 8, 7, 6, 5, 4, 3, 2, 1]
BUILD SUCCESSFUL (total time: 0 seconds)
Rotar elementos de una lista. Uso de "Collections.rotate".
El siguiente algoritmo desplaza una posición los elementos de una lista.
Código (ListaRotar.java):
package listarotar;
import java.util.List;
import java.util.Arrays;
import java.util.Collections;
public class ListaRotar {
public static void main(String[] args) {
List<Integer> cuadrante = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
for (int i = 0; i < 9; i++) {
Collections.rotate(cuadrante, 1);
System.out.println(cuadrante);
}
}
}
Resultado:
run:
[9, 1, 2, 3, 4, 5, 6, 7, 8]
[8, 9, 1, 2, 3, 4, 5, 6, 7]
[7, 8, 9, 1, 2, 3, 4, 5, 6]
[6, 7, 8, 9, 1, 2, 3, 4, 5]
[5, 6, 7, 8, 9, 1, 2, 3, 4]
[4, 5, 6, 7, 8, 9, 1, 2, 3]
[3, 4, 5, 6, 7, 8, 9, 1, 2]
[2, 3, 4, 5, 6, 7, 8, 9, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
BUILD SUCCESSFUL (total time: 0 seconds)
domingo, 23 de octubre de 2022
Cola circular. Uso de Queue.
Una cola circular es una estructura de datos que almacena elementos en una lista (en este caso LinkedList) y que permite acceder a los datos por uno de los dos extremos de la lista. Un elemento se inserta en la cola (parte final) y se suprime/elimina por la parte frontal.
Código (colas.java):
package colas;
import java.util.LinkedList;
import java.util.Queue;
public class Colas {
public static void main(String[] args) {
Queue<Integer> cola = new LinkedList<>();
llenar(cola);
desplazar(cola);
}
//llenar cola
private static void llenar(Queue<Integer> cola) {
for (int i = 1; i < 10; i++) {
cola.add(i);
}
}
//correr una posición <-
private static void desplazar(Queue<Integer> cola) {
mostrar(cola);
for (int i = 1; i < 9; i++) {
cola.add(cola.poll());
mostrar(cola);
}
}
private static void mostrar(Queue<Integer> cola) {
System.out.println(cola);
}
}
Resultado:
run:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9, 1]
[3, 4, 5, 6, 7, 8, 9, 1, 2]
[4, 5, 6, 7, 8, 9, 1, 2, 3]
[5, 6, 7, 8, 9, 1, 2, 3, 4]
[6, 7, 8, 9, 1, 2, 3, 4, 5]
[7, 8, 9, 1, 2, 3, 4, 5, 6]
[8, 9, 1, 2, 3, 4, 5, 6, 7]
[9, 1, 2, 3, 4, 5, 6, 7, 8]
BUILD SUCCESSFUL (total time: 0 seconds)
domingo, 16 de octubre de 2022
Mezclar elementos de una lista. Uso de "Collections.shuffle".
package gensudoku;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class GenSudoku {
public static void main(String[] args) {
List<Integer> valores = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
System.out.println("valores no mezclados: " + valores);
Collections.shuffle(valores);
System.out.println("valores si mezclados: " + valores);
}
}
Resultado:
valores no mezclados: [1, 2, 3, 4, 5, 6, 7, 8, 9]
valores si mezclados: [3, 9, 2, 8, 4, 5, 7, 1, 6]