Embedded Files
Clase Main
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
import java.util.Scanner;
public class Ejercicio7 {
public static int ingresarEntero(String mensaje, int min, int max) {
Scanner ingreso = new Scanner(System.in);
int dato;
do {
System.out.println(mensaje +" entre "+min +" y "+max);
dato = ingreso.nextInt();
} while (dato < min || dato > max);
return dato;
}
public static String ingresarString(String mensaje){
Scanner ingreso=new Scanner(System.in);
String texto="";
System.out.println(mensaje);
texto= ingreso.nextLine();
return texto;
}
public static void main(String[] args) {
int resp=0, num=0 ,grado=0,op=0;
Lista coleccion=new Lista();
Scanner Entrada= new Scanner(System.in);
do{
System.out.println("1-->Ingresar terminos \n2-->Reemplazar terminos(varios valores)\n3-->reemplazar con un valor determinado\nSeleccione una: ");
op=Entrada.nextInt();
switch(op){
case 1:{
do{
coleccion.agregarNodoAlFinal(new Numero(ingresarString("Ingrese el signo del termino \n Positivo --> +\n Negativo --> -"),
ingresarEntero("Ingrese el termino: ",1,100),
ingresarEntero("Ingrese el grado deltermino ",0,100)));
System.out.println("¿Desea ingresar un termino adicional?");
resp=Entrada.nextInt();
}while(resp!=0);
coleccion.recorreLista();
}
break;
case 2:
coleccion.reemplazo(0.5);
coleccion.reemplazo(1.0);
coleccion.reemplazo(1.5);
coleccion.reemplazo(2.0);
coleccion.reemplazo(2.5);
coleccion.reemplazo(3.0);
coleccion.reemplazo(3.5);
coleccion.reemplazo(4.0);
coleccion.reemplazo(4.5);
coleccion.reemplazo(5.0);
break;
case 3:
coleccion.reemplazo(ingresarEntero("Ingrese un numero ",-100,100));
break;
}
System.out.println("\n¿Desea ingresar otro termino? 1--->Si 0--->No");
resp=Entrada.nextInt();
}while(resp!=0);
System.out.println("\nEl polinomio es: ");
coleccion.recorreLista();
}
}
Clase Lista
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
lase Nodo
Clase Número
Como corre el Programa
import static java.lang.Math.pow;
public class Lista {
Nodo inicio;
Nodo fin;
public void agregarNodoAlFinal(Numero obj){
Nodo nuevo=new Nodo(obj);
Nodo reco1;
Nodo reco2;
if(inicio==null){
inicio=nuevo;
nuevo.setSiguiente(null);
}else{
reco1=inicio;
while(reco1!=null){
reco2=reco1.getSiguiente();
if(nuevo.getNum().getGrado()>=reco1.getNum().getGrado()){
nuevo.setSiguiente(inicio);
inicio=nuevo;
break;
}else{
if(nuevo.getNum().getGrado()nuevo.getNum().getGrado()&&reco2.getNum().getGrado()<=nuevo.getNum().getGrado()){
reco1.setSiguiente(nuevo);
nuevo.setSiguiente(reco2);
break;
}else{
reco1=reco1.getSiguiente();
}
}
}
}
}
}
public void recorreLista(){
Nodo aux=inicio;
while(aux!=null){
if(aux.getNum().getGrado()>=1){
System.out.printf(aux.getNum().getSigno()+aux.getNum().getNum()+"x^"+aux.getNum().getGrado());
aux=aux.getSiguiente();
}else{
System.out.printf(aux.getNum().getSigno()+aux.getNum().getNum());
aux=aux.getSiguiente();
}
}
System.out.println("\n");
}
public void reemplazo(double n){
Nodo aux=inicio;
int r=0;
double exp=0, re=0, base=0, acu=0;
while(aux!=null){
base=(double)aux.getNum().getNum();
exp=(double)aux.getNum().getGrado();
re= pow(n,exp);
if(aux.getNum().getSigno().compareTo("+")==0){
acu=acu+(base*re);
}
if(aux.getNum().getSigno().compareTo("-")==0){
acu=acu-(base*re);
}
aux=aux.getSiguiente();
}
System.out.printf("\nEl resultado del reemplazo de: "+"f("+n+")=");
recorreLista();
System.out.printf("f("+n+")= "+acu);
}
}
public class Nodo {
Numero num;
Nodo Siguiente;
public Nodo(Numero num) {
this.num = num;
}
public Numero getNum() {
return num;
}
public void setNum(Numero num) {
this.num = num;
}
public Nodo getSiguiente() {
return Siguiente;
}
public void setSiguiente(Nodo Siguiente) {
this.Siguiente = Siguiente;
}
}
<span style="font-size: x-large;"><b><span style="font-size: small;"> </span></b></span>
public class Numero {
String signo;
int num;
int grado;
public Numero(String signo, int num, int grado) {
this.signo = signo;
this.num = num;
this.grado = grado;
}
public String getSigno() {
return signo;
}
public void setSigno(String signo) {
this.signo = signo;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public int getGrado() {
return grado;
}
public void setGrado(int grado) {
this.grado = grado;
}
}
Ejercicio 9.1
Escribir un programa que utilice una Pila para comprobar si una determinada frase/palabra
(cadena de caracteres) es un palíndromo. Nota: una palabra o frase es un palíndromo cuando la
lectura directa e indirecta de la misma tiene igual valor: alila, es un palíndromo; cara (arac) no
es un palíndromo.
La palabra se lee con el método readLine() y se almacena en un String; cada carácter
de la palabra leída se inserta en una pila de caracteres. Una vez leída la palabra y construida la
pila, se compara el primer carácter del String con el carácter que se extrae de la pila; si son
iguales, sigue la comparación con el siguiente carácter del String y de la pila; así sucesivamente
hasta que la pila se queda vacía o hay un carácter no coincidente. Al guardar los caracteres de la
palabra en la pila se garantiza que las comparaciones de caracteres se realizan en orden inverso:
primero con último…
Se codifica de nuevo la clase Pila, cambiando el tipo de los elementos a Object. Para ello es
necesario crear para cada carácter (tipo char) una referencia a la clase Character.
import java.io.*;
class PilaLineal
{
private static final int TAMPILA = 79;
private int cima;
private Object [] listaPila;
public PilaLineal()
{
cima = -1;
listaPila = new Object[TAMPILA];
}
public void insertar(Object elemento) throws Exception
{
if (pilaLlena())
{
throw new Exception("Desbordamiento pila");
}
cima++;
listaPila[cima] = elemento;
}
public Object quitar() throws Exception
{
Object aux;
if (pilaVacia())
{
throw new Exception ("Pila vacía, no se puede extraer.");
}
aux = listaPila[cima];
cima--;
return aux;
}
public Object cimaPila() throws Exception
{
if (pilaVacia())
{
throw new Exception ("Pila vacía, no se puede extraer.");
}
return listaPila[cima];
}
public boolean pilaVacia()
{
return cima == -1;
}
public boolean pilaLlena()
{
return cima == TAMPILA-1;
}
public void limpiarPila()
{
cima = -1;
}
}
public class Palindromo
{
public static void main(String [] a)
{
PilaLineal pilaChar;
char ch;
boolean esPal;
String pal;
BufferedReader entrada = new BufferedReader(
new InputStreamReader(System.in));
try {
pilaChar = new PilaLineal(); // crea pila vacía
System.out.print("Teclea la palabra" +
" a verificar si es palíndromo: ");
pal = entrada.readLine();
// se crea la pila con los caracteres de la palabra
for (int i = 0; i < pal.length(); )
{
Character c;
c = new Character(pal.charAt(i++));
pilaChar.insertar(c);
}
// se comprueba si es palíndromo
esPal = true;
for (int j = 0; esPal && !pilaChar.pilaVacia(); )
{
Character c;
c = (Character) pilaChar.quitar();
esPal = pal.charAt(j++) == c.charValue();
}
pilaChar.limpiarPila();
if (esPal)
System.out.println("La palabra " + pal +
" es un palíndromo \n");
else
System.out.println("La palabra " + pal +
" no es un palíndromo \n");
}
catch (Exception er)
{
System.err.println("Excepcion: " + er);
}
}
}
pagina 278 (joyanes)
Page updated
Report abuse