Mostrando entradas con la etiqueta Según. Mostrar todas las entradas
Mostrando entradas con la etiqueta Según. 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 II


Ejercicios de Pseudocódigo con sub-procesos usando PSeInt.




Programa que lee dos matrices y permite operar con ellas sumar , restar y multiplicar.




1 //Algoritmo para operar con matrices.
2
3 SubProceso CrearMatriz(Nombre, Filas por referencia, Columnas por referencia)
4      Escribir "Dime las filas de la " , Nombre;
5      Leer Filas;
6      Escribir "Dime las columnas de la ", Nombre;
7      Leer Columnas;
8 FinSubProceso
9
10 SubProceso LlenarMatriz(Matriz, Filas, Columnas)
11     Definir i,j como entero;
12     Para i<-1 hasta Filas hacer
13           Para j<-1 hasta Columnas hacer
14                  Matriz[i,j] <- azar(10) ;
15           FinPara
16     FinPara
17 FinSubProceso
18
19 SubProceso MostrarMatriz(Matriz,Nombre, Filas, Columnas)
20     Definir i,j como entero;
21     Escribir Nombre;
22     Para i<-1 hasta Filas hacer
23           Para j<-1 hasta Columnas hacer
24                  Escribir Matriz[i,j] , " " Sin Saltar;
25           FinPara
26           Escribir "";
27     FinPara
28 FinSubProceso
29
30 SubProceso SumarMatrices(MatrizR, Matriz1 ,Filas1, Columnas1, Matriz2,Filas2, columnas2)
31     Definir i,j como entero;
32     Si Filas1 <> Filas2 | Columnas1 <> Columnas2 entonces
33           Escribir "Solo se pueden sumar matrices de la misma dimension";
34     Sino
35           Para i<-1 hasta Filas1 hacer
36                  Para j<-1 hasta Columnas1 hacer
37                         MatrizR[i,j] <- Matriz1[i,j] + Matriz2[i,j];
38                  FinPara
39           FinPara
40           MostrarMatriz(MatrizR, "Suma",Filas1,Columnas1);
41     FinSi
42 FinSubProceso
43
44 SubProceso RestarMatrices(MatrizR, Matriz1 ,Filas1, Columnas1, Matriz2,Filas2, columnas2)
45     Definir i,j como entero;
46     Si Filas1 <> Filas2 | Columnas1 <> Columnas2 entonces
47           Escribir "Solo se pueden restar matrices de la misma dimension";
48     Sino
49           Para i<-1 hasta Filas1 hacer
50                  Para j<-1 hasta Columnas1 hacer
51                         MatrizR[i,j] <- Matriz1[i,j] - Matriz2[i,j];
52                  FinPara
53           FinPara
54           MostrarMatriz(MatrizR, "Resta",Filas1,Columnas1);
55     FinSi
56 FinSubProceso
57
58 SubProceso MultiplicarMatrices(MatrizR, Matriz1 ,Filas1, Columnas1, Matriz2,Filas2, columnas2)
59     Definir i,j,x como entero;
60     Si Columnas1 <> Filas2 Entonces
61           Escribir "Solo se pueden multiplicar si el número de columnas de la primera matriz coincida con el número de filas de la segunda";
62     Sino
63           Para i<-1 hasta Filas1 Hacer
64                  para j<-1 hasta Columnas2 Hacer
65                  // Suma i,j es Ain*Bnj
66                         MatrizR[i,j] <- 0;
67                         para x<-1 hasta Columnas1 hacer
68                                MatrizR[i,j] <- MatrizR[i,j] + (Matriz1[i,x] * Matriz2[x,j]);
69                         FinPara
70                  FinPara
71           FinPara
72           MostrarMatriz(matrizR, "Poducto",Filas1, Columnas2);
73     FinSi
74 FinSubProceso
75
76 Proceso OpertarConMatrices
77     //Programa que lee dos matrices y permite operar con ellas
78     // 1 = sumar , 2 = restar , 3 = multiplicar , 4 = Fin
79     Definir FilasA , ColumnasA como entero;
80     Definir FilasB , ColumnasB como entero;
81     Definir MatrizA , MatrizB Como Real;
82
83     CrearMatriz( "Matriz A", FilasA , ColumnasA);
84     Dimension MatrizA[FilasA, ColumnasA];
85     LlenarMatriz(MatrizA, FilasA, ColumnasA);
86     CrearMatriz("Matriz b", FilasB, ColumnasB);
87     Dimension MatrizB[FilasB, ColumnasB];
88     LlenarMatriz(MatrizB , FilasB, ColumnasB);
89     MostrarMatriz(MatrizA, "Matriz A", FilasA , ColumnasA);
90     MostrarMatriz(MatrizB, "Matriz B", FilasB , ColumnasB);
91
92     Definir operacion Como Entero; //1 suma 2 resta 3 producto 4 salir
93     Definir MatrizS, MatrizP como real;
94     Dimension MatrizS[FilasA, ColumnasA];
95     Dimension MatrizP[FilasA, ColumnasB];
96     Repetir
97           Escribir "Dime la operacion a realizar 1 Suma 2 Resta 3 Producto 4 Fin";
98           Leer Operacion;
99           segun Operacion hacer
100          1: //sumar
101          SumarMatrices(MatrizS, MatrizA, FilasA, ColumnasA, MatrizB, FilasB, ColumnasB);
102          2: //Restar
103          RestarMatrices(MatrizS, MatrizA, FilasA, ColumnasA, MatrizB, FilasB, ColumnasB);
104          3: //Producto
105          MultiplicarMatrices(MatrizP, MatrizA, FilasA, ColumnasA, MatrizB, FilasB, ColumnasB);
106    FinSegun
107 Hasta Que operacion = 4
108 FinProceso



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.




1 //Algoritmo calculo dias fin de año
2
3 SubProceso res <- EsBisiesto( a )
4      Definir res como logico;
5      res <- falso;
6      si a % 100 = 0 entonces
7            si a % 400 = 0 entonces //Bisiesto
8                   res <- Verdadero;
9            FinSi
10     sino
11           si a % 4 = 0 entonces //Bisiesto
12                  res <- Verdadero;
13           FinSi
14     FinSi
15 FinSubProceso
16
17 SubProceso res<- DiasMes(m, a)
18     Definir res como entero;
19     Segun M hacer
20           1: Res <- 31;
21           2: si EsBisiesto(a) entonces
22                         res<-29;
23                  sino
24                         res<-28;
25                  FinSi
26           3: Res <- 31;
27           4: Res <- 30;
28           5: Res <- 31;
29           6: Res<- 30;
30           7: Res <- 31;
31           8: Res <- 31;
32           9: Res <- 30;
33           10: Res <- 31;
34           11: Res <- 30;
35           12: Res <- 31;
36     FinSegun
37 FinSubProceso
38
39
40 Proceso DiasFinAnyo
41     //Escribir una programa que calcule y retorne el número de días
42     //que faltan hasta final de año, a partir de una determinada
43     //fecha (dia mes año) introducida por teclado
44     //y teniendo en cuenta si el año es bisiesto.
45     Definir Dia, Mes, Anyo como entero;
46     Escribir "Dime el dia mes año";
47     Leer Dia, Mes , Anyo;
48
49     Definir MaxDias, i como entero;
50     Si esBisiesto(Anyo) entonces
51           maxDias <- 366;
52     Sino
53           maxDias <- 365;
54     FinSi
55     Para i<-1 hasta Mes - 1 Con Paso 1 hacer
56           maxDias <- maxDias - DiasMes(i, Anyo);
57     FinPara
58     maxDias <- MaxDias - Dia;
59
60     Escribir "Para fin de año quedan " , MaxDias, " dias";
61
62
63 FinProceso



Otra opción para el mismo algoritmo.




1 //Algoritmo dias fin de año
2
3 SubProceso res <- EsBisiesto( a )
4      Definir res como logico;
5      res <- falso;
6      si a % 100 = 0 entonces
7            si a % 400 = 0 entonces //Bisiesto
8                   res <- Verdadero;
9            FinSi
10     sino
11           si a % 4 = 0 entonces //Bisiesto
12                  res <- Verdadero;
13           FinSi
14     FinSi
15 FinSubProceso
16
17 SubProceso res<- DiasMes(m, a)
18     Definir res como entero;
19     Segun M hacer
20           1,3,5,7,8,10,12: Res <- 31;
21           2: si EsBisiesto(a) entonces
22                         res<-29;
23                  sino
24                         res<-28;
25                  FinSi
26           4,6,9,11: Res <- 30;
27     FinSegun
28 FinSubProceso
29
30
31 Proceso DiasFinAnyo
32     //Escribir una programa que calcule y retorne el número de días
33     //que faltan hasta final de año, a partir de una determinada
34     //fecha (dia mes año) introducida por teclado
35     //y teniendo en cuenta si el año es bisiesto.
36     Definir Dia, Mes, Anyo como entero;
37     Escribir "Dime el dia mes año";
38     Leer Dia, Mes , Anyo;
39
40     Definir MaxDias, i como entero;
41     Si esBisiesto(Anyo) entonces
42           maxDias <- 366;
43     Sino
44           maxDias <- 365;
45     FinSi
46     Para i<-1 hasta Mes - 1 Con Paso 1 hacer
47           maxDias <- maxDias - DiasMes(i, Anyo);
48     FinPara
49     maxDias <- MaxDias - Dia;
50
51     Escribir "Para fin de año quedan " , MaxDias, " dias";
52
53
54 FinProceso



Un programa que lea una temperatura en grados centígrados o Fahrenheit y la convierta.




1 //Algotirmo conversor de temperaturas
2
3 subProceso res <- CelsiusAFahrenheit(grados)
4      // F = (9 / 5) * C + 32;
5      Definir res como real;
6      res <- ((9/5) * grados) + 32;
7 FinSubProceso

8 subProceso res <- FahrenheitACelsius(grados)
9      // C = ( F - 32 ) * (5 /9)
10     Definir res como real;
11     res <- ( grados - 32) * (5/9);
12 FinSubProceso

13 Proceso ConvertirGradosCelsiusAFahrenheit
14     //Permite convertir entre grados Celsius y Fahrenheit
15     //Leer de consola temperatura y tipo de grado C o F
16     //Calcular le tenperatura en la otra escala
17     Definir Grados, GradosCon como real;
18     Definir Escala Como Caracter; //C o F
19     Escribir "Dime la temperatura a calcular";
20     Leer Grados;
21     Escribir "Dime la escala de los grados introducidos";
22     Escribir "C=Celsius y F=Fahrenheit";
23     Leer Escala;
24     Si Escala = "C" Entonces
25           GradosCon <- CelsiusAFahrenheit(Grados);
26     Sino
27           GradosCon <- FahrenheitACelsius(Grados);
28     FinSi
29     Escribir "Los grados son: ", GradosCon;
30 FinProceso



Calcular cuota hipoteca.




1 //Calculo de la cuota mensual hipoteca.
2
3 SubProceso InteresMensual <- CalcularInteresMensual(InteresAnual)
4      // Usando tantos equivalentes
5      // 1 + interes = ( 1 + InteresMensual)^12;
6      //InteresMensual =((1+Interes)^(1/12)) - 1;
7      //Entradas y salidas en %
8      Definir InteresMensual como real;
9      InteresMensual <- ((1 + (InteresAnual/100))^(1/12))-1;
10     InteresMensual <- InteresMensual * 100;
11 FinSubProceso
12
13 SubProceso CuotaMensual <- CalcularCuotaMensual(Capital, InteresAnual, Plazos)
14     //Couta = (Capital * Interes) /
15     // 100 * (1 - (1+(interes/100))^ - plazo)
16     Definir CuotaMensual como real;
17     Definir A, B, InteresM Como Real;
18     Plazos <- -Plazos;
19     InteresM <- CalcularInteresMensual(InteresAnual);
20     A <- Capital * InteresM;
21     B <- 100 * ( 1 - (1 + (InteresM/100))^(Plazos));
22     CuotaMensual <- A / B;
23 FinSubProceso
24
25 Proceso CalcularCuotaHipoteca
26     //Lee los anos, capital , interes anula en %
27     //Muestra la couta con amortización constante.
28     Definir Anyos Como Entero;
29     Definir Capital, Interes Como Real;
30     Definir Cuota Como Real;
31     Escribir "Introduce Capital";
32     Leer Capital;
33     Escribir "Introduce Interes (%) ";
34     Leer Interes;
35     Escribir "Intrduce Años";
36     Leer Anyos;
37     Cuota <- CalcularCuotaMensual(Capital, Interes, Anyos * 12);
38     Escribir "la Cuota es " , Cuota;
39 FinProceso


Hay unos multicines con 5 salas, y cada sala con 100 personas distribuidas en 20 asientos y 5 filas. Si yo pido entrada para una sala, implementar un programa que me diga si hay sitio en la sala.




//Entradas multicines
2
SubProceso InicializarCine(ElCine)
4      Definir SComo Entero;
5      Para S<-hasta Hacer
6            Para F<-hasta Hacer
7                   Para A<-hasta 20 Hacer
8                          ElCine[S,F,A<- (Azar(2) = 1);
9                   FinPara
10           FinPara
11     FinPara
12 FinSubProceso
13
14 SubProceso MostrarCines(ElCine)
15     Definir SComo Entero;
16     Para S<-hasta Hacer
17           Escribir "Sala : "S;
18           Para F<-hasta Hacer
19                  Para A<-hasta 20 Hacer
20                         Si ElCine[S,F,Aentonces //Verdadero ocupado
21                                Escribir " X " sin saltar;
22                         sino
23                                Escribir " . " sin saltar;
24                         FinSi
25                  FinPara
26                  Escribir "";
27           FinPara
28     FinPara
29 FinSubProceso
30
31 SubProceso Ok <- ReservarEntradas(ElCineSalaCantEntradasLasEntradas)
32     Definir OkSeguirBuscado como logico;
33     Definir EntradasResevadasFcomo entero;
34     EntradasResevadas <-0;
35     F<-1;
36     A<-1;
37     SeguirBuscado<-Verdadero;
38     Mientras SeguirBuscado
39           si ElCine[Sala,F,A] = Falso Entonces
40                  EntradasResevadas <- EntradasResevadas 1;
41                  LasEntradas[EntradasResevadas,]<-Sala;
42                  LasEntradas[EntradasResevadas,]<-F;
43                  LasEntradas[EntradasResevadas,]<-A;
44                  si EntradasResevadas CantEntradas Entonces
45                         SeguirBuscado<-falso;
46                  Sino
47                         A<-A+1;
48                         Si 20 entonces
49                                <- 1;
50                                <- 1;
51                                si entonces
52                                      SeguirBuscado<- Falso;
53                                FinSi
54                         FinSi
55                  FinSi
56           sino
57                  A<-A+1;
58                  Si 20 entonces
59                         <- 1;
60                         <- 1;
61                         si entonces
62                                SeguirBuscado<- Falso;
63                         FinSi
64                  FinSi
65           FinSi
66     finMientras
67     Si Entonces //sala ocupada
68           Ok<-Falso;
69     Sino
70           Ok<-Verdadero;
71     finsi
72 FinSubProceso
73
74 Proceso CinesVariasEntradas
75     //Hay unos multicines con 4 salas,
76     //y cada sala con 100 personas distribuidas
77     //en 20 asientos y 5 filas.
78     //Si yo pido un numeros de entradas para una sala, implementar
79     //un programa que me diga si hay sitio en la sala.
80     //Decir fila y asiento
81     Definir Cines como logico//Verdadero es ocupado
82     Dimension Cines[4,5,20]; // 4 salas, 5 filas , 20 asientos
83     Definir SComo Entero;
84     InicializarCine(Cines);
85     MostrarCines(Cines);
86     Definir SalaNumEntradasEntradas Como Entero;
87     Dimension Entradas[153]; // NumEntada(1)Sala (2)Fila (3)Asiento
88     Definir SeguirBuscado como logico;
89     Repetir
90           Escribir "Dime a que sala queires ir??";
91           Leer Sala;
92           Si Sala <> Entonces
93                  Escribir "Dime cuantas entradas max(15) ?";
94                  Leer NumEntradas;
95                  Borrar Pantalla;
96                  Si ~ReservarEntradas(CinesSalaNumEntradasEntradasEntonces //sala ocupada
97                         Escribir "Sala ocupada ";
98                  Sino
99                         Escribir "Tus Entradas:";
100                 Para S<-Hasta NumEntradas Hacer
101                        Sala <- Entradas[S,];
102                        F<-Entradas[S,];
103                        A<- Entradas[S,];
104                        Cines[Sala,F,A<- Verdadero;
105                        Escribir "Entrada " S" en S:" Sala " F:"F" A:",A;
106                 FinPara
107          FinSi
108          MostrarCines(Cines);
109    FinSi
110 Hasta Que Sala 0
111 FinProceso