Mostrando entradas con la etiqueta recursividad. Mostrar todas las entradas
Mostrando entradas con la etiqueta recursividad. Mostrar todas las entradas

lunes, 1 de abril de 2013

Pseudocódigo Sub Procesos IV


Ejercicios Sub Procesos recursivos con PSeInt:



Cálculo del producto mediante sumas utilizando la recursividad.




1 Subproceso res <- Producto(NumA, NumB)
2      Definir res como real;
3      Si NumB = 0 entonces
4            res <- 0;
5      Sino
6            si NumB > 0 Entonces
7                   res <- NumA + Producto(NumA, NumB - 1);
8            Sino
9                   res <- -NumA + Producto(NumA, NumB + 1);
10           FinSi
11     FinSi
12 FinSubProceso
13 //5 * 3
14 //5 + ( 5 * 2)
15 //5 + 5 + ( 5*1)
16 //5 + 5 + 5
17
18 Proceso ProductoSumando
19     //Calculo del producto mediante suma
20     Definir A, B como real;
21     Escribir "Dime los numeros a multiplicar";
22     Leer A, B;
23     Escribir "El producto de ",A, " * ", B, " es ", Producto(A, B);
24 FinProceso




Programa que permita calcular el elemento N de la serie de Fibonacci:


  • Valores de la serie:
    • 0,1, 1 ,2 ,3 ,5 ,8 ,13 ,21 ,34 ,…
    • Fib(n) = Fib(n-1) + Fib(n-2). El elemento n es la suma de los dos anteriores
    • Fib(0) = 0
    • Fib(1) = 1


1 subproceso res <- Fibonacci(Num)
2      Definir res Como Entero;
3      //Fib(n) = Fib(n-1) + Fib(n-2)
4      //Fib(0) = 0
5      //Fib(1) = 1
6      Segun Num
7            0: Res<-0;
8            1: Res<-1;
9            De Otro Modo:
10                  Res<- Fibonacci(Num-1) + Fibonacci(Num-2);
11     FinSegun
12 FinSubProceso
13
14 Proceso FibonacciRec
15     Definir Numero Como Entero;
16     Escribir "Dime el número para Fibonacci";
17     Leer Numero;
18     Escribir "Fib de ", Numero " es ", Fibonacci(Numero);
19 FinProceso


Programar un algoritmo recursivo que permita invertir un número.

  • Ejemplo: 
    • Entrada: 123 
    • Salida: 321
1 Subproceso res <- Invertir(Numero)
2      Definir res, A, B Como Entero;
3      Definir Multi como entero;
4      si Numero < 10 entonces
5            res <- Numero;
6      Sino
7            A <- (Numero % 10);
8            B <- Numero/10;
9            Multi <- ln(Numero) /ln(10);
10           Escribir "A " , A , " B " , B , " Ceros" , Multi;
11           res <- (A * 10^Multi ) + Invertir(B );
12     FinSi
13 FinSubProceso
14 Proceso InvertirUnNumeroRecursivo
15     //Programar un algoritmo recursivo que permita
16     //invertir un número.
17     /      /Ejemplo:
18     //Entrada: 123 Salida: 321
19     Definir Numero Como Entero;
20     Numero <- 1234567;
21     Escribir Numero ," - " , invertir(Numero);
22 FinProceso
23 // invertir(123)
24 // 3 00 + invertir (12)
25 // 300 + 2 0 + Invertir(1)
26 // 300 + 20 + 1


Torres de hanoi.


1 SubProceso InicioTorres(LasTorres , Altura)
2      Definir I, J como entero;
3      para I <- 2 hasta 3 hacer
4            para J <- 1 hasta Altura hacer
5                   LasTorres[I, J] <- 0;
6            FinPara
7      FinPara
8      para J <- 1 hasta Altura hacer
9            LasTorres[1, J] <- ( Altura - J) + 1 ;
10     FinPara
11 FinSubProceso
12
13 SubProceso VerTorres(LasTorres, Altura)
14     Definir I, J como entero;
15     para J <- Altura hasta 1 Con Paso -1 hacer
16           para I <- 1 hasta 3 hacer
17                  Escribir LasTorres[I, J] ," " Sin Saltar ;
18           FinPara
19           Escribir "";
20     FinPara
21     Escribir "------------------------------";
22 FinSubProceso
23
24 SubProceso Pasar(LasTorres,origen, destino ,Altura)
25     Definir aux, io, id Como Entero;
26     io <- Altura ; //bucar el ultimo cero
27     mientras io > 1 & LasTorres[origen, io ] = 0
28           io <- io - 1;
29     FinMientras
30     id <- Altura + 1;
31     mientras id > 1 & LasTorres[destino, id - 1] = 0
32            id <- id - 1;
33     FinMientras
34     Escribir "pasar de origen ", origen, " destino ", destino;
35     LasTorres[destino, id ] <- LasTorres[origen, io];
36     LasTorres[origen, io]<-0;
37     VerTorres(LasTorres, Altura);
38 FinSubProceso
39
40 SubProceso Hanoi(Alt, LasTorres,origen, auxiliar, destino, Altura)
41     Si Alt = 1 entonces
42           //el disco 1 de pila origen a la pila destino
43           //(insertarlo arriba de la pila destino)
44           Pasar(LasTorres,origen, destino ,Altura);
45     Sino
46           //mover todas las fichas menos la más grande (n)
47           //a la varilla auxiliar
48           hanoi(Alt - 1, LasTorres, origen, destino, auxiliar , altura);
49           //mover la ficha grande hasta la varilla final
50           Pasar(LasTorres,origen, destino ,Altura);
51           //mover todas las fichas restantes,
52           //0...n-1, encima de la ficha grande (n)
53           hanoi(Alt - 1 , LasTorres, auxiliar, origen, destino, altura);
54     FinSi
55 FinSubProceso
56
57
58 Proceso LasTorresDeHanoi
59     Definir Torres , Altura, ori, aux, des como entero;
60     Escribir "Dime la altura";
61     Leer Altura;
62     Dimension Torres[3, Altura];
63     InicioTorres(Torres, Altura);
64     VerTorres(Torres, Altura);
65     ori<-1;
66     aux<-2;
67     des<-3;
68     Hanoi(Altura, Torres ,ori, aux, des, Altura);
69     VerTorres(Torres, Altura);
70 FinProceso



Pseudocódigo Sub Procesos III


Divide y vencerás o recursividad.


Cuando un sub proceso se invoca a si mismo para la realización de alguna tarea se dice que es recursivo. 

En todo sub proceso recursivo debe existir una condición que provoque la terminación de la misma para que no exista una recursividad infinita.


Para resolver un problema con recursividad tenemos que tener al menos un caso base que tenga una solución directa y otro que reduzca el tamaño del problema.


Tipos de recursividad:


  • Directa
    • Un sub proceso se invoca a si mismo.
  • Indirecta
    • Un sub proceso invoca a otro que a su vez invoca al primero.

Ejemplos:


Veamos dos ejemplos de recursividad , el primero es calcular la potencia de un número.
La potencia de x^4 es x * x^3.



1 SubProceso resultado <- Potencia (base, exponente)
2      Si exponente=0 Entonces
3            resultado <- 1;
4      sino
5            resultado <- base*Potencia(base,exponente-1);
6      FinSi
7 FinSubProceso
8
9 Proceso DosALaDiezRecursivo
10     Definir exponente como Entero;
11     Definir base como Entero;
12     Escribir "Ingrese Base";
13     Leer base;
14     Escribir "Ingrese Exponente";
15     Leer exponente;
16     Escribir "El resultado es ",Potencia(base,exponente);
17 FinProceso


El segundo es es calcular el factorial de un número.


El factorial de 10 es 10 * el factorial de 9.



1 SubProceso res <- Factorial(Numero)
2      Definir res Como Entero;
3      si Numero = 0 Entonces
4            res <- 1; //caso fin
5      Sino
6            res <- Numero * Factorial(Numero - 1); //Caso reducción
7      FinSi
8 FinSubProceso
9
10 Proceso FactorialRecursivo
11     Definir Num Como Entero;
12     Escribir "Dime el numero ";
13     Leer Num;
14     Escribir "El factorial de " , Num , " es ", Factorial(Num);
15 FinProceso