llenar una matriz de f y c que se ingresan por teclado y que los muestre del ultimo al primero

Leer dimensiones de una matriz por teclado, pedir valores y mostrar matriz.

1 Proceso MatrizFC

2  //llenar una matriz de f y c que se ingresan por teclado y que los muestre del ultimo al

primero

3  Definir Filas , Columnas, Matriz como entero;

4  Escribir "Cuantas filas?";

5  Leer Filas;

6  Escribir "Cuantas columnas?";

7  Leer Columnas;

8  Dimension Matriz[Filas, Columnas];

9

10  Definir i, j Como Entero;

11  Para i=1 hasta Filas

12   Para j= 1 hasta Columnas

13    Escribir "Dime valor para F = ", i, " C= ", j;

14    Leer Matriz[i,j];

15  FinPara

16 FinPara

17

18 Escribir "Mostrar matriz";

19

20 Para i=1 hasta Filas

21   Para j= 1 hasta Columnas

22    Escribir Matriz[i,j] , " " Sin Saltar;

23   FinPara

24   Escribir "";

25 FinPara

26

27

28 FinProceso

29

Ordinograma de el ejemplo de calcular los dias que faltan hasta final de año actual

Escribir una programa que calcule y retorne el número de días que faltan hasta final de año, a partir de una determinada fecha (dia, mes, año) introducida por y teniendo en cuenta si el año es bisiesto.

Para responder a un comentario, vamos a poner el ordinograma de un proceso creado con PSeint.

El ejemplo en pseudocódigo esta aquí.

Con PSeInt podemos crear los ordinogramas pulsando el botón "Dibujar diagrama de flujo".

Como este ejercicio usaba sub procesos se crea un DFD para cada sub-proceso.

Proceso Principal:

Sub Proceso EsBisiesto:

Sub Proceso DiasMes:

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

Indice del curso>

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

Siguiente>