Java - Recursividad

 
Vista:
Imágen de perfil de juan
Val: 16
Ha aumentado su posición en 2 puestos en Java (en relación al último mes)
Gráfica de Java

Recursividad

Publicado por juan (13 intervenciones) el 08/06/2019 05:00:38
Hola buenos dias, ando empezando a estudiar java y no se como hacer este ejercicio...alguno que me ayude pofa

Escribir un metodo static String corrector(String s) que toma un string s como parametro y
devuelva otro string resultante de corregir s, de tal manera que si encuentra una ’n’ seguida de una
’b’ o una ’p’, la corrige cambiando la ’n’ por una ’m’.

Por ejemplo:
Si s = ”canpo”, retorna ”campo”.
Si s = ”enbeber”, retorna ”embeber”.
Si s = ”tienda”, retorna ”tienda”.
Si s = ””, retorna ””.

Se pide resolver utilizando recursion.
Se puede dar por hecha la funcion String resto(String str)
que devuelve una cadena igual a str pero sin su primer caracter.

1
2
3
public String resto(String x) {
	return x.substring(1);
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Recursividad

Publicado por Kabuto (1385 intervenciones) el 08/06/2019 14:30:19
Hola.
Te muestro como lo he hecho yo, aunque he decir que no he usado el método resto() que proporciona el enunciado, porque no lo he necesitado la verdad.

Yo los pasos que sigo son:

- Con indexOf("n") busco si la cadena a corregir tiene alguna letra "n".
Si no la tiene, este método devuelve valor -1 y entonces damos por finalizada la correccion.
Si tiene una letra "n", este método me dará la posicion de la primera "n" que encuentre.

- Bien, teniendo esta posicion, divido la cadena en dos partes.
La primera parte es la cadena que hay ANTES de la "n".
La segunda parte es la cadena que hay DESPUES de la "n"

- Si la cadena que hay DESPUES comienza con una "b" o una "p", entonces es que la "n" que habíamos encontrado es incorrecta y ha de cambiarse por una "m".
En este caso, para poder usar la recursividad, lo que hago es retornar la cadena que hay ANTES de la "n", le concateno una "m" (porque corregimos la "n") y además le concateno lo que vaya a devolver una llamada recursiva a nuestro método, pasándole como argumento la cadena que ha sobrado DESPUES de la "n".
Esta llamada recursiva repetirá este proceso una y otra vez hasta que el indexOf("n") devuelva -1, es decir, cuando ya no queden letras "n" por revisar.

- Si la cadena que hay DESPUES no comienza por "b" o "p", el return que hago es igual al del caso anterior, solo que en lugar de concatenar una "m", concateno una "n", ya que no es necesario corregirla.


Te pongo aquí el programa con el main de prueba y el método. El método parece que tiene mucho texto pero en realidad si le quitas los comentarios verás que se queda en solo unas pocas líneas.
En el código doy por hecho que el texto se va a recibir en minúsculas, si quieres contemplar la posibilidad de corregir mayúsculas y minúsculas por igual, puedes intentar hacerlo tú una vez hayas entendido lo de la recursividad, que es lo importante.


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
public class Corrector {
 
	public static void main(String[] args) {
 
		System.out.println(corrector("El inperio esta canbiando su canpamento a otro canpo de batalla"));
 
	}
 
	public static String corrector(String s) {
		//Buscamos alguna n
		int pos = s.indexOf("n");
		if (pos == -1) //No hay n, devolvemos cadena tal cual y se acaba el proceso
			return s;
		else {
			//Separamos principio de cadena hasta la "n"
			String antesN = s.substring(0, pos);
			//Final de la cadena tras la "n"
			String trasN = s.substring(pos+1);
 
			//Comprobamos si tras la "n", hay una "b" o "p"
			if (trasN.startsWith("b") || trasN.startsWith("p")) {//Hay que corregir la "n"
				//Retornamos la parte correcta, la "n" corregida con una "m" y
				//llamamos recursivamente a corrector para que se encargue de
				//revisar lo que queda de la cadena original
				return antesN + "m" + corrector(trasN);
			}
			else { //No hay que corregir nada, la "n" es correcta
				return antesN + "n" + corrector(trasN);
			}
		}
	}
 
}

Y este es el resultado que me sale por consola. Verás que corrige perfectamente todos los errores de la cadena original:
1
El imperio esta cambiando su campamento a otro campo de batalla
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar