Se incorpora mejoras en la función de limpieza y formateo que permite ajustar la calidad y la precisión de la expresión de entrada, eliminando cualquier elemento innecesario y corrigiendo posibles errores de formateo.
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("> Expresión 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 expr) {
expr = expr.trim();
expr = expr.charAt(0) == '-' ? "0-" + expr.substring(1) : expr;
expr = expr.replaceAll("\\(-(\\d)", "(0-$1");
expr = expr.replaceAll("(\\d)\\(", "$1*(");
expr = expr.replaceAll("\\)(\\d)", ")*$1");
expr = expr.replaceAll("([\\+|\\-|\\*|\\/|\\(|\\)|\\^|])", " $1 ");
expr = expr.replaceAll("\\s+", " ");
return "( " + expr + " )";
}
}
Resultado:
run:
> Ingresa expresión algebraica a convertir:
-4(56-3+5)/2-(45+34)+(-23*(-52)6+2)-1
> Expresión en notación Postfija:
0 4 56 3 - 5 + * 2 / - 45 34 + - 0 23 0 52 - * 6 * - 2 + + 1 -
BUILD SUCCESSFUL (total time: 2 seconds)
miércoles, 28 de diciembre de 2022
Conversión de Infijo a Postfijo usando pilas (v.4). Mejorar formato de entrada.
lunes, 26 de diciembre de 2022
Conversión de Infijo a Postfijo usando pilas (v.3). Añadir operador de potencia ^.
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)
sábado, 20 de agosto de 2022
Conversión decimal > binario > boleano
Código (Conversiones.java):
package conversiones;
import java.util.Arrays;
public class Conversiones {
public static void main(String[] args) {
System.out.println("Dec\tBin\tBoolean");
String cod;
boolean[] mCod;
for (int i = 0; i < 16; i++) {
cod = Integer.toBinaryString(i);
while (cod.length() < 4) {
cod = "0" + cod;
}
mCod = new boolean[cod.length()];
for (int j = 0; j < cod.length(); j++) {
mCod[j] = cod.charAt(j) == '1';
}
System.out.println(i + "\t" + cod + "\t" + Arrays.toString(mCod));
}
}
}
Resultado:
run:
Dec Bin Boolean
0 0000 [false, false, false, false]
1 0001 [false, false, false, true]
2 0010 [false, false, true, false]
3 0011 [false, false, true, true]
4 0100 [false, true, false, false]
5 0101 [false, true, false, true]
6 0110 [false, true, true, false]
7 0111 [false, true, true, true]
8 1000 [true, false, false, false]
9 1001 [true, false, false, true]
10 1010 [true, false, true, false]
11 1011 [true, false, true, true]
12 1100 [true, true, false, false]
13 1101 [true, true, false, true]
14 1110 [true, true, true, false]
15 1111 [true, true, true, true]
BUILD SUCCESSFUL (total time: 0 seconds)