Met Programacion PDF

UNIDAD 2 - METODOLOGÍA DE LA PROGRAMACIÓN.
(48 Horas Aprox)
1 HERRAMIENTAS Y ANOTACIONES PARA EL DISEÑO DE ALGORITMOS .............. 3

1.1 DIAGRAMAS DE FLUJO. ............................................................ 3
1.1.1 Diagramas de flujo del sistema. Organigramas ........................... 3
1.1.2 Diagramas de flujo del programa. Ordinogramas. ....................... 4
2 ESTRUCTURA GENERAL DE UN PROGRAMA. .......................................... 6
2.1 La estructura de un programa. .................................................. 6
2.1.1 Estructura de un programa en PASCAL. ................................... 6
2.1.2 Estructura de un programa en C............................................ 7
2.1.3 Estructura de un programa en pseudocódigo............................. 8
2.2 PARTES PRINCIPALES DE UN PROGRAMA. ....................................... 8
2.2.1 Entrada. ....................................................................... 8
2.2.2 Proceso. ....................................................................... 8
2.2.3 Salida. ......................................................................... 8
2.3 CLASIFICACIÓN DE LAS INSTRUCCIONES......................................... 9
2.3.1 De declaración. ............................................................... 9
2.3.2 Primitivas. ..................................................................... 9
2.3.2.1 De entrada ............................................................... 9
2.3.2.2 De asignación ........................................................... 10
2.3.2.3 De salida. ............................................................... 10
2.3.3 De control. ................................................................... 10
2.3.3.1 Alternativas. ............................................................ 10
2.3.3.1.1 Simple (if then)...................................................... 10
2.3.3.1.2 Doble (if then else)................................................ 11
2.3.3.1.3 Múltiple (case of)................................................... 12
2.3.3.2 Repetitivas .............................................................. 13
2.3.3.2.1 Mientras (While)..................................................... 13
2.3.3.2.2 Repetir (Repeat). ................................................... 13
2.3.3.2.3 Para (For). ........................................................... 14
2.3.4 Compuestas. ................................................................. 15
2.3.5 Comentarios. ................................................................. 15
2.4 VARIABLES AUXILIARES DE UN PROGRAMA. .................................... 15
2.4.1 Contadores. .................................................................. 15
2.4.2 Acumuladores. ............................................................... 16
2.4.3 Máximos y Mínimos. ......................................................... 16
2.4.4 Switches. ..................................................................... 16
3 TÉCNICAS DE PROGRAMACIÓN ........................................................ 17
3.1 PROGRAMACIÓN CONVENCIONAL................................................ 17
3.2 PROGRAMACIÓN ESTRUCTURADA. .............................................. 17
3.2.1 EJEMPLOS ESTRUCTURA SECUENCIAL. .................................... 18
3.2.2 EJEMPLOS CON SELECTIVAS. ............................................... 19
3.2.2.1 Estructuras de decisión anidadas. ................................... 20
3.2.2.2 Alternativa Múltiple. .................................................. 22
3.2.3 EJEMPLOS CON ESTRUCTURAS REPETITIVAS. ............................ 24
3.2.3.1 Estructura Mientras (WHILE)......................................... 24
3.2.3.2 Estructura Repetir .................................................... 27
3.2.3.3 Estructura desde/para (FOR) ........................................ 30
3.2.4 Ejemplos estructuras repetitivas anidadas. ............................. 33
3.3 PROGRAMACIÓN MODULAR....................................................... 35
3.3.1 Tamaño de los módulos. .................................................... 35
3.3.2 Implementación de los módulos. .......................................... 36
3.3.2.1 Subprogramas, Procedimientos, Funciones. ........................ 36
3.3.2.1.1 Representación. ..................................................... 37
3.3.2.1.2 Parámetros. .......................................................... 38
3.3.2.1.3 Tipos de Parámetros. ............................................... 38
3.3.2.1.4 Ámbito: Variables locales y globales. ............................ 39
3.3.2.2 Funciones. .............................................................. 40
4 EJERCICIOS PROPUESTOS.............................................................. 50
ALICIA RAMOS. IES ALONSO DE AVELLANEDA.
1 HERRAMIENTAS Y ANOTACIONES PARA EL DISEÑO

DE ALGORITMOS
1.1 DIAGRAMAS DE FLUJO.

Antes de escribir un programa en un lenguaje de programación, podemos expresarlo
gráficamente. Esta expresión gráfica nos ayudará a conocer la información que tenemos y a ordenar el
tratamiento de la misma en pasos que faciliten luego la realización de un programa sin errores y fácil
de entender y modificar. Para estas representaciones básicas utilizaremos unos símbolos sencillos.
1.1.1 Diagramas de flujo del sistema. Organigramas

El organigrama representa la organización global de lo que queremos hacer, es decir, la
información que tenemos, dónde la tenemos y qué queremos hacer con ella. El proceso o tratamiento
se representa sin detallar, pues en el ordinograma se indicará dicho proceso.
La norma para representar organigramas es la siguiente:
- En la parte superior estarán los soportes de entrada, es decir donde está la

información.
- En el centro estará el proceso sin desarrollarlo, y los soportes que funcionan
tanto de entrada como de salida.
- En la parte inferior estarán los soportes de salida, es decir donde estará la
información después del proceso.
Algunos símbolos que utiliza el organigrama son los siguientes:
UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 3

Ejemplos:
1) Organigrama de una aplicación que realiza un listado por impresora de los alumnos
de un centro que están almacenados en un disco llamado ALUMNOS.
2) Organigrama de una aplicación con entrada de datos a través de teclado,

visualización de datos por pantalla y por impresora listado de errores.
Ejemplo 1 Ejemplo 2
ALUMNOS ENT RADA D E DATO S
U.T .
U.T.
LIST AD O DE
LISTADO DE ALUMNOS VISUALIZ ACIÓN
ERRO RES DE DAT OS
(U.T. Unidad de tratamiento)
1.1.2 Diagramas de flujo del programa. Ordinogramas.
Es la representación gráfica del algoritmo. Debe ser amplia y ordenada y no contener errores.
En el ordinograma vendrá reflejado: El principio del proceso, las operaciones que se van a realizar, en
el orden que se haya establecido, y el final del proceso.
• Las normas para la representación de ordinogramas son:

• El comienzo del programa aparece sólo una vez.
• El fin del programa aparece sólo una vez: al final.
• El camino se tomará de principio a fin y de izquierda a derecha si están en el mismo nivel.
• Se debe impedir el cruce entre los distintos caminos. Para ello se utilizan los conectores.
Además de los símbolos anteriores, el ordinograma utiliza los siguientes símbolos:

• Ejercicios: Realizar el organigrama y el ordinograma en estos ejemplos:
1) Calcular el área de un rectángulo cuyos datos base y altura se leen de teclado.

Visualizar el resultado en la pantalla.
2) Calcular la suma de dos cantidades leídas de teclado y visualizarla por pantalla.
Organigramas:
DATOS CAN 1
D AT OS BASE Y
ALTU RA Y CAN 2
PR OCESO
PROCESO
R ESULTADO
RESULTA DO

Ordinogramas:
Ejercicio 1 Ejercicio 2
INICIO INICIO
BASE, ALTURA CAN1,CAN2
AREA=BASE *ALTURA SUMA=CAN1+CAN2
"Àrea: ", AREA "SUMA=", SUMA
FIN FIN
2 ESTRUCTURA GENERAL DE UN PROGRAMA.

Todo programa contiene dos bloques bien diferenciados:
• Bloque de declaraciones: En él se especifican todos los objetos que utiliza el

programa (constantes, variables, tablas, registros, ficheros, etc.) indicando sus
características. Este bloque se encuentra localizado siempre por delante del
comienzo de las acciones.
• Bloque de instrucciones: Constituido por el conjunto de operaciones que se han

de realizar para la obtención de los resultados deseados.
2.1 La estructura de un programa.
2.1.1 Estructura de un programa en PASCAL.
program nombre de programa {cabecera del programa}

uses lista de librerías;
const
definición de constantes;
type
declaración de tipos de datos definidos por el usuario;
var
declaración de variables;

procedure
definiciones de procedimientos;
function
definiciones de funciones;
begin
sentencias; {cuerpo del programa}
end.
Donde:
• nombre de programa : Es el identificador por el que se designa al programa.
• lista de librerías: Aquí se pondrán los nombres de las librerías que utiliza el
programa. Por ejemplo en la librería crt están definidas todas las operaciones
relacionadas con el teclado y la pantalla.
• definición de constantes : Aquí se pondrán aquellos datos que se utilizan en el
programa pero que no alteran su valor en ningún momento.
• declaración de tipos de datos definidos por el usuario : Aquí se definen otros tipos
de datos.
• declaración de variables: Aquí se encuentran las variables del programa, su
identificador y su tipo.
• En definiciones de procedimientos y definiciones de funciones: se definen los
subprogramas que tendrá nuestro programa.
• sentencias : Aquí se pondrán las operaciones que realiza el programa.
2.1.2 Estructura de un programa en C.
/* Estructura de un programa C */
#include ... /*directivas archivos de cabecera */
void main(void) /* función principal main() */

{
/* Declaraciones de variables */
..........
/* Instrucciones de main() */
..........
}
/* Declaraciones de funciones */
void fun1(void) /*cabecera de fun1() */
{
/*cuerpo de fun1()*/
..............
}
void fun2(void) /*cabecera de fun2() */
{
/*cuerpo de fun2()*/
..............
}
• Las directivas las utilizamos para indicar los archivos de cabecera, que contienen las funciones del
lenguaje, que se utilizan en los programas.
• Una función Principal llamada main. Es la función que se ejecuta en primer lugar.
• El código de main()
• Las llamadas a funciones desde main.
• Desarrollo de las funciones declaradas por el usuario.

2.1.3 Estructura de un programa en pseudocódigo.
Programa Nombre de programa

Declaraciones
<declaraciones de variables y constantes>
Inicio
<declaraciones de variables y constantes>
Fin
2.2 PARTES PRINCIPALES DE UN PROGRAMA.

Las partes principales de un programa son:
DECLARACIONES
PROGRAMA
Entrada de datos
INSTRUCCIONES Proceso o algoritmo
Salida de resultados
2.2.1 Entrada.
La constituyen todas las instrucciones que toman los datos de entrada desde un
dispositivo externo y los almacenan en la memoria central para que puedan ser
procesados.
DATOS DE ENTRADA > MEMORIA CENTRAL
2.2.2 Proceso.
Está formado por las instrucciones que modifican los objetos a partir de su estado
inicial (datos de entrada) hasta el estado final (resultados), dejando los objetos que lo
contienen disponibles en la memoria central.
DATOS DE ENTRADA > PROCESO > RESULTADOS
2.2.3 Salida.
Conjunto de instrucciones que toman los datos finales (resultados) de la memoria

central y los envían a los dispositivos externos.
MEMORIA CENTRAL > DATOS DE SALIDA

2.3 CLASIFICACIÓN DE LAS INSTRUCCIONES.

Según la función que desempeñan dentro de un programa, las instrucciones s e clasifican de la
siguiente manera:
2.3.1 De declaración.
Su misión es anunciar la utilización de objetos en un programa indicando qué

identificador, tipo y otras características corresponde a cada uno de ellos. Ejemplos:
En C En seudocódigo
/*constantes*/
#define VERDADERO 1 Declaraciones
#define CIEN 100 Constantes
#define IVA 0.17 VERDADERO = 1
CIEN = 100
/*variables*/ IVA=0.17
char car1, car2, car3; Variables
int m, n; carácter car1, car2, car3
float x, y; enteras m, n
reales x, y
Todo objeto referenciado en un programa debe haber sido previamente definido.
2.3.2 Primitivas.
Son aquellas que ejecuta el procesador de modo inmediato. Pueden ser: de entrada,
de asignación o de salida.
2.3.2.1 De entrada
Su misión consiste en tomar uno o varios datos desde un dispositivo de entrada y
almacenarlos en la memoria central en los objetos cuyos identificadores aparecen en
la propia instrucción.
EN C:
Nombre
scanf("control", campo);
- No es aconsejable utilizar más de un dato por instrucción:

Num
scanf("%s", nombre);
scanf("%d", &Num);

2.3.2.2 De asignación
Nos permite realizar cálculos evaluando una expresión y depositando su valor final en
un objeto o realizar movimientos de datos de un objeto a otro.
EN C:
variable = expresión;
su m a= 0
suma = 0;
suma = suma + 100; su m a= su m a+1 00
contador = contador + 1;
2.3.2.3 De salida.
Su misión consiste en enviar datos a un dispositivo externo, bien tomándolos de
objetos depositados en la memoria central o definidos de alguna forma en la propia
instrucción. Ejemplos en Pascal:
EN C:
printf(Control,campo1,campo2,....);
Cuando se encuentra \n se provoca un salto de línea.
printf("\n Hay %d alumnos \n",nume); "Total sa lario:",

salario
printf("\n Total salario: %f \n",Salario);
2.3.3 De control.
Son instrucciones que realizan la evaluación de expresiones, generalmente lógicas, con

el objetivo de controlar la ejecución de otras instrucciones o alterar el orden de
ejecución normal de otras instrucciones.
2.3.3.1 Alternativas.
Son aquellas que controlan la ejecución de uno o varios bloques de instrucciones,
dependiendo del cumplimiento o no de alguna condición o del valor final de una
expresión. Existen 3 modelos típicos de instrucciones alternativas: alternativa simple,
doble y múltiple.
2.3.3.1.1 Simple (if then).
Controla la ejecución de un conjunto de instrucciones por el cumplimiento o no de una

condición, de tal forma, que si se cumple, se ejecutan; si no se cumple, no se
ejecutan.
En seudocódigo:

Si expresión_lógica entonces
Acción1
Acción2
..........
Fin-si
SI
CONDICION
En C:
NO ACCIONES
Una sola sentencia
if (expresión) sentencia_v;
Varias sentencias
if (expresión)
{
sentencia1;
sentencia2;
.............
sentencian;
}
2.3.3.1.2 Doble (if then else).
Controla la ejecución de dos conjuntos de instrucciones por el cumplimiento o no de

una condición, de tal forma, que si se cumple, se ejecutan las instrucciones del primer
bloque; si no se cumple, se ejecutan las instrucciones del segundo.
NO SI
CONDICION
AC CIO NF ACCIO NV
En seudocódigo:
Si expresión_lógica entonces
Acción_v1
Acción_v2
..........
Si no
Acción_f1
Acción_f2
............
Fin-si
En C:
Una sola sentencia

if (expresión) sentencia_v else sentencia_f;

Varias sentencias
if (expresión)
{
sentencia_v1;
sentencia_v2;
.............
sentencia_vn;
}
else
{
sentencia_f1;
sentencia_f2;
.............
sentencia_fn;
}
2.3.3.1.3 Múltiple (case of).
Controla la ejecución de varios conjuntos de instrucciones por el valor final de una

expresión, de tal forma que cada conjunto de instrucciones está ligado a un posible
valor de la expresión, existiendo un bloque al final que engloba otros posibles valores
no definidos. Se ejecutará el conjunto que se encuentre relacionado con el valor que
resulte de la evaluación de la expresión, de tal forma que si este no aparece se
ejecutará el último.
EXP RESIÓN
VALO R2 VAL OR3 OTROS

VAL OR1
ACCIÓN 1 ACCIÓ N2 ACCIÓN3 AC CIÓN4
EN LENGUAJE C EN SEUDOCÓDIGO
switch (expresión) Según sea (expresión)
{ Valor1:
case constante1: Instrucción1
secuencia de sentencias; Instrucción2
break; ...........
case constante2: Valor2:
secuencia de sentencias; Instrucción1
break; Instrucción2
case constante3: .............
secuencia de sentencias; ............
break; Otros:
. Instrucción1
. Instrucción2
default: ..............
secuencia de sentencias; Fin-según-sea

2.3.3.2 Repetitivas
Son aquellas que controlan la repetición de un conjunto de instrucciones denominado rango
mediante la evaluación de una condición que se realiza cada nueva repetición o por medio de un
contador asociado.
2.3.3.2.1 Mientras (While).
Controla la ejecución del conjunto de instrucciones que configuran su rango, de tal

forma que éstas se ejecutan mientras se cumpla la condición, que será evaluada antes
de cada repetición, es decir, mientras la condición sea CIERTA.
En C:
En seudocódigo:
while (expresión_condición)
Mientras (condición)
Una_sentencia;
sentencia1
sentencia2
while (expresión_condición)
.........
{
Fin-mientras
sentencia(s);
}
NO
CONDICION
SI
ACCION ES
2.3.3.2.2 Repetir (Repeat).
Controla la ejecución del conjunto de instrucciones que configuran su rango, de tal

forma que éstas se ejecutan hasta que se cumpla la condición, que será evaluada
siempre después de cada repetición, es decir, hasta que la condición sea CIERTA. Se
diferencia de la anterior en que las instrucciones se ejecutan al menos una vez.
En seudocódigo: En C:
do
Repetir {
sentencia1 sentencias;

sentencia2 ...........
......... } while (condición);
Mientras (condición)
A CCI ONE S
SI
CO ND ICION
NO
2.3.3.2.3 Para (For).
Controla la ejecución del conjunto de instrucciones que configuran su rango, de tal forma que
éstas se ejecutan un número determinado de veces que queda definido en lo que se denomina la
cabecera del bucle. En ella se define un identificador de variable que va a actuar como contador
asociado y que se denomina variable de control del bucle, definiéndose al mismo tiempo su valor
inicial, su valor final y el incremento que esta variable de control va a adquirir en cada definición.
VC = Variable de control
VI = Valor inicial
VF = Valor final
IN = Incremento
En seudocódigo: En C:
Para VC=VI hasta VF hacer for(inicialización ; condición ; incremento) Una-

sentencia-1; sentencia;
sentencia-2;
.............. for(n = 1 ; n <= 10000 ; n++) ;
sentencia-n
Fin-para for(inicialización ; condición ; incremento)
{
sentencia1;
sentencia2;
sentencia3;
}

VC = VI
SI
VC > V F
NO
ACCIONES
VC = VC + IN
2.3.4 Compuestas.
Una instrucción compuesta es aquella que representa a un conjunto de instrucciones

que están definidas en otra parte. En general son llamadas a subprogramas (funciones,
subrutinas, procedimientos).
2.3.5 Comentarios.
Son frases que se incluyen de forma moderada en el diseño de un algoritmo con

intención de aclarar el cometido o función de un objeto o conjunto de instrucciones.
En pascal se representan por las llaves {}, o por los paréntesis seguidos y precedidos de
un *. Ejemplo:
{Esto es un comentario en Pascal}

(*Esto es otro comentario en Pascal*)
/*Esto es otro comentario en C */
// Esto es otro comentario en C
2.4 VARIABLES AUXILIARES DE UN PROGRAMA.

Son objetos que utiliza un programa y por la función que realizan dentro del mismo toman un
nombre especial, modelizando su funcionamiento debido a su frecuente utilización.
2.4.1 Contadores.
Un contador es un objeto que se utiliza para contar cualquier evento que pueda ocurrir dentro
de un programa. En general suelen contar de forma natural desde 0 y de 1 en 1, aunque se pueden
realizar otros tipos de cuenta necesarios en algunos procesos.
Se utilizan realizando sobre ellos dos operaciones básicas:

• Inicialización: Todo contador se inicializa a 0 si realiza una cuenta natural, o a otro

valor si se desea realizar otro tipo de cuenta.
C1 = 0;
CP = 2;
• Contabilización o incremento: Cada vez que aparece el evento a contar se ha de
incrementar el contador en 1 si se realiza cuenta natural o en otro valor si se realiza
otro tipo de cuenta.
C1 = C1 + 1;
CP = CP + 2;
2.4.2 Acumuladores.
Son objetos que se utilizan en un programa para acumular elementos sucesivos con una misma
operación. En general se utilizan para calcular sumas y productos, sin descartar otros posibles tipos de
acumulación.
Para utilizarlos se realizarán sobre ellos dos operaciones básicas:
• Inicialización: Todo acumulador se inicializa a 0 si realiza sumas y a 1 si realiza

productos.
SUMA = 0;
PRODUC = 1;
• Acumulación: Cuando se hace presente en la memoria el elemento a acumular por la

realización de una lectura o un cálculo, se efectúa la acumulación del mismo por
medio de la asignación:
SUMA = SUMA + CANTIDAD;

PRODUC = PRODUC * NUMERO;
2.4.3 Máximos y Mínimos.
Un máximo es una variable que guarda el máximo valor de un conjunto de valores. El máximo
se inicializa a un valor muy pequeño para que tengamos la seguridad de que el primer valor que se
almacene en esta variable sea el mayor.
Un mínimo es similar al máximo solo que coge el valor más pequeño de una serie de valores. El
mínimo se inicializa a un valor máximo.
2.4.4 Switches.
Son objetos que se utilizan en un programa y sólo pueden tomar dos valores (true y false , 0 y
1) realizando la función de transmitir información de un punto a otro dentro del programa. Se utilizan
iniciándolos con un valor y en los puntos en que corresponda se cambian al valor contrario.

3 TÉCNICAS DE PROGRAMACIÓN
3.1 PROGRAMACIÓN CONVENCIONAL.
Los diagramas de flujo fueron la primera representación gráfica utilizada para el diseño de algoritmos
y programas. Este tipo de herramienta constituye el fundamento de la programación convencional
clásica y es de utilidad para la solución de problemas de pequeña y mediana complejidad. Sin embargo,
para problemas complejos el diseño de algoritmos implica un aumento considerable de la
representación gráfica y una reducción de la legibilidad del algoritmo. Para evitar estos inconvenientes
se utilizan otras técnicas de programación que veremos en los siguientes puntos.
3.2 PROGRAMACIÓN ESTRUCTURADA.

El término programación estructurada se refiere a un conjunto de técnicas que han ido
evolucionando desde los primeros trabajos de Edsgar Dijkstra. Estas técnicas aumentan
considerablemente la productividad del programa reduciendo en elevado grado el tiempo requerido
para escribir, verificar, mantener y depurar los programas. La programación estructurada utiliza un
número limitado de estructuras de programación que minimizan la complejidad de los problemas y por
consiguiente reducen los errores. La programación estructurada hace los programas más fáciles de
escribir, leer y mantener.
La programación estructurada es el conjunto de técnicas que incorporan:
• Diseño descendente (top-down).
Es el proceso mediante el cual un problema se descompone en una serie de niveles o pasos

sucesivos de refinamiento. Se descompone el problema en etapas o estructuras jerárquicas, de modo
que se puede considerar cada estructura desde dos puntos de vista: )qué hace? y )cómo lo hace?.
DISEÑO
TOP
PROBLEMA INICIAL
Primer
refinamiento
SUBPROBLEMA 1 SUBPROB. 2 SUBPROB. 3

DOWN
21 refinamiento
1.1 2 3 1 2 3 1 2 3
..... .... ....
• Recursos abstractos.
Descomponer un programa en términos de recursos abstractos consiste en descomponer una

determinada acción compleja en términos de un número de acciones más simples capaz de ejecutarlas
o constituyan instrucciones de computadora disponible.

• Estructuras básicas.
En mayo de 1966 Böhm y Jacopini demostraron que un programa propio puede ser escrito
utilizando solamente tres tipos de estructuras de control:
- secuenciales
- selectivas
- repetitivas
Un programa se define como propio si cumple las siguientes características:
- Posee un solo punto de entrada y uno de salida o fin para control del programa.
- Existen caminos desde la entrada hasta la salida que se pueden seguir y que pasan por
todas las partes del programa.
- Todas las instrucciones son ejecutables y no existen lazos o bucles infinitos (sin fin).
3.2.1 EJEMPLOS ESTRUCTURA SECUENCIAL.
INICIO
Acción 1 Acción 1
Acción 2
Acción 3
FIN
Acción 2
<
Acción 3
Ordinograma
• Realiza el ordinograma y el seudocódigo de los siguientes ejercicios:
1) Programa que lea un número de teclado, calcule el cuadrado y el cubo y lo visualice.
2) Programa que lea un número expresado en segundos y lo visualice en el equivalente de minutos y

segundos.(Utilizar los operadores / y % que sólo se utilizan con enteros).
c =a / b; c = a % b;
INICIO INICIO
N UMERO N UMERO
C UAD=NU MER O*NU MERO MINU TOS=NU MER O/60
CUB O=CU AD *NU MER O SEGUND OS=N UMERO/60
" Cuadr ado=",C UAD "Min uto s=",MINUTOS

"C ubo=",CUBO "Segun dos=",SE GUN DOS
FIN FIN

1) 2)
Programa CuadradoYCubo; Programa Minutos;
Declaraciones Declaraciones
Enteras numero, cuad, cubo Enteras numero, minutos, segundos
Inicio Inicio
Visualiza(“Teclea un número:”) Visualiza(“Teclea un número:”)
Leer numero Leer(numero)
cuad = numero * numero minutos = numero / 60
cubo = cuad * numero segundos = numero % 60
visualiza(“El cuadrado es : “, cuad) Visualiza (“Los minutos son : “, minutos)
visualiza(“El cubo es : “, cubo) Visualiza (“Los segundos : “, segundos)
Fin Fin.
3.2.2 EJEMPLOS CON SELECTIVAS.
1) Programa que lea un número de teclado y deduzca si es positivo o negativo.
2) Programa que intercambie los valores de dos números enteros leídos de teclado si no están en orden
creciente y no hacer nada si están ordenados.
E JER CIC IO 1 : INIC IO E JE R CIC IO 2: IN ICIO
N U ME R O1 ,
N U ME R O
N U M ER O2
NO SI NO
N U ME R O N U ME R O1 >
> 0 N U M ER O2
SI
N U ME R O ,
N UM ER O ,
"E S NE GA TIVO
"E S P OSITIV O" A U X=N U M ER O1
O CE RO"
N U ME R O1 =N U ME R O2
N U M ER O2 =A UX
FIN
FIN
Programa PositivoNegativo Program Intercambiar

Enteras Numero Enteras Numero1, Numero2, Aux
Inicio Inicio
Visualiza “Teclea el número:” Visualiza “Teclea numero 1:”
Leer Numero Leer Numero1
Si (Numero > 0) entonces Visualiza “Teclea numero 2:”
Visualiza Numero, 'Es positivo' Leer Numero2
Si no Si (Numero1 > Numero2) entonces
Visualiza Numero, 'Es negativo' Aux:=Numero1;
Visualiza 'O bien es cero' Numero1:=Numero2;
Fin_si Numero2:=Aux
Fin. Fin_si
Fin

3.2.2.1 Estructuras de decisión anidadas.

La sentencia que sigue a la palabra then o else puede ser cualquiera, incluso otra sentencia if-
then-else. Cuando una o ambas bifurcaciones de una sentencia if-then-else contienen también una
sentencia if-then-else, se dice que dichas sentencias if están anidadas y al proceso anidamiento.
NO SI
CON D1
NO SI
COND2 ACCIONES1
NO SI
COND3 ACC IONES2
ACCIONES4 ACCIONES3
SI (condición1) entonces
<ACCIONES1>
si no
Si (condición2) entonces
<ACCIONES2>
si no
Si (condición3) entonces
<ACCIONES3>
si no
<ACCIONES4>
Fin_si
Fin_si
Fin_si

1) Programa que lea tres números enteros de teclado y visualice el mayor (los tres números se
suponen distintos).
INICIO
A, B, C
NO SI
A>B
NO SI NO SI
B>C A>C
MAYOR = C MAYOR = B MAYOR = C MAYOR =A
"MAYOR ES =",
MAYOR
FIN
Programa Mayor
Declaraciones
Enteras A, B, C, MAYOR
Inicio
Visualiza “Teclea tres números enteros:”
Leer A,B,C
Si (A > B) entonces
Si (A > C) entonces
MAYOR = A
si no
MAYOR = C
Fin-si
si no
Si (B > C) entonces
MAYOR = B
Si no
MAYOR = C
Fin-si
Fin-si
Visualiza “El número mayor es : “,MAYOR
Fin
2) Programa que lea tres números enteros de teclado y visualice el mayor, el intermedio y el

menor (los tres números se suponen distintos).
INICIO
A, B, C
NO SI
A >B
NO SI NO SI
C >B A >C
MAYOR=C MAYOR=C
MAYOR=B INTER=B INTER=A MAYOR=A
MENOR =A MENOR=B
NO SI NO SI
A >C B> C
INTER=C INTER=A INTER=C INTER=B

MENOR=A MENOR=C MENOR=B MENOR=C
MAYOR,
INTER,
MENOR
FIN
Programa OrdenarTresNumeros Si (C > B) entonces

Declaraciones MAYOR = C
Enteras A, B, C, MAYOR, INTER, MENOR INTER = B
Inicio MENOR = A
Visualiza “Teclea tres números enteros:” Si no
Leer A,B,C MAYOR = B
Si (A > B) entonces Si (A > C) entonces
Si (A > C) entonces INTER = A
MAYOR = A MENOR = C
Si (B > C) entonces Si no
INTER = B INTER = C
MENOR = C MENOR = A
Si no Fin-si
INTER = C Fin-si
MENOR = B Fin-si
Fin-si Visualiza “El número mayor es : “,MAYOR
Si no Visualiza “El intermedio es : “,INTER
MAYOR = C Visualiza “El menor es : “,MENOR
INTER = A Fin
MENOR = B
Fin-si
Si no
3.2.2.2 Alternativa Múltiple.

1) Realiza el ordinograma y la codificación en Pascal para un programa que lea un

número entero de teclado y visualice el día de la semana al que corresponde.
INICIO
NUMERO
NUMERO
5 6 7
1 2 3 4
"LUN ES" "MARTES" "MIERCOLES" "JUEVES" "VIERNES" "SABADO" "DOMINGO"
FIN
Programa Diassemana
Declaraciones
Entera NUMERO
Inicio
Leer NUMERO
Según sea NUMERO
1 : Visualiza “Lunes”
2 : Visualiza “Martes”
3 : Visualiza “Miércoles”
4 : Visualiza “Jueves”
5 : Visualiza “Viernes”
6 : Visualiza “Sábado”
7 : Visualiza ”Domingo”
Otros Visualiza “DÍA NO VALIDO”
Fin-Según-sea
End.
2) Programa que lea dos números enteros de teclado (suponemos que son > 0) y, a continuación, pida
la operación aritmética a realizar con estos dos números (+ , - , *, /), realice la operación pedida y
visualice el resultado. Controlar que la operación tecleada no sea correcta
Programa operaciones '-' : RESUL=N1-N2

Declaraciones Visualiza “RESTA:”, RESUL
Enteras N1, N2, RESUL '*' : RESUL=N1*N2
Caracter OPERA Visualiza “PRODUCTO:”, RESUL
inicio '/' : RESUL=N1 / N2
Leer N1, N2 Visualiza “DIVISIÓN:”, RESUL
Visualiza “Teclea la operación + , - , *, / : “ Otros
Leer OPERA Visualiza “OPERACIÓN INCORRECTA.”
Según sea OPERA Fin-Según_sea
'+' : RESUL=N1+N2 Fin
Visualiza “SUMA:”, RESUL

INICIO
N1, N2
'Teclea +, - ,
* , /'
OPERA
OPERA
/ OTRO
+ - *
'OPERACION
RESUL =N1+N2 RESUL=N1-N2 RESUL=N1*N2 RESUL=N1/N2
INCORRECTA'
'SUMA', 'RESTA', 'PRODUCTO', 'DIVISION',

RESUL RESTA RESUL RESU L
FIN
3.2.3 EJEMPLOS CON ESTRUCTURAS REPETITIVAS.
Es una estructura con una entrada y una salida en la cual se repite una acción un número
determinado o indeterminado de veces, dependiendo en este caso del cumplimiento de una condición.
3.2.3.1 Estructura Mientras (WHILE).

RECUERDA: En esta estructura se repite una acción/es mientras se cumpla la condición
(expresión lógica) que controla el bucle. La característica principal de esta estructura es que la
condición es evaluada siempre antes de cada repetición. Si la condición es verdadera, se ejecuta el
bucle, y si es falsa el control pasa a la sentencia siguiente al bucle.

While condición do
Sentencia-simple;
While condición do
begin NO
acción-1;
CONDICION
acción-2;
................. SI
acción-n
end;
ACCIONES
Ejemplos en Pascal:
1) Programa para leer un número entero de teclado y decir si es primo o no lo es. ( Un número es primo
si sólo es divisible por sí mismo y la unidad; entonces hay que dividirlo entre todos los números
menores que él, hasta el 2 y ver si con alguno da resto 0; en ese caso no es primo.).
INICIO
PRIMO=TRUE
DIVISOR=2
NUME
NO
DIVISOR<NUME
AND PRIMO =TRUE
SI
NO NO SI
NUMERO MOD
PRIMO=TRUE
DIVISOR = 0
SI
NUME, 'NO ES PRIMO' NUME, 'ES PRIMO'

PRIMO=FALSE
FIN
DIVISOR=DIVIDOR+1

programa Primo
declaraciones
enteras Primo, Nume, Divisor
Inicio
Primo=0
Divisor=2
Visualiza “Teclea un nº > 0:'”
Leer Nume
mientras (Divisor < Nume) y (Primo=0)
Si (Nume % Divisor =0) entonces
Primo=1
Fin-si
Divisor=Divisor+1
Fin-mientras
Si (Primo =0)
Entonces Visualiza Nume ,”Es Primo”
Si no Visualiza Nume ,”NO es Primo”
Fin-si
Fin-programa
2) Escribir un programa que encuentre el primer valor N para el cual la siguiente suma exceda a 10000 :
1 + 2 + 3 + 4 + 5 + ......... + N.
INICIO
Programa suma10000
Declaraciones SUMA=0
N=0
N, Suma : integer;
Inicio
Suma=0
N=0
mientras (Suma <= 10000)
N=N+1
Suma=Suma +N SUMA<= NO
Fin-mientras 10000
Visualiza “El valor de N es “, N SI

Fin-programa
'VALOR DE N',
N=N+1
N
SUMA=SUMA+N FIN

3) Leer números enteros de teclado y contar la cantidad de números positivos y negativos leídos. El
programa termina cuando leamos el 0.
INICIO
POSI=0
NEGA=0
Programa contarnumeros
Declaraciones N
Enteras N, Posi, Nega
Inicio
Posi=0
Nega=0
Leer N NO
Mientras (N !=0) N <> 0
Si (N > 0)
entonces Posi=Posi +1
SI
si no Nega=Nega+1 NO SI
'POSITIVOS',POSI
Fin-si N> 0
'NEGATIVOS', NEGA
Leer N
Fin-mientras
Visualiza “Positivos “, Posi NEGA=NEGA + 1 POSI = POSI + 1 FIN
Visualiza “Negativos “, Nega

Fin-programa
3.2.3.2 Estructura Repetir .

RECUERDA: En esta estructura se repite una acción/es mientras se cumpla la condición
(expresión lógica) que controla el bucle, la cual se evalúa después de cada ejecución del mismo. Las
acciones se ejecutan como mínimo una vez, pues la condición se evalua después de ejecutar. El bucle
termina cuando la condición no se cumple.
Repetir
acción-1
acción-2
ACCIONES
..................
acción-n
Mientras condición SI
CONDICION
NO

- Ejemplos cortos. {Lectura de datos hasta teclear 'N' en respuesta}

Calcula la edad media de los alumnos.
leer nºs de teclado hasta leer el 100 Visualiza “ Leer Nombre y Edad de alumnos “
respuesta='s'
Repetir suma=0
Visualiza “Teclea número : “ contador=0
Leer numero Repetir
Mientras (numero != 100) Visualiza “Teclea el Nombre : “
Leer (nombre);
Visualiza “Teclea la Edad : “
Visualiza potencias de 2 hasta que sea > 100 Leer edad
Visualiza “ Potencias de dos “ suma=suma+edad
potencia=1 contador=contador+1
Repetir Visualiza “Teclea N para terminar “
Visualiza potencia Leer respuesta
potencia = potencia * 2 Mientras (respuesta!='n') y (respuesta !='N')
mientras (potencia <= 100) media=suma/contador
Visualiza “Edad media = “, media
1) Realizar un programa para obtener la suma de la serie 1 + 1/2 + 1/3 + ... + 1/N hasta que la suma
sea mayor de 3. Visualiza el valor de N.
INICIO
programa sumaserie
Declaraciones S UMA=0
Enteras N N=0
Real Suma
Inicio
N=0
Suma=0
repetir
N=N+1 N=N +1
Suma =Suma + 1/N SUM A=SU MA +1/N
Mientras (Suma <= 3)

Visualiza “Suma “, Suma
Visualiza “N vale “, N
Fin-Programa SI
S UMA
<= 3
SI
SU MA,
N
F IN

2) Hacer un entrada de datos de alumnos pidiendo por teclado los datos: NOMBRE, CURSO y SEXO;
validando el curso con un valor de 1 a 3, y el sexo con los valores "H" o "M". El proceso terminará
cuando se responda ‘N’ o ‘n’ a la pregunta: “¿Quieres teclear más datos?.” . Visualizar el nº de
hombres y el nº de mujeres tecleados.
IN ICIO
C H=0
Programa Datosalumnos CM =0
Declaraciones
Enteras CURSO, CH, CM
Carácter SEXO, MAS
Cadena NOMBRE NOMBR E
Inicio
CH=0. CM=0
repetir
Visualiza “Teclea Nombre.” SEXO
Leer NOMBRE
Repetir
Visualiza “Teclea Sexo.” SI
Leer SEXO SE XO!='H ' y

SE XO!='M'
Mientras (SEXO != 'H') y (SEXO != 'M')

Repetir
NO
Visualiza “Teclea Curso.”

Leer CURSO C UR SO
Mientras (CURSO<1) o (CURSO>3)

Si (SEXO='M' ) entonces
CM=CM+1 SI
Si no CU RSO<1 o
CU RSO >3
CH=CH+1
Fin si NO
Visualiza “¿Quieres teclear más datos?.” NO SI
Leer MAS
S EXO='H'
Mientras (MAS!='N') y (MAS!='n')

Fin CM=C M+1 C H=CH +1
MAS
NO SI
MAS ='N' CH , CM FIN

3.2.3.3 Estructura desde/para (FOR)

RECUERDA: utilizamos esta estructura cuando sabemose el número de veces que vamos a
ejecutar un grupo de instrucciones. Utiliza una variable de control que debe inicializarse y dentro del
bucle se va incrementando o decrementando.
Ejemplos en seudocódigo:
Para a =1 hasta 10 hacer Visualiza “ Leer 10 números y sumarlos “

Visualiza a suma=0
Fin-para Para i=1 hasta 10 hacer
Visualiza “Teclea el número “, i ,” : “
Para caracter ='a' hasta 'z' hacer Leer numero
Visualiza caracter suma=suma+numero
Fin-para Fin-para
Visualiza “La suma es : “,suma
suma:=0;
Para i=1 hasta 100 hacer
suma=suma+i
Fin-para
• Realiza el ordinograma y el seudocódigo para los siguientes ejercicios:
1) Escribir un programa que calcule la suma : 1 + 1/2 + 1/3 + 1/4 + .... + 1/N, donde N se debe leer de
teclado, comprobar que n sea distinto de 0 para realizar la suma.
IN ICIO
Programa Sumaserie N
Declaraciones
Enteras I, N
Real SUM NO
Inicio N <> 0 'N ES 0 '
Visualiza “Teclea Número.”

Leer N
SI
Si (N <> 0) entonces
SUM=0
S UM = 0
Para I=1 hasta N hacer

SUM = SUM + (1 / I) I= 1 FIN
Fin-para
Visualiza “LA SUMA ES:”, SUM
Si no
Visualiza ” el valor de N es 0”
Fin-si
NO
'S UM A' ,
I <= N
S UM A
Fin
SI
SU M = SU M + 1 / I
I =I + 1

2) Escribir un programa para leer el nombre, la edad y el curso de los 100 alumnos de un centro y
visualizar : la edad media , el número de alumnos de 2º curso y la edad media de los alumnos de 3º
curso.
INICIO
AE=C=0
AE3=C3=C2=0
programa Alumnos
Declaraciones
Enteras I, AE, C, AE3, C3, C2 , CUR, EDAD I=1
Cadena NOM
Real M, M3
Inicio
AE=0, C=0 NO
AE3=0, C3=0, C2=0 I <= 100
M = AE / C
M3 = AE3 /C3
Para I=1 hasta 100 hacer
Leer NOM, EDAD, CUR SI
AE=AE+EDAD
C=C+1 NOM, EDAD,
CUR
M, M3, C2
Si (CUR = 2) entonces
C2=C2+1
Fin-si FIN
Si (CUR = 3) entonces AE=AE+EDAD
C=C+1
C3=C3+1
AE3=AE3+EDAD
Fin-si
SI
Fin-para CUR = 2 C2 = C2 + 1
M = AE/C
M3=AE3/C3
NOI
Visualiza “Edad Media:”, M

Visualiza “Media de los de 3º:”, M3
Visualiza “ALUMNOS de 2º:”, C2 SI
C3 = C3 +1
Fin. CUR = 3
AE3=AE3+EDAD
NO
I=I+1

3) Realiza un programa que lea 10 números enteros de teclado y visualize el mayor y el menor de los
números leídos.
INIC IO
programa MaximoMinimo MAX =-9 999

MIN =999 9
Declaraciones
Enteras I, MAX, MIN, N
Inicio
MAX =-9999 I= 1
MIN= 9999
Para I:=1 hasta 10 hacer
Leer N
Si (N > MAX) entonces
MAX = N
Fin-si
NO
I <=1 0 MAX , MIN FI N
Si (N < MIN) entonces
MIN = N SI
Fin-si
Fin-para N
Visualiza “Maximo: “, MAX, “ Mínimo: “, MIN

Fin
N > MA X MA X = N
SI
NO
SI
N < MIN MIN = N
NO
I =I+ 1
RECUERDA: Para poder calcular el máximo y el mínimo necesitamos dos variables auxiliares que irán
guardando estos valores. Cada número tecleado se comparará con estas variables. Si el número
tecleado es mayor que el máximo entonces el nuevo máximo será ahora el valor tecleado. Si el número
tecleado es menor que el mínimo entonces el nuevo mínimo será ahora el valor tecleado.

3.2.4 Ejemplos estructuras repetitivas anidadas.
Ejemplo 1 : Leer las temperaturas horarias de cada uno de los días del año en Guadalajara:
INICIO
DIAS = 1
programa Temperaturas
Declaraciones
Enteras Días, Horas, Temperatura NO
DIAS <=
Inicio 365
FIN
Días=1
Mientras (Días<= 365) SI
Horas=1
Mientras (Horas <= 24) HORAS = 1
Leer Temperatura
Horas = Horas+1
Fin-mientras
Días=Dias+1
Fin-mientras
NO
HORAS
Fin. <= 24
SI
TEMPERATURA
HORAS=HORAS+1
DIAS = DIAS + 1

Ejemplo 2: Leer las 5 asignaturas y notas en cada una de las tres evaluaciones de un alumno, y calcular
la nota de cada evaluación:
INICIO
EVAL = 1
programa Evaluaciones
Declaraciones
Integer EVAL, Sum, nota, I NO
Real NotaEva EVAL <= 3 FIN
Cadena asignatura
Inicio SI
Para EVAL = 1 hasta 3 hacer
Sum:=0;
Para I = 1 hasta 5 hacer
SUM=0
Leer asignatura
Leer nota I =1
Sum=Sum+nota
Fin-para
NotaEva=Sum/3
Visualiza(Eval,' Evaluación = ', NotaEva) NO
Fin-para
Fin I <= 5
SI
ASIGNATURA,
NOTA
NOTAEVA=SUM/3
SUM = SUM+NOTA
EVAL ,
NOTAEVA
I= I+ 1
EVAL = EVAL+1

3.3 PROGRAMACIÓN MODULAR.

En programación modular el programa se divide en módulos (partes independientes), cada una
de las cuales ejecuta una actividad o tarea y se codifican independientemente de otros módulos. Cada
uno de estos módulos se analizan, codifican y ponen a punto por separado.
Cada programa contiene un módulo que se llama programa principal que controla todo lo que
sucede; se transfiere el control a submódulos (subprogramas) , de modo que ellos puedan ejecutar sus
funciones; sin embargo cada submódulo devuelve el control al programa principal cuando se haya
completado su tarea. Si la tarea asignada a cada submódulo es demasiado compleja, éste deberá
romperse en otros módulos más pequeños. Dado que los módulos son independientes, diferentes
programadores pueden trabajar simultáneamente en diferentes partes del mismo programa.
RAÍZ
MOD.1 MOD. 2 MOD. 3 MOD. 4
MOD11
MOD 2.1 MOD 2.2 MOD 3.1 MOD4.2 MOD 4.1
3.3.1 Tamaño de los módulos.
Aunque no exista una regla fija que permita definir el tamaño estándar del módulo, una buena
aproximación es considerar módulos del tamaño físico de una página ( 30 o 40 líneas de instrucciones).
• Ejemplo:
Se desea diseñar un algoritmo que realice las siguientes tareas:

- Impresión de cabeceras de un informe.
- Lectura de datos.
- Ejecutar cálculos.
- Imprimir líneas detalladas de información.
- Imprimir totales.
Este programa se puede descomponer en módulos de modo que exista un módulo

principal o de control y diferentes submódulos:
Módulo Principal :
Llamada a submódulo "Impresion de cabeceras"
Llamada a submódulo "Proceso de datos"
Llamada a submódulo "Impresion de totales"
Fin de proceso.
Submódulo Impresión de cabeceras :

Instrucciones para impresión de cabeceras.
Retorno al módulo principal.
Submódulo Proceso de datos :

Lectura de datos.
Ejecución de cálculos.
Impresión detallada de líneas.
Submódulo Impresión de totales :

Instrucciones para impresión de totales.
• Representación gráfica:
Módulo
Principal
Módulo de Módulo de Módulo de

impresión de proceso de impresión
cabeceras datos de totales
3.3.2 Implementación de los módulos.
La programación modular se implanta utilizando módulos que toman diferentes nombres según
el lenguaje de programación: subprogramas, procedimientos, funciones.
3.3.2.1 Subprogramas, Procedimientos, Funciones.
Un subprograma es un programa dentro de otro. Tiene los mismos componentes que un

programa y se ejecuta cuando lo ordena el programa principal.
Se considera subprograma interno a aquél que está junto al programa principal de nuestro
trabajo, y se llama externo al que no lo está.
Un procedimiento es un subprograma que realiza una tarea específica. Puede recibir 0 o más
valores del programa que llama y devolver cero o más valores a dicho programa llamador. Un
procedimiento está compuesto de un grupo de sentencias a las que se asigna un nombre (identificador)
y constituye una unidad de programa. La tarea asignada al procedimiento se ejecuta siempre que se
encuentre el nombre del procedimiento.
Los procedimientos deben estar declarados antes de que puedan ser referenciados en el
cuerpo del programa.
Una función es un subprograma que devuelve un único resultado al programa o subprograma

que le llamó, pero puede recibir 0 o más valores del programa que llama.

3.3.2.1.1 Representación.
• En el ordinograma del programa principal se representaría la llamada al subprograma

como:
SUBPROGRAMA
(Parámetros)
donde SUBPROGRAMA tendría aparte un ordinograma normal, con inicio, instrucciones de su

algoritmo y fin.
• En seudocódigo declaramos un procedimiento de la siguiente forma:
FORMATO 1: Sin parámetros FORMATO 2: Con parámetros
Procedimiento nombreproc Procedimiento nombreproc(lista de parámetros formales)

Declaraciones de variables locales Declaraciones de variables locales
Inicio Inicio
cuerpo del procedimiento cuerpo del procedimiento
Fin-procedimiento Fin-procedimiento
lista de parámetros formales : Sirven para pasar información al

procedimiento y/o devolver
información del procedimiento a la
unidad de programa que le invoca;
tiene el formato: param1: tipo1 ;
param2: tipo2; ....
• La llamada para que se ejecute el procedimiento:
FORMATO 1 : FORMATO 2 :
nombreproc nombreproc(lista parámetros actuales)
EJEMPLO:
Programa Mensaje
Procedimiento Asteriscos {Procedimiento que pinta asteriscos}

Inicio
Visualiza “ *************** “
Fin-procedimiento

Inicio {Programa Principal}

Asteriscos {llama a Asteriscos }
Visualiza “Hola”
Asteriscos
Fin
{La salida será : *************** Hola *************** }
INICIO
INICIO
AS TERISCOS
ASTERISCOS
"Hola" " ****** ******* ** "
AS TERISCOS Fin ASTERISCOS
Fin
3.3.2.1.2 Parámetros.
Los subprogramas nos permiten realizar varias veces una serie de acciones; estas acciones
pueden ser ejecutadas siempre sobre los mismos o diferentes datos. Para que un subprograma pueda
utilizar diferentes variables, se utilizan los parámetros.
3.3.2.1.3 Tipos de Parámetros.
Se define como parámetro toda variable que se intercambia entre el programa y el

subprograma. Existen dos tipos de parámetros:
• Parámetros por valor : Son aquellos que da el programa para proporcionar

información al subprograma, y cuyo valor no será modificado por el
subprograma.
• Parámetros por referencia : Son aquellos que van a ser modificados por el
subprograma y su valor modificado va a ser devuelto al programa. Para
distinguirlos de los pasados por valor, se les colocará delante, en la
declaración del subprograma la palabra VAR.

EJEMPLO 1 : El procedimiento Asteriscos dibuja el nº de asteriscos indicado en el

parámetro N:
Procedimiento Asteriscos( Entera N) {Procedimiento que pinta N asteriscos}

Declaraciones
Entera I
Inicio
Visualiza('*')
Fin-para
Fin-procedimiento
Diferentes llamadas al procedimiento son:
Asteriscos(5) Dibuja 5 asteriscos

Asteriscos(2*4 - X) Si X=6 Dibuja 2 asteriscos
3.3.2.1.4 Ámbito: Variables locales y globales.
Una variable local es aquella que está declarada y definida dentro de un subprograma, y es
distinta de las variables con el mismo nombre declaradas en cualquier parte del programa principal.
Una variable global es aquella que está declarada para el programa o algoritmo completo.
Programa Ejemplovariables
Declaraciones
Cadena a , b , c {a, b, c, i, j son variables globales, las puede usar cq procedimiento}
Enteras i , j
Procedimiento SUBPROGRAMA1
Declaraciones { a, b, i son variables locales al procedimiento, cualquier modificación de estas }
{ variables no afecta a las variables globales}
Cadena a , b
Enteras i
Inicio
{Instrucciones}
Fin-procedimiento
Procedimiento SUBPROGRAMA2
Declaraciones { a, c, i , j son variables locales al procedimiento}
Cadena a , c
Enteras i , j
Inicio
{Instrucciones}
Fin-procedimiento
Inicio {PROGRAMA PRINCIPAL}

SUBPROGRAMA1
SUBPROGRAMA2
Fin.

3.3.2.2 Funciones.
Cuando un subprograma sólo devuelve un valor, se le puede considerar dentro de una variedad
de subprogramas denominados funciones, y que se declaran de la siguiente forma:
Tipo-dato Función nombrefuncion (parámetros)

{declaraciones locales}
Inicio
<Cuerpo de la función>
Retorna valor
Fin-Función
y cuya llamada se realiza de la siguiente forma :
varF = nombrefuncion(var1, var2, .....)
Donde varF es del tipo devuelto por la función.
EJEMPLO: Función que calcula y devuelva la media de 2

cantidades leídas de teclado.
PROGRAMA calcularmedia
VAR
Enteras n1, n2
Real resul
Real Funcion media( enteras x , y )

Inicio
media = (x + y) / 2
Fin-Función
INICIO {Programa Principal}

Leer n1, n2
resul = media(n1, n2) { Llamada a la función}
Visualiza “La Media es: “, resul
Fin.

EJERCICIO: Realizar el ordinograma y el seudocódigo para un programa en el que aparezca el siguiente

menú:
** MENÚ DE OPCIONES **
1 - NUMEROS PRIMOS.
2 - DIBUJO.
3 - TABLA DE MULTIPLICAR.
4 - FIN.
Teclea opción:
- Opción 1: Programa que calcule e imprima los N primeros números primos. N es un valor entero
que se leerá de teclado. Deberá ser > 0.
- Opción 2: Utilizando bucles anidados realiza un programa que visualize este triángulo tantas veces
como indique N, un valor entero leído de teclado. Por ejemplo si N = 6, la salida será:
$
$$
$$$
$$$$ Validar la entrada de N de 1 a 20.
$$$$$
$$$$$$
- Opción 3: Realiza un programa que lea un número entero de teclado y visualize la tabla de
multiplicar. Por ejemplo tecleo 5 la salida será:
5*1=5
5 * 2 = 10
5 * 3 = 15
.......
5 * 10 = 50
TENIENDO EN CUENTA QUE:
- Cada uno de estos ejercicios será un procedimiento.

- El programa principal se encargará de llamar a cada procedimiento.

PROGRAMA PRINCIPAL
INI CIO
PINTARMENU
O PCIO N
O PCIO N
1 2 3
P RIMOS DIB UJO TAB LAMULT
SI O PCIO N
!= 4
NO
FIN

INICIO
PRIMOS
SUBPROGRAMA SUBPROGRAMA
PINTARMENU '**CALCULAR PRIMOS
PRIMOS**'
INICIO
PINTARMENU
'**MENU DE OPCIONE S**'

'1. NUMEROS PRIMOS.'
'2. DIBUJO.'
'3. TAB LA DE MULT.'
'4.FIN' 'NUMEROS
PRIMOS SON:'
Teclea opción:
FIN
I=1
PINTARMENU
NO
FIN
I <= N TECLA
PRIMOS
SI
PRIMO=
VERPRIMO(I)
SI
P RIMO
=1
NO
I, 'ES PRIMO'
I = I +1

INICIO
FUNCION VERPRIMO
VERPRIMO:
PRI = 1
DIVISOR = 2
DIVISOR < X NO
FIN
y RETORNA PRI
VERPRIMO
PRI = 1
SI
SI
X % DIVISOR
=0
PRI = 0
NO
DIVISOR = DIVISOR + 1
INICIO
TECLA
SUBPROGRAMA 'Pulsa una tecla'
TECLA:
C
FIN
TECLA

INICIO
TABLAMULT
SUBPROGRAMA
TABLAMULT:
'TABLA DE
MULTIPLICAR'
'************** ****'
I =1
NO
I <= 10
SI
PRODUC = I * N '******** **********'
N,'*',I,'=',
TECLA
PRODUC
FIN
I =I + 1 TABLAMULT


INICIO
DIBUJO
SUBPROGRAMA
'*DIBUJO DE DIBUJO
TRIANGULO*'
SI
N <1
0 N>20
NO
I =1
NO FIN
I <= N TECLA DIBUJO
SI
J =1
NO
J <= I
SI
'$'
J =J +1
Salto de
I = I +1
línea

{PROGRAMA QUE PINTA UN MENÚ DE EJERCICIOS }

ProgramA Menú
Declaraciones
Enteras opcion
Inicio
Repetir
PintarMenu
Leer opcion
Según sea opción
1 : Primos
2 : Dibujo
3 : TablaMult
Fin-según-sea
Mientras (opción != 4)
Fin.
{Fin de programa}
***********************************************************************
{PINTA EL MENÚ EN LA PANTALLA}
Procedimiento Pintarmenu
Inicio
{Borrar pantalla}
Visualiza ” **MENÚ DE OPCIONES** “
Visualiza “1. NUMEROS PRIMOS.”
Visualiza “2. DIBUJO.”
Visualiza “3. TABLA DE MULTIPLICAR.”
Visualiza “4. FIN.”
Visualiza “ Teclea opción: “
Fin-Procedimiento-Pintarmenu
{FUNCIÓN QUE COMPRUEBA SI UN NUMERO ES PRIMO O NO}

{RECIBE EL NUMERO Y DEVUELVE TRUE SI LO ES, FALSE SI NO LO ES}
Entero Función Verprimo(Entero X )
Declaraciones
Entero PRI, DIVISOR
Inicio
PR= 1
DIVISOR=2
mientras (DIVISOR < X) y (PRI=1) hacer
Si (X % DIVISOR) =0 entonces
PRI=0
Fin-si
DIVISOR:= DIVISOR+1
Fin-mientras
Retorna PRI
Fin-Función-Verprimo
{Pulsar tecla antes de volver al programa principal}

Procedimiento Tecla
Declaraciones
Carácter c
Inicio
Visualiza “Pulsa una tecla para volver...”
Leer c
Fin- Procedimiento-Tecla

{OPCIÓN PRIMERA DEL MENÚ - VISUALIZAR LOS NUMEROS PRIMOS HASTA N}

Procedimiento Primos
Declaraciones
Enteras N, I, PRIMO
Caracter c
Inicio
Borrar la pantalla
Visualiza “**CALCULAR PRIMOS HASTA UN N1 LEIDO DE TECLADO**”
Visualiza “Teclea un nº:”
Leer N
Visualiza “Los números primos hasta “, N ,” son los siguientes:”
PRIMO=Verprimo(I)
Si (PRIMO = 1) entonces
Visualiza I, “ Es primo.”
Fin-si
Fin-Para
Tecla
Fin- Procedimiento-Primos
{OPCIÓN SEGUNDA DEL MENÚ - VISUALIZAR UN TRIÁNGULO}

Procedimiento Dibujo
Declaraciones
Enteras N, I, J
Inicio
Borrar pantalla
Visualiza “**DIBUJO DE UN TRIÁNGULO**”
Repetir
Visualiza “Teclea un n1 entre 1 y 20 : “
Leer N
Mientras (N<1) o (N>0)
Para J=1 hasta I hacer
Visualiza ‘$’
Fin-Para
Visualiza {salto de línea}
Fin-Para
Tecla
Fin- Procedimiento-Dibujo
{OPCIÓN TERCERA DEL MENÚ - VISUALIZAR TABLA DE MULTIPLICAR}

Procedimiento TablaMult
Declaraciones
Enteras N, I, PRODUC
Inicio
Borrar pantalla
Visualiza “**TABLA DE MULTIPLICAR**”
Visualiza “Teclea un nº : “
Leer N
Visualiza “**************************'”
Para I=1 hasta 10 hacer
PRODUC = I * N
Visualiza N ,' * ' , I , ' = ', PRODUC
Fin-Para
Visualiza “*************************”
Tecla
Fin- Procedimiento-TablaMulti

4 EJERCICIOS PROPUESTOS.
1) Escribir un programa que determine si un año leído de teclado es bisiesto. Un año es bisiesto si es múltiplo de 4
(por ejemplo 1996). Los años múltiplos de 100 no son bisiestos, salvo si ellos son también múltiplos de 400 (2000 es
bisiesto, 1800 no lo es).
2) Escribir un programa que calcule la suma de los 100 primeros términos de esta serie :
1/2 + 2/22 + 3/23 + 4/24 + .... + 100/2100 .
3) Calcular el factorial de un número N leido de teclado.
4) Calcular el factorial de N números leídos de teclado. N se leerá de teclado.
5) Escribe un programa que visualize el número más grande, el más pequeño y la media de una serie de N números
leídos de teclado. N se leerá al principio y debe ser > 0 para realizar el proceso.
6) Diseñar una función que calcule potencias de la forma XN y un programa que haga uso de la misma, para
distintos valores X y N. X y N se leerán de teclado. N debe ser > 0
XN = X * X * X * X *..... * X N Veces
7) El valor de ex se puede aproximar por la suma : 1+ x + x2/2! + x3/3! + .... + xn/N!. Escribe un programa que
tome el valor de x como entrada y visualice la suma para N = 10.
8) Programa que calcule el número de combinaciones de M elementos tomados de N en N. (M y N deben ser > 0).
No existen factoriales de números negativos. El Factorial de 0 es 1.
9) Realiza un programa que imprima este rombo:
;;;;;-;;;;;
;;;;---;;;;
;;;-----;;; Los caracteres del rombo ( ; - ) se
;;-------;; pedirán por teclado.
;---------;
-----------
;---------;
;;-------;;
;;;-----;;;
;;;;---;;;;
;;;;;-;;;;;
10) Realizar un programa que dibuje un tablero de ajedrez.
11) Realiza un programa que escriba los N primeros números de la sucesión de Fibonacci:
n 0=0 n 4=n 2+n 3 =3

n 1=1 n 5=n 3+n 4 =2+3=5 0, 1, 1, 2, 3, 5, 8 .....
n 2=n 0+n 1 =1 n 6=n 4+n 5 =3+5=8 ....
n 3=n 1+n 2 =2

Met Programacion PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Met Programacion PDF

Uploaded by

Copyright:

Available Formats

UNIDAD 2 - METODOLOGÍA DE LA PROGRAMACIÓN.

(48 Horas Aprox)

1 HERRAMIENTAS Y ANOTACIONES PARA EL DISEÑO DE ALGORITMOS .............. 3

1 HERRAMIENTAS Y ANOTACIONES PARA EL DISEÑO

1.1 DIAGRAMAS DE FLUJO.

1.1.1 Diagramas de flujo del sistema. Organigramas

La norma para representar organigramas es la siguiente:

- En la parte superior estarán los soportes de entrada, es decir donde está la

Algunos símbolos que utiliza el organigrama son los siguientes:

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 3

2) Organigrama de una aplicación con entrada de datos a través de teclado,

ALUMNOS ENT RADA D E DATO S

(U.T. Unidad de tratamiento)

1.1.2 Diagramas de flujo del programa. Ordinogramas.

• Las normas para la representación de ordinogramas son:

Además de los símbolos anteriores, el ordinograma utiliza los siguientes símbolos:

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 4

• Ejercicios: Realizar el organigrama y el ordinograma en estos ejemplos:

1) Calcular el área de un rectángulo cuyos datos base y altura se leen de teclado.

2) Calcular la suma de dos cantidades leídas de teclado y visualizarla por pantalla.

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 5

BASE, ALTURA CAN1,CAN2

AREA=BASE *ALTURA SUMA=CAN1+CAN2

"Àrea: ", AREA "SUMA=", SUMA

2 ESTRUCTURA GENERAL DE UN PROGRAMA.

• Bloque de declaraciones: En él se especifican todos los objetos que utiliza el

• Bloque de instrucciones: Constituido por el conjunto de operaciones que se han

2.1 La estructura de un programa.

2.1.1 Estructura de un programa en PASCAL.

program nombre de programa {cabecera del programa}

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 6

2.1.2 Estructura de un programa en C.

void main(void) /* función principal main() */

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 7

2.1.3 Estructura de un programa en pseudocódigo.

Programa Nombre de programa

2.2 PARTES PRINCIPALES DE UN PROGRAMA.

DATOS DE ENTRADA > MEMORIA CENTRAL

DATOS DE ENTRADA > PROCESO > RESULTADOS

Conjunto de instrucciones que toman los datos finales (resultados) de la memoria

MEMORIA CENTRAL > DATOS DE SALIDA

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 8

2.3 CLASIFICACIÓN DE LAS INSTRUCCIONES.

Su misión es anunciar la utilización de objetos en un programa indicando qué

Todo objeto referenciado en un programa debe haber sido previamente definido.

- No es aconsejable utilizar más de un dato por instrucción:

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 9

Cuando se encuentra \n se provoca un salto de línea.

printf("\n Hay %d alumnos \n",nume); "Total sa lario:",

Son instrucciones que realizan la evaluación de expresiones, generalmente lógicas, con

2.3.3.1.1 Simple (if then).

Controla la ejecución de un conjunto de instrucciones por el cumplimiento o no de una

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 10

2.3.3.1.2 Doble (if then else).

Controla la ejecución de dos conjuntos de instrucciones por el cumplimiento o no de

Una sola sentencia

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 11

2.3.3.1.3 Múltiple (case of).

Controla la ejecución de varios conjuntos de instrucciones por el valor final de una

VALO R2 VAL OR3 OTROS

ACCIÓN 1 ACCIÓ N2 ACCIÓN3 AC CIÓN4

UNIDAD II - METODOLOGÍA DE LA PROGRAMACIÓN. Pág: 12

2.3.3.2.1 Mientras (While).