E C I D N Í
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
Lógica de la Programación Guía didáctica 6 créditos Titulación Ciclo
1
In fo rm á t ic a
S A I O D S E R M U I C T E L R U M
E C I D N Í
S E R A N I M I L E R P
MODALIDAD ABIERTA Y A DISTANCIA
Departamento de Ciencias de la Computación y Electrónica
E R R E T S M I E R M P I B
Sección Tecnologías Tecnologías Avanzadas de la Web y SBC
Lógica de la Programación Guía didáctica 6 créditos
Titulación
In fo rm á ti c a
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
Ciclo
I S A I O D S E R M U I C T E L R U M
Autores:
Marco Patricio Abad Espinoza Jorge Stalin Calderón Bustamante
18106
La Universidad Católica de Loja
Asesoría virtual:
www.utpl.edu.ec
E C I D N Í
S E R A N I M I L E R P
MODALIDAD ABIERTA Y A DISTANCIA
Departamento de Ciencias de la Computación y Electrónica
E R R E T S M I E R M P I B
Sección Tecnologías Tecnologías Avanzadas de la Web y SBC
Lógica de la Programación Guía didáctica 6 créditos
Titulación
In fo rm á ti c a
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
Ciclo
I S A I O D S E R M U I C T E L R U M
Autores:
Marco Patricio Abad Espinoza Jorge Stalin Calderón Bustamante
18106
La Universidad Católica de Loja
Asesoría virtual:
www.utpl.edu.ec
E C I D N Í
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
LÓGICA DE LA PROGRAMACIÓN Guía didáctica Marco Patricio Abad Espinoza Jorge Stalin Calderón Bustamante © UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA Maquetación y diseño digital: Ediloja Cía. Ltda. Telefax: 593-7-2611418 San Cayetano Alto s/n www.ediloja.com.ec
[email protected] Loja-Ecuador Cuarta edición ISBN digital-978-9942-04-137-1
Reservados todos los derechos conforme a la ley. No está permitida la reproducción total o parcial de esta guía, ni su tratamiento informático, ni la transmisión de ninguna forma o por cualquier medio, ya sea electrónico, mecánico, por fotocopia, por registro u otros métodos, sin el permiso previo y por escrito de los los titulares del Copyright.
21 de octubre, 2010
S A I O D S E R M U I C T E L R U M
E C I D N Í
S E R A N I M I L E R P
2. Índice
2. Índice .................. .................. .................. ................. .................. .................. .................. .................. .............
4
3. Introducción.............................................................................................................................................
6
4. Lineamientos generales del Modelo Educativo basado en competencias y créditos académicos UTPL- ECTS.................. .................. .................. ................. .................. ....
7
4.1.
Competencias genéricas.................................. .................................... .................................
8
4.2.
Competencias específicas............................... .................................... ..................................
8
5. Bibliografía ................ ................. .................. .................. .................. .................. .................. .................. . 5.1.
9
Básica ................................. .................................... ................................... ..................................
9
5.2. Complementaria ................................... ..................................... ................................... ..........
9
6. Orientaciones generales para el estudio................. .................. .................. ................. ....... ................ 7. Proceso de enseñanza-aprendizaje enseñanza-aprendizaje para el logro de competencias................
10 12
PRIMER BIMESTRE
7.1.
Planificación para el trabajo del alumno ................................ ..................................... ...
12
7.2.
Sistema de evaluación ............................... .................................... ................................... ....
14
7.3.
Orientaciones específicas para el aprendizaje por competencias...........................
15
UNIDAD 1. PROBLEMAS Y SOLUCIONES .................................. .................................... .....................
15
1.1.
Aplicación de la lógica en la programación.................................. ..................................
17
1.2.
Principios en la elaboración de enunciados.................................. .................................
18
1.3.
Comprensión y especificación del problema..................................................................
19
1.4.
Identificación de entradas procesos y salida................................. .................................
19
Autoevaluación Autoevaluación 1 .................................. .................................... .................................... ......................
UNIDAD 2. NATURALEZA DE LOS DATOS
21
................................. .................................... .....................
22
2.1.
Naturaleza de los datos................................... ..................................... .................................
22
2.2.
Expresiones y variables .................................... .................................... .................................
23
2.3.
Dominios................................ ..................................... ................................... ............................
23
2.4.
Tipos de operadores................................... .................................... .................................... ....
23
2.5.
Reglas de precedencia................................ .................................... ................................... ....
25
Autoevaluación Autoevaluación 2 .................................. .................................... .................................... ......................
26
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
UNIDAD 3. ALGORITMOS .................................... .................................... ................................... ..........
27
3.1.
Ciclo de desarrollo...................................................................................................................
27
3.2.
Determinación de requerimientos................................. .................................... ...............
29
3.3.
Estructuración de pasos del algoritmo .................................... .................................... ....
30
3.4.
Resolución de problemas mediante algoritmos................................ ...........................
31
Autoevaluación 3 .................................. .................................... .................................... ......................
33
S E R A N I M I L E R P
E R R E T S M I E R M P I B
SEGUNDO BIMESTRE
7.4.
Planificación para el trabajo del alumno ................................ ..................................... ...
7.5.
Orientaciones específicas para el aprendizaje por competencias...........................
34 36
UNIDAD 4. ESTRUCTURAS DE DECISIÓN Y BUCLES ................................ .................................... ....
36
4.1.
Flujos de programa.................................................................................................................
36
4.2.
Estructuras selectivas ................................. .................................... ................................... ....
38
4.3.
Bucles................................ ..................................... ................................... ..................................
39
4.4.
Estructuras de control anidadas............................... ..................................... .....................
40
4.5.
Pruebas de escritorio ................................. .................................... .................................... ....
42
Autoevaluación 4 .................................. .................................... .................................... ......................
47
UNIDAD 5. DIAGRAMAS DE FLUJO .....................................................................................................
48
5.1.
Elementos de un diagrama de flujo.................................... .................................... ..........
48
5.2.
Elaboración de diagramas de flujo................................ .................................... ................
50
5.3.
Ejercicios con diagramas de flujo.................................... .................................... ...............
59
Autoevaluación 5 .................................. .................................... .................................... ......................
69
UNIDAD 6. DESARROLLO DE PROBLEMAS DE PROGRAMACIÓN .................................. ...............
70
6.1.
Abstracción de problemas de programación............................... ..................................
70
6.2.
Componentes de una aplicación............................... .................................... .....................
74
6.3.
Desarrollo de aplicaciones sencillas............................... .................................... ...............
75
Autoevaluación 6 .................................. .................................... .................................... ......................
80
8. Solucionario ................. .................. .................. .................. .................. .................. .................. ................
81
9. Glosario ................ .................. ................. .................. .................. .................. .................. .................. ..........
87
10. Recursos educativos multimedia................ ................. .................. .................. .................. .......
88
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
3. Introducción Estimado estudiante, queremos darle la más cordial bienvenida a esta su Universidad, particularmente a la carrera de Ingeniería en Informática. Aprovechamos la oportunidad para felicitarlo por haber confiado en esta prestigiosa institución educativa. Nuestros nombres son: Patricio Abad y Stalin Calderón, estaremos con ustedes para guiar el proceso de aprendizaje en la asignatura de Lógica de la Programación, cualquier duda e inquietud estamos a sus órdenes para responderle. Lógica de Programación es una materia troncal con seis créditos que se ubica en el primer ciclo de la carrera de Ingeniería en Informática y se ha elaborado enfocándose en el desarrollo de las competencias básicas para el diseño de algoritmos a través del pensamiento lógico aplicado a la resolución de problemas por computadora. El desarrollo de habilidades de programación no se logra sino con la inducción de una forma de pensamiento que ayuda a identificar los aspectos relevantes de un problema y representarlo en una notación formal que permita establecer una solución para el mismo. Como veremos más adelante, todas las personas somos capaces de resolver problemas de diferentes maneras, pero encuentran muchas dificultades al momento de traducir este problema a un lenguaje algorítmico y es precisamente este aspecto el que la materia de Lógica de la Programación intenta resolver, sin esto es muy difícil avanzar con otras asignaturas en la línea de programación, y de allí su importancia vital para el resto de la carrera. Los contenidos se encuentran organizados en unidades y distribuidos equitativamente para los dos bimestres. Se abordará en la unidad 1 los principios de la resolución de problemas mediante la abstracción de las salidas, el proceso de cálculo y las entradas requeridas; En la unidad 2 se estudiará la naturaleza de los datos, su representación y sus operaciones; para la unidad 3 tenemos los algoritmos que le permite al estudiante adquirir las bases para representar, su proceso de construcción, verificación y depuración. El segundo bimestre comprende la unidad 4 que abarca el uso de la selección y ciclos repetitivos, la unidad 5 versa sobre la representación de los algoritmos en diagramas de flujos y culmina con la unidad 6 consolidando todos los contenidos en la creación de aplicaciones sencillas susceptibles de programación. Además se considera el uso de herramientas de programación visual que le permitirán concentrarse en la lógica de programación antes que en la sintaxis de un lenguaje particular, esto con el ánimo de que pueda aplicar luego esta lógica con cualquier lenguaje de programación. Un aspecto importante que debemos mencionar es que la lógica de la programación no se limita a un lenguaje de programación específico, es por tanto independiente del lenguaje y para escribir los algoritmos utilizaremos dos herramientas fundamentales que son el pseudocódigo (miniespecificaciones) y los diagramas de flujo, los cuales puede dibujar y probar en una herramienta muy importante desarrollada por la academia de pilotos de la fuerza aérea norteamericana llamada Raptor. Thomas Alba Edison decía que los genios son 1% de inspiración y 99% de sudor, la cual es una máxima aplicable a esta materia, pues se requiere estudiar el fundamento teórico, comprenderlo y luego comenzar a desarrollar ejercicios. Muchos otros autores afirman que a programar se aprende programando, así que le animamos a aplicar estos principios en su estudio, es posible que encuentre algunas dificultades, que deberá superar para alcanzar los objetivos propuestos.
6
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
4. Lineamientos generales del Modelo Educativo basado en competencias y créditos académicos UTPL- ECTS Sr. Estudiante recuerde que usted ha iniciado su formación de tercer nivel con un sistema educativo basado en el desarrollo de competencias a través de créditos académicos. Este modelo le convierte a usted en protagonista de su propia formación y al profesor en mediador de las experiencias de aprendizaje. Surge entonces la necesidad de que tenga claro dos conceptos fundamentales competencia y crédito académico. •
¿Qué es una competencia? Entendemos por competencia el conjunto de actitudes, habilidades y conocimientos que el alumno adquiere e incorpora según sus características personales y experiencias laborales y, que se ponen de manifiesto en el desempeño de la actividad profesional. Las competencias se adquieren a lo largo del proceso formativo de la carrera y se desagregan en objetivos de aprendizaje propuestos en cada asignatura. Elementos de una competencia. Tres son los elementos que podemos distinguir en toda competencia:
Actitudes: son predisposiciones y comportamientos ante situaciones concretas.
Habilidades: son destrezas para ejecutar con éxito tareas, utilizar procedimientos y realizar trabajos. Se desarrollan a través de la práctica y la experiencia.
Conocimientos: constituyen los contenidos científicos, conceptuales, teóricos, conocidos también como el aprendizaje académico.
•
¿Qué es un crédito académico UTPL / ECTS en la Modalidad a Distancia? Un crédito académico es la unidad de medida del trabajo del estudiante, implica 32 horas de trabajo del alumno (29 horas de trabajo autónomo y 3 horas de interacción)1. Los créditos académicos que el estudiante irá acumulando en el transcurso de la carrera involucran: aprendizaje autónomo (estudio personal), tareas de investigación, interacción en el Entorno Virtual de Aprendizaje (EVA), participación en tutorías, videoconferencias y otros eventos académicos (Jornadas, seminarios, cursos, congresos avalados por la UTPL), prácticas académicas, pasantías preprofesionales y de vinculación con la colectividad; actividades de evaluación; así como la realización del trabajo de titulación. El modelo adoptado por la UTPL contempla dos tipos de competencias: genéricas y específicas.
Competencias Genéricas: Son aquellas capacidades (actitudes, habilidades y conocimientos) comunes a todas las profesiones que se ofrecen en la UTPL. Constituyen una parte fundamental del perfil que el estudiante debe desarrollar durante su formación.
1. CONESUP (2008): Reglamento del Régimen Académico del Sistema Nacional de Educación Superior , art. 18.
7
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
•
Competencias Específicas: son propias de la titulación, aportan a la cualificación específica para la profesión, dándole consistencia social y profesional al perfil formativo.
Estructura general del programa formativo
Las Unidades Académicas o Escuelas de la UTPL han estructurado el programa formativo contemplando cinco ámbitos o bloques de asignaturas: Formación Básica (10%); Genéricas de carrera (15%); Troncales (35%) Complementarias (10%); Libre configuración (10%) y además, el Practicum que comprende las Pasantías preprofesionales y de vinculación con la colectividad y Practicum Académico (20%).
4.1. Competencias genéricas • •
Capacidad de abstracción, análisis y síntesis. Capacidad para identificar, plantear y resolver problemas.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
4.2. Competencias específicas Estas se encuentran detalladas en la planificación de cada bimestre.
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
8
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
5. Bibliografía
5.1. Básica •
Ramírez, F. (2007): Introducción a la Programación. Algoritmos y su implementación en VB.net , C#, Java y C++, México, Alfaomega. El autor del libro Felipe Ramírez tiene mucha experiencia en capacitación de tecnología para las empresas, es director de contenidos de Aprenda Practicando. El texto se ha seleccionado debido a que la forma como plantea los contenidos es didáctica y fácil de seguir, además tiene muchos ejercicios y autoevaluaciones que lo hacen ideal para un estudiante a distancia. El enfoque práctico le da mucha relevancia frente a otros textos similares.
•
5.2. Complementaria
•
Cairo, O. (2005): Metodología de la programación algoritmos, diagramas de flujo y programas , México, Alfaomega. Contiene muchos ejercicios y algoritmos que se pueden usar para complementar los que posee el texto base, es ideal para la parte práctica de cualquiera de los capítulos del la materia. Tiene un desarrollo especial en lo referente a diagramas de flujo. Lipschutz, S. (1983): Matemáticas para computación , Colombia, McGraw-Hill. A pesar de ser una edición con bastantes años por delante, tiene valiosa información sobre aritmética del computador, lógica matemática, desarrollo de algoritmos y su representación en diagramas de flujos, contiene muchos ejercicios.
•
Paniagua, E., Sánchez, J. y Martín, F. (2003), Lógica Computacional , España, Thomson. Excelente texto para el estudio de la lógica matemática y su aplicación en el ámbito de las ciencias de la computación, se lo puede utilizar como complemento del capítulo 1 de la materia.
DIRECCIONES ELECTRÓNICAS •
O E D R N T S U E G M E I S B
Abad, M. y Calderón, J. (2009): Guía didáctica de Lógica de la Programación, Ecuador, Editorial UTPL Guía didáctica diseñada para el estudio de la Lógica de la Programación en la carrera de Ingeniería en Informática de la Modalidad Abierta y a Distancia de la Universidad Técnica Particular de Loja.
•
E R R E T S M I E R M P I B
Carlisle, M. (2009): Welcome to the raptor home page , [En línea] Disponible en: http://raptor. martincarlisle.com/ [Consulta 12-06-2009] Sitio de descarga de raptor, donde se publican además las últimas novedades del producto, aquí encontrará también la versión de raptor orientada a objetos.
9
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
6. Orientaciones generales para el estudio Estimado Estudiante: El estudio de la programación de computadores es una tarea compleja que requiere el desarrollo de algunas habilidades de pensamiento orientadas a la solución de problemas descomponiéndolos en partes manejables, lo cual aprenderemos durante el presente curso. Para conseguir este propósito es necesario que tenga una dedicación periódica que le permita aprender y desarrollarlas, por ello le sugerimos no menos de 8 horas semanales que podrían variar en función de sus habilidades y conocimientos previos. A continuación se le propone algunas orientaciones que le servirán en su proceso de aprendizaje:
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
En primera instancia recordarle que usted cuenta con los siguientes recursos para el aprendizaje: O I R A N O I C U L O S
1.
La guía didáctica: Le orientará sobre cómo y qué temas estudiar, además contiene ejercicios de autoevaluación que le permitirán medir su grado de comprensión y la necesidad de tutoría por parte del docente. Muchos estudiantes empiezan estudiando directamente el texto, pero como verá más adelante no es recomendable hacerlo.
2.
El texto básico: Le servirá para desarrollar los contenidos principales conforme se lo indica en la guía didáctica. Vale acotar que no todos los capítulos del texto se consideran para la asignatura y tampoco cubre todos los contenidos por lo que el estudio debe hacerse siguiendo las instrucciones de la guía didáctica. Los capítulos del 10 al 14 los puede usar para iniciar el estudio de la lógica de la programación en alguno o en todos los lenguajes de programación propuestos.
O I R A S O L G
3.
El Entorno Virtual de Aprendizaje: Donde podrá interactuar con sus profesores a través de una orientación del trabajo semanal, uso de mensajería electrónica para resolver inquietudes, foros, desarrollo de ejercicios prácticos, publicación de recursos, todo este trabajo tendrá una valoración de 2 puntos.
S A I O D S E R M U I C T E L R U M
4.
La Tutoría personal: Es un tiempo semanal que como profesores dedicamos para atender las inquietudes en relación a los contenidos o desarrollo de trabajos, para ello se publicará un horario en el cual podrán asistir personalmente o contactarse vía telefónica, el mismo que se detalla en la carátula de la evaluación a distancia.
5.
Los trabajos a distancia: Son actividades teóricas y prácticas que acompañan a la guía didáctica de cada una de las materias, le permiten aplicar y reforzar los conocimientos adquiridos mediante su desarrollo, y debe enviarlos a su profesor. La entrega de estos trabajos con su respectiva carátula es obligatoria y no recuperable, lo cual significa que si no entrega alguno de los mismos no tendrá opción a la evaluación presencial, su valoración es de 4 puntos que sumados a la calificación de participación en el EVA totalizan 6 puntos.
6.
El Software para el desarrollo de aplicaciones: Los estudiantes contarán con herramientas de software que les permitirán realizar prácticas y validar los resultados de sus ejercicios. Este software se lo incluirá en un disco compacto que se entrega con la presente guía didactica.
10
E C I D N Í
Guía didáctica: Lógica de la Programación
Al finalizar cada bimestre usted debe presentarse a una evaluación presencial en su centro universitario, la cual se califica sobre 14 puntos, que sumados a los 6 puntos de los trabajos a distancia le dan un total de 20 puntos por bimestre. Usted debe obtener una nota mínima de 14 sobre 20, de lo contrario deberá rendir una evaluación supletoria que reemplaza a la nota bimestral. Para aprobar debe tener un mínimo de 28 puntos. Como método de estudio, le recomendamos que lea detenidamente los contenidos de la guía didáctica y siga fielmente las instrucciones dadas, lo más importante es realizar prácticas no limitándose a lo que dice el texto, sino que es recomendable que idee sus propios problemas lo cual lo hará sentirse mucho más familiarizado con la mecánica de la materia. Puesto que dispondrá de herramientas para la computadora utilícelas en todo momento.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
Nota importante: Por su participación en ciertas actividades del EVA en cada bimestre, usted podrá obtener un punto que complementará la nota obtenida en la evaluación a distancia; esto quiere decir que si obtiene en la misma menos de 6 puntos podrá incrementar su nota (hasta 6 puntos) por medio de la participación y los ejercicios que su tutor(a) le propondrá en el EVA.
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
11
E C I D N Í
Guía didáctica: Lógica de la Programación
N Ó I C A U L A V E
s a i c n e t e p m o c e d o r g o l l e a r a p e j a z i d n e r p a a z n a ñ e s n e e d o s e c o r P . 7
a s l e n n e o s a i c c e i a d t c u a á l a d d i v i d e n u o a t r í u o u A p g •
S S O O I o S C c R T i s U C á C Á b E D o t R I D x e T •
a s e n o i a i c c a n u a l t a i v s E d •
o n m u l a l e d o j a b a r t l e a r a p n ó i c a c i f i n a l P . 1 . 7
S E R A N I M I L E R P
s s e e n l a o i i c c a n u e l s a e v r E p • •
E R R E T S M I E R M P I B
, s e : l e d a a j a . c u a d i z i s t t i r c i v o t i á V d t n o n d c e i o e n r a D n , o r p s m f u a o í t A o c é l r u n e o o e G E d f d T •
•
a l E n e D E s S J a a e d E A c a d i Z v s I a t D i c e s o d A D l d n á n l N D d a e o e i I E a r r r d d V i m p r I R u a v t a o í T P c m s i t c C A e o e c e u L c D a r g A • • o A O d a 2 M V y I m A T i 1 R A t o n a e i G T s e n d d e ó O N o a s u d i a c N E s s c I p m r t O R m e o e a r a R O e S h o o r e t C i h 6 u t T n 1 a 8 i
E R T S E M I B R E M I R P
s o l n e n ó i c a p i . c s i t r o a r o P f
o c i n ó r t c e l e o e r r o C • • o l l l a e o r n r ó n a i o s c e c a n d l u . ó l i a e a i c c d v c e a o a n r a i e c l t t A i s e i V n E I n d d I • •
O E D R N T S U E G M E I S B
a l n e s a a e d c a d i v s a t i c s l o e d á n l d n d a e o e i a r r r r d d i m u v t p a a i o í c m s t c e o e c e u L c D a r g • •
O I R A N O I C U L O S
3 a o n n e i a e d d i d ó m s u s c e a t c s S r e a a r o o r o h t h e u t n 8 a 4 i . . s n a y a . o i ó y . t i c s . i n s c c a s s s a l g i ó a o d o e r n e a t e ó s t S m l c s o d d s e e n a d a e s l e o O m a e c l o l d a e e e a d . y n d o s t l m D b ó r c e n e a e r I T n i n a / n s ó c . ó p r D d y e e r o d r n s r i N s o o ó i a a i , e p p p g i e . a E e P c s s c d n s e c c a n i n s o e T d : l u ó o o z . R r s m a a s f o a o e d e i : l o i i l c d r i e l e i c N a 1 o i c p i r c 2 f a a e s i a p o n p e b i n d s d d S a l i a r O i r d t e a d u r s l c c b u p o n t i d l i C n a a l n i t p m o g n l n m s r e n a a p o i a p e r e e o e p d U d e s d x i e i n A P C I N E D T R n U 1 2 3 4 1 . . . . . 2 . 3 . 4 . 5 . U 1 1 1 1 2 2 2 2 2 . n e . ó s u n n i E E e c q e ó l i n J s D a u a s t c s u l s r o A s n u a l o S Z e a a r o n o y e u l . r t p s j O I s d n ó i r o a m m s a i s a c d s e u D V a d o e e a n s n e e o o a c l a I N l l e i c e m a u b t i e s r b t T E r i l n m c f u r t p m d a i e E o o a i a i l o r s r i t p l r r p i r r J R i c c g s o a e b a j d n p p o e B P l i t o e r n ó m m g l r o e e g e p a e l O A p r a a e o d o r l e i A p l l d c I c p l D t m p d m a • • • r a o s r l l S o o u A l S a e a s I A r a r , , d o r r y . s s a C a v t s s , a N C o s s o p r I e o , r s o s s e n p e o n . c s r c E Í F d t o e a e s a d i i n l c c e o a t i a u a T C r n t n d i e á i i i i a g o r e r m t r e E E m r o y l d ó i m i r i s c e e c a m m a i a í P P n n z c c ó s s s v l o i o a o a a e p l d l c r o c s e e n b M S p d e t i n a n a e e c l c c n o i u c s n a o t s o t l O E i f n r e e e c s l p o u m e e y n i n e C D f s e e t a A n c n e r p • •
O I R A S O L G
S A I O D S E R M U I C T E L R U M
12
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
E R R E T S M I E R M P I B
e n d a o o n c l ó i r l c a a o r a i u r u c a l n i a n t s a e t n d v s o l e i a C e l d •
l e l n e e d o t n s ó i e c u a p p o r i c p i t A r o a r o V P f E •
a l n e s a a e d c a d i v s a t i c s l o e d á n l d n d a e o e i a r r r r d d i m u v t p a a i o í c m s t c e o e c e u L c D a r g • •
l e l n e e d o t n s ó i e c u a p p o r i c p i t A r o a r o V P f E •
a e n l d ó i . e l o c a r l a i a o u c z r l i a n l r a a a s v t e i s n e i a F d l d •
O E D R N T S U E G M E I S B
l e a d l l a . a r i e r a c t p n s e s n e e ó m i r i c p b a r a r a b e p e m e r i r r u P p p
6 y 5 , o e n 4 e i d a d d i n s u s ó c a a a r t c s r o e m h o o a r e h e S 4 t u 2 t n 2 a 1 i s o e s s t o a n p a m l o e i t e l i d s d r o o d n t n o e e o r r ó m n i g a m l s s i i e ó t d s c i A e c a r n a o a : d i m ó r o i m m 3 e n i r u t e i g c l l e t d d m u b r c a r l u a o e q u l o o o g r e s r l d l i c t e e r t s d e p a n i D E R U C 1 3 4 . 2 . . . 3 3 3 3
O I R A N O I C U L O S
8 y 7 a n a m e S
O I R A S O L G
3 a l a 1 a l e d d a d i n U
S A I O D S E R M U I C T E L R U M
s s e a o l d c i e o g s e e s d s s ó o o u d d . l t o o a l s e l l e l s i l a s i , l s s n c l d e a a e a a l c e r c o e r r i . e r r n e n o c l r e a l a m . c n r o i t g c e o e r i t i n r d d o e a e i c i o r i a f v s é c i i a s e a n d s l a r e t e e a s r r m a c e o e d w l d l o u a n t m s p i t e c e r q u r p e s e f s e x r r e e e o a d o e R e a y m d p o R f s d I f r u • • • r e v l , s l r o s o e a . e e l r s d a o d y a a í n y d s i r e o c i e r r n a m e d n l z a o e n p i l b i c t i e m a l é g o n o r p c a i n C a p a m l •
, o l s l l o a , , i t o a n n n u , r r . c e ó i e e d i ó s n a c i r d g a o c c i i ó s e s a ó c c d m l i c o a t c t t e i a t x c u y e i a á l r d m y p e o n s o r i r a o e a m t m g r s i ñ g i c e n l l i o C o p e l t á c s C n i o a p a l o s r n e a a A m e l l c d p a d •
13
E C I D N Í
Guía didáctica: Lógica de la Programación
7.2. Sistema de evaluación Formas de evaluación
2. Heteroevaluación * n ó i c a u l a v e o t u A . 1
s Cumplimiento, puntualidad, e d responsabilidad u t i t c Esfuerzo e interés en los trabajos A
Evaluación a distancia **
a v i t e j b o e t r a P
o y a s n e e d e t r a P
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
Respeto a las personas y a las normas de comunicación
X
s e Contribución en el trabajo d a colaborativo y de equipo d i l i b Presentación, orden y ortografía a H
desarrollo de temas PORCENTAJE
Puntaje
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S
X X
Emite juicios de valor argumentadamente Dominio del contenido
a v i t e j b o a b e u r P
n ó i c a u l a v e o C . 3
X
Creatividad e iniciativa
s o t n Investigación (cita fuentes de e i consulta) m i c o Aporta con criterios y soluciones n o C Análisis y profundidad en el
Evaluación presencial A V E l e n e n ó i c c a r e t n I
Competencia: criterio Comportamiento ético
S E R A N I M I L E R P
X
X
X
X
X
X
X
X
O I R A S O L G
X
X X
X
X
X
e e 10% 20% 30% d j a a i z i g d e t n e a r r 2 4 6 t s p E a
TOTAL
o t n u a a * p l n * ) a ó * 1 t a e i o l c i c a m p u n i a l t x m s á o a i c v M ( e d
70%
14
20 puntos
l e n e y s s e e l a d i a c d i n v e i t s A c e r V A p E
Para aprobar la asignatura se requiere obtener un puntaje mínimo de 28/40 puntos, que equivale al 70%.
*
Son estrategias de aprendizaje, no tienen calificación; pero debe responderlas con el fin de autocomprobar su proceso de aprendizaje. ** Recuerde que la evaluación a distancia consta de dos partes: una objetiva y otra de ensayo, debe desarrollarla y entregarla en su respectivo centro universitario. *** Su tutor(a) le planteará una o más actividades en el EVA que serán calificadas por un punto en total. Este solo computará para complementar la nota del trabajo a distancia, es decir, si Ud. logra menos de seis puntos en el mismo podrá aumentar dicha nota (hasta completar los 6 puntos) con esas actividades en el EVA.
Señor estudiante:
Tenga presente que la finalidad de la valoración cualitativa es principalmente formativa.
14
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
7.3. Orientaciones específicas para el aprendizaje por competencias
UNIDAD 1. PROBLEMAS Y SOLUCIONES
El trabajo del pensamiento se parece a la perforación de un pozo: el agua es turbia al principio, más, luego se clarifica. - Proverbio Chino
Estimado(a) estudiante: Iniciamos nuestro estudio con este interesante proverbio, que nos da una pauta de cómo es el proceso de aprendizaje de la lógica de programación, con ello le invitamos a poner especial interés en su estudio y a no desesperarse si las cosas no se ven fáciles al inicio, esto no debe preocuparle porque logrará mayor claridad conforme vaya avanzando con el desarrollo de los ejercicios.
Para el estudio de la presente Unidad trabajaremos con el capítulo 3 del texto básico y opcionalmente los libros de lógica planteados en la bibliografía, si puede disponer de ellos sería importante que los use para reforzar los temas planteados. Una de las habilidades de pensamiento más importante para aprender a programar es la abstracción del problema, la cual podemos decir que es la capacidad de identificar par tes en las que podemos dividir un problema para trabajar sobre ellas en la búsqueda de la solución. Cuando el problema se refiere a programación, en términos generales estas partes se pueden considerar como entradas, proceso, almacenamiento y salida (fig. 1.1), que son los tareas básicas que realiza el computador.
ENTRADAS
PROCESO
SALIDA
ALMACENAMIENTO
Fig. 1.1 Funciones básicas del computador
La capacidad de abstraer un problema es innata en el ser humano y se desarrolla en mayor o menor medida en función de la complejidad de los problemas que debemos resolver, también tiene mucho que ver la creatividad, de hecho cuando tenemos que enfrentarnos a un problema, podemos resolverlo de diferentes maneras, es muy difícil que dos personas lo hagan del mismo modo. 15
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Analice el siguiente ejemplo.
S E R A N I M I L E R P
Ejemplo 1.1 Problema: Calcule la edad de una persona. Análisis del problema: •
Debe solicitar la fecha de nacimiento y restarla de la fecha actual, el resultado debe expresarse en años, meses y días. Hasta aquí el asunto parece fácil, pero si lo analizamos con más detalle la operación de restar fechas es un poco más compleja que la resta común, de hecho no puedo restar directamente las dos fechas como si se tratase de dos número cualquiera, las fechas son números compuestos por tres componentes, que serían los años, los meses y los días, los cuales debo restarlos por separado. Calcular la edad que tiene una persona nacida el 12 de abril de 1985 al 15 de mayo de 2009. Abstrayendo los datos tendríamos:
Si aplicamos el cálculo requerido tendríamos que ejecutar las siguientes operaciones:
Fecha actual Fecha de nacimiento Edad
Mes 05 04 01
Día 15 12 03
O I R A S O L G
Solución: La persona tiene 24 años, 1 mes y 3 días. El método de cálculo seleccionado aparentemente funciona, pero ¿qué sucedería si debemos calcular lo mismo para otra persona, cuya fecha de nacimiento es 22 de diciembre de 1980, si aplicamos el mismo método los resultados serían:
Fecha actual Fecha de nacimiento Edad
Año 2009 1980 0029
Mes 05 12 -7
Día 15 22 -7
Si interpretamos la respuesta tendríamos que la edad de la persona es 29 años, -7 meses y -7 días, lo cual no resulta lógico porque nadie tiene una edad negativa, este debido a que no podemos realizar restas cuando la fecha de nacimiento es mayor a la fecha actual, en este caso toca aplicar las siguientes reglas: 1.
O E D R N T S U E G M E I S B O I R A N O I C U L O S
Fecha actual: 2009-05-15 Fecha de nacimiento: 1985-04-12
Año 2009 1985 0024
E R R E T S M I E R M P I B
Si el día de nacimiento es mayor al día actual, debo pedir prestado 30 días al mes para poder efectuar la operación y puesto que he convertido un mes en treinta días tengo que restarle un mes a la fecha actual.
16
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
2.
Si el mes de nacimiento es mayor al mes de la fecha actual, debo pedir prestado un año expresado en 12 meses y sumarlos al mes actual, luego hay que restar ese año que se convirtió en meses al año actual.
3.
Si luego de realizar todas las operaciones obtenemos un año en negativo, hay inconsistencia en los datos por lo tanto no se puede calcular la edad de alguien que todavía no nace.
Solución:
E R R E T S M I E R M P I B
Luego del análisis realizado, vamos a realizar el cálculo correspondiente
Prestamos Fecha actual Fecha de nacimiento Edad
Año 2009 -1 = 2008 2009 1980 0028
Mes 5-1 = 4 + 12 = 18 05 12 6
S E R A N I M I L E R P
Día 15+30 = 45 15 22 23
O E D R N T S U E G M E I S B
Por tanto la persona en realidad tendría 28 años, 6 meses y 23 días. Esta solución podría no ser la única, pero es correcta. El problema puede complicarse más cuando se pide que consideremos los años bisiestos en los cuales el mes de febrero tiene 29 días en lugar de 28. ¿Sería capaz de plantear una solución considerando este problema? Lo invito a solucionarlo en papel y lápiz. Ahora ¿qué dificultades tuvo para encontrar la solución? Cuando se trata de encontrar la solución una de las dificultades más importantes es la representación del problema en un lenguaje formal como puede ser el lenguaje matemático, para poder procesarlo, en esta tarea nos ayudan la lógica y la matemática. Es por ello que nuestro estudio va a comenzar estudiando el papel de la lógica matemática en el planteamiento y solución de problemas.
1.1. Aplicación de la lógica en la programación Comencemos revisando al apartado Lógica del capítulo 3 del texto básico para ver cómo la lógica de proposiciones nos ayuda a abstraer premisas de un problema y obtener de ella algunas conclusiones. Luego de revisar el capítulo indicado vale recalcar nuevamente la importancia del razonamiento para poder obtener las proposiciones y llegar a conclusiones. El estudio de la lógica va más allá del planteamiento de silogismos como se lo ha mostrado en este apartado, el extracto presentado aquí constituye solamente una parte para comprender como empata la lógica matemática con la lógica de programación. Según lo establece Ramírez, la lógica nos ayuda a tener un pensamiento más ordenado siguiendo algunas reglas que hacen que el mismo sea más lógico.
17
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Si no logramos un pensamiento fundamentado en la razón, corremos el riesgo de lanzar planteamientos sin la debida argumentación, lo cual no ayuda a resolver los problemas, y muchas de las soluciones propuestas adolecerán fallas que se verán reflejadas en nuestros programas.
Desarrolle el ejercicio 03.01 del texto básico.
Como habrá notado al obtener conclusiones a partir de las premisas, los enunciados pueden ser verdaderos, falsos, correctos o incorrectos. El valor de verdad corresponde a su comparación con la realidad y la corrección tiene que ver con la argumentación que sustenta dicha conclusión. Los ejercicios hasta ahora analizados en el texto son relativamente sencillos, pero en la práctica nos encontramos con situaciones más complejas, por lo tanto el razonamiento lógico debe apoyarse en un gran número de equivalencias y reglas de inferencia que permiten llegar a conclusiones verdaderas o falsas. Estudie ahora los apartados Lógica de Programación con sus secciones Aplicación de la lógica en programación y Finalidad de los enunciados del proceso del capítulo 3 del texto básico. Como bien menciona el autor, la Lógica de la Programación es una “habilidad” o “competencia” que permite obtener algoritmos susceptibles de implementarse en un lenguaje de programación. Muchas personas tienen facilidad para inferir algoritmos rápidamente, pero como podemos darnos cuenta el uso adecuado de los silogismos, ayuda a formar esta capacidad. Si usted ha tenido la oportunidad de estudiar Lógica Matemática, seguramente habrá sentido que no le sir ve de mucho para programación, lo cual según lo estamos analizando no es cierto, y lo más interesante es que le ayuda a ordenar las ideas para obtener algoritmos eficientes a partir de los enunciados. Aunque todavía no hemos desarrollado ningún algoritmo, hemos podido establecer las salidas esperadas, los datos de entrada y el proceso de cálculo requerido, así como también ha establecer si la información que hemos obtenido es suficiente y correcta como para poder resolver el problema que tenemos en mente. Si se ha fijado, tenemos diferentes tipos de enunciados que es necesario plantear para poder establecer las condiciones de un problema; mientras más grande y complejo es el problema, requerimos una mayor cantidad de enunciados, los cuales es preciso ubicar en alguna de las tres categorías que son entradas, proceso y salidas.
1.2. Principios en la elaboración de enunciados Como ya hemos mencionado en el apartado anterior, la clave para resolver de manera lógica un problema es la adecuada elaboración de enunciados. En esta sección vamos a analizar los principios que ubican a los enunciados en entradas, proceso y salidas. Para el estudio de este tema, tome su texto básico y lea el subtema Principios en la elaboración de enunciados.
18
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Muy probablemente habrá tenido experiencia programando bien sea en el colegio, en su trabajo, o ahora que está estudiando para obtener su título, si corresponde a este último caso, seguramente reconocerá estos principios en algunas de las características de los algoritmos, de allí la importancia de que antes de resolver un problema, comience planteando los enunciados de acuerdo a cada uno de los procesos estudiados. Para medir el grado de comprensión que ha obtenido respecto de la elaboración de enunciados, sírvase desarrollar el ejercicio 03.02, note que no es necesario haber estudiado el capítulo 1 del texto básico para hacerlo. Adicionalmente resuelva las preguntas del capítulo 3.
1.3. Comprensión y especificación del problema Muchos autores inician el estudio de la programación con situaciones triviales como por ejemplo resolver el problema de sumar dos números, lo cual la mayoría de las veces resulta contraproducente porque se subestima la verdadera naturaleza de los problemas de programación. ¿Qué complejidad se puede encontrar en el problema de sumar dos números o en el de encontrar el mayor de dos números? ¿Sería posible plantear enunciados para este tipo de problemas? Lo más seguro es que pueda poner uno o dos pero no tendrá necesidad de desarrollar grandes habilidades de pensamiento para hacerlo. Los problemas de programación reales suelen tener mayor grado de complejidad y se prestan muy bien para realizar la identificación de las entradas, proceso y salida. Por ello consideramos importante comenzar con problemas no triviales que permitan desde el inicio poner en práctica la mayoría de los principios. Como se verá más adelante el proceso de programación inicia con una etapa de análisis en la cual se busca identificar todas las características del problema que incluyen: el contexto del dominio que nos permitiría conocer datos, reglas que acompañan al problema en cuestión y las restricciones de entradas o salidas que debemos respetar.
1.4. Identificación de entradas procesos y salida Tal como se mencionó anteriormente la resolución de un problema de programación implica la identificación de entradas, procesos y salidas, las cuales deben cumplir con las características indicadas en la sección 1.2 de la presente guía. El análisis del problema contrario a lo que el sentido común dictaría, debe comenzar con la identificación de la SALIDAS esperadas, es decir los resultado que esperamos tener de nuestra solución. En esta etapa entonces debemos elaborar los enunciados correspondientes a las salidas que normalmente corresponderían a los enunciados de resultado. El siguiente paso es idear el proceso que nos permita llegar al resultado deseado. Los enunciados del PROCESO, corresponderían a la asignación de valores, enunciados de cálculo y enunciados condicionales. Finalmente debemos identificar las ENTRADAS requeridas para poder realizar los cálculos. Los enunciados en esta categoría normalmente corresponden con enunciados de asignación de valores y enunciados de valor preexistente. La figura 1.2 ilustra gráficamente esta forma de analizar el problema.
19
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
En trad as
Pro ceso
S E R A N I M I L E R P
Salidas
E R R E T S M I E R M P I B
3 1
2
Etapas en la resolución de un problema Ejemplo 1.2 Intentemos aplicar los principios de la elaboración de enunciados al ejemplo 1.1 de la guía didáctica valiéndonos de la estrategia aquí planteada.
O I R A N O I C U L O S
Enunciados de las Salidas • • • • • •
O E D R N T S U E G M E I S B
La edad debe expresarse en años, meses y días. La edad en años no debe ser menor que cero. La edad en meses no puede ser menor que cero. La edad en meses no puede ser mayor que once. La edad en días no puede ser menor que cero. La edad en días no puede ser mayor que treinta.
O I R A S O L G
Enunciados del proceso • • • • • • •
Para calcular la edad se debe restar la fecha de nacimiento de la fecha actual. La fecha debe descomponerse en años, meses y días. Se debe comenzar restando los días. Si el día de nacimiento es mayor al día actual debe solicitar un mes expresado en días a los meses de la fecha actual, con lo cual se suman 30 días al día actual y se resta un mes al mes actual. En segunda instancia debe restarse los meses. Si el mes de nacimiento es mayor que el mes de la fecha actual, debe solicitar un año expresado en meses a la fecha actual, con lo cual se suman 12 meses al mes actual y se resta un año a año actual. Finalmente se resta los años.
Enunciados de la entrada • • • • •
Para el cálculo de la edad es necesario ingresar la fecha de nacimiento y la fecha actual. Las fechas actual y de nacimiento deben ingresarse en tres números cada una que representan año, mes y día. La fecha de nacimiento nunca puede ser mayor que la fecha actual. Un año tiene 12 meses. Un mes tiene 28, 30 0 31 días. 20
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
• •
Los meses del año pueden tener valores del 1 al 12. Los días del mes pueden tener valores del 1 al 31.
S E R A N I M I L E R P
EJERCICIOS
Trabajemos ahora para reforzar los conocimientos adquiridos, desarrollando el siguiente ejercicio. 1.
Considere el siguiente problema y elabore los enunciados relacionados con la entrada, procesos y salidas: se desea entregar una cantidad de dinero en dólares con la menor cantidad de billetes y monedas.
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
¿Ya realizó el ejercicio? ¡Qué bien! !Continuemos¡
Autoevaluación 1
Hemos concluido el estudio de la primera unidad. Conviene comprobar cuánto ha logrado asimilar de los temas revisados en esta parte, para lo cual es necesario que desarrolle el examen rápido del capítulo 3 del texto básico. Verifique sus respuestas con el solucionario que se encuentra al final de la guía didáctica.
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
21
E C I D N Í
Guía didáctica: Lógica de la Programación
UNIDAD 2. NATURALEZA DE LOS DATOS El propósito de la presente unidad es conocer la importancia del uso de los datos al momento de resolver problemas computacionales, así como también aprender a elegir los tipos de datos que mejor se adapten al contexto del problema que estamos tratando de resolver para lograr un mayor rendimiento en la ejecución de nuestros algoritmos. La temática abordada en esta unidad está vinculada con los capítulos 4 y 5 del texto básico.
2.1. Naturaleza de los datos Antes de revisar y desarrollar un algoritmo, es necesario aprender a utilizar los datos que serán procesados y transformados en resultados (información) por dichos algoritmos. Los datos son representaciones simbólicas no significativas que sirven como punto de partida para poder resolver un problema computacional. A continuación se muestran los diferentes tipos de valores que se pueden manejar en un computador: Tipo de valor Numéricos Cadena Fecha Booleanos Nulos BLOB
Descripción Permiten realizar cálculos aritméticos Permite manejar una serie de caracteres como un solo valor Permiten almacenar fechas del calendario Permite almacenar valores binarios. 1-0, Verdadero-Falso Ausencia de valor Representación binaria para almacenar imágenes, sonidos, etc.
Procesamiento
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
A continuación usted podrá darse cuenta en qué punto intervienen los datos, considerando la arquitectura general de un computador.
Datos
S E R A N I M I L E R P
Información
Figura 2.1 Arquitectura general de un computador “Un dato por sí mismo no constituye información, es el procesado de los datos lo que nos proporciona información”. 2
2. Wikipedia (2009): Dato, [En línea] Disponible en: http://es.wikipedia.org/wiki/Datos [Consulta 25-06-2009]
22
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
2.2. Expresiones y variables Para comprender cómo escribir expresiones, sírvase estudiar el apartado “Expresiones y Variables” del capítulo 4 de su texto básico.
Una vez que ha realizado la lectura del apartado sugerido, podemos concluir que una expresión en términos generales es la representación de un cálculo necesario para la obtención de un resultado; a continuación se presenta ejemplos de diferentes tipos de expresiones: 4 8+2
Expresión absoluta “UTPL” Expresión absoluta Expresión compuesta
nom_variable
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
4
RAM
Por otro lado, una variable es una referencia lógica a una posición física de la memoria RAM, tal como se esquematiza a continuación: En donde: nom_variable corresponde al nombre de la variable que referencia al valor 4 (expresión absoluta), que está almacenado físicamente en una celda de la memoria RAM.
2.3. Dominios Una vez que haya revisado los contenidos del libro en relación a los dominios y sus tipos, podemos concluir que un dominio es el conjunto de valores válidos para un dato. Antes de implementar un algoritmo se debe definir correctamente el dominio de los datos que vayamos a usar, para de esta forma evitar que se ingresen valores incorrectos. Por ejemplo: si deseamos almacenar la edad en años de una persona, claramente podemos darnos cuenta que el rango de valores válidos estarían comprendidos entre 0 y 130, este rango corresponderá al dominio, evitando así que se ingrese valores mayores o tipos de datos diferentes que vayan afectar la ejecución del algoritmo o en su defecto que provoquen almacenar información incorrecta.
2.4. Tipos de operadores Luego de haber identificado en su texto básico los tipos de operadores que se puede usar en una expresión, podemos concluir diciendo que un operador es un símbolo que tiene una función predefinida (suma, resta, multiplicación, mayor que, etc.); los mismos que nos permiten construir expresiones compuestas, como las que se muestran a continuación: A = (b * h) A = (b * h) / 2 Y = x^2 + 5 23
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Los operadores se clasifican de acuerdo a su función, así tenemos la siguiente clasificación:
S E R A N I M I L E R P
Operadores aritméticos Operador
Acción
+ * / ^
Suma Resta Multiplicación División Exponencial
E R R E T S M I E R M P I B
Operadores de asignación Operador
Acción
=
Igual que
O E D R N T S U E G M E I S B
Operadores relacionales o comparativos Operador
Acción
= < > <= >= !=
Igual que Menor que Mayor que Menor o igual que Mayor o igual que Distinto a
O I R A N O I C U L O S O I R A S O L G
Operadores Lógicos Operador NOT AND OR
S A I O D S E R M U I C T E L R U M
Acción
Negación Conjunción ( Y ) Disyunción (O)
Es importante señalar que el resultado de las operaciones lógicas, es decir expresiones que contengan operadores comparativos o lógicos, está determinado por las tablas de verdad correspondientes a cada una de ellas, tal como se puede apreciar a continuación: continuación:3 Operador NOT A V F
NOT A NOT A F V
3. Wikipedia (2009): Tablas de valores de verdad , [En línea] Disponible en: http://es.wikipedia.org/wiki/Tabla_de_valores_de_verdad [Consultado 15-06-2009]
24
E C I D N Í
Guía didáctica: Lógica de la Programación
Operador AND A V V F F
B V F V F
S E R A N I M I L E R P
A AND B AND B V F F F
E R R E T S M I E R M P I B
Operador OR A V V F F
B V F V F
A OR B OR B V V V F
O E D R N T S U E G M E I S B
2.5. Reglas de precedencia Estimado estudiante, le sugiero realizar una lectura comprensiva del apartado de reglas de precedencia y tenga muy en cuenta los diferentes tipos que menciona el texto básico, finalmente compleméntelos compleméntelos con lo que a continuación se cita: Los operadores de una expresión se evalúan, en general, de acuerdo al siguiente orden: 1. 2. 3. 4. 5. 6. 7. 8. 9.
O I R A S O L G
Paréntesis Paréntesis (comenzando por los más internos) Signo Potencias Productos y divisiones Sumas y restas Relacionales Negación Conjunción Negación
S A I O D S E R M U I C T E L R U M
Para poder entender el funcionamiento de las reglas de precedencia, desarrollaremos el siguiente ejercicio: tenemos la expresión: ((3 + 2) * 2 - 4) / 2 * 5 , del cual debemos obtener su resultado, a continuación resolveremos dicha expresión paso a paso, tomando en cuenta el orden de precedencia de los operadores. Expresión inicial Se resuelve (3 + 2) Se resuelve 5 * 2 Se resuelve (10 - 4) Se resuelve 6 / 2 Se resuelve 3 * 5
O I R A N O I C U L O S
((3 + 2) * 2 - 4) / 2 * 5 (5 * 2 - 4) / 2 * 5 (10 - 4) / 2 * 5 6/2*5 3*5 15
25
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
Ejercicio 2.1 Resolver la siguiente expresión teniendo en cuenta las reglas de precedencia. Expresión
12 / 4 * (7 - 5) / 3 * (4 – 3)
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
EJERCICIOS
Es hora de trabajar en los siguientes ejercicios. ejercicios. 1.
Desarrolle los ejercicios del apartado Ejercicio 04.04 del texto básico.
2.
Desarrolle los ejercicios del apartado Ejercicio 05.01 del texto básico.
3.
Dados los valores valores de: X = 1, Y = 4, Z = 10, resolver la siguiente siguiente expresión tomando en cuenta el orden de los operadores.
O I R A N O I C U L O S O I R A S O L G
2 * X + 0.5 * Y – 1 / 5 * Z
Autoevaluación 2
Una vez terminada esta unidad, unidad, midamos su nivel de comprensión comprensión resolviendo resolviendo el examen rápido del capítulo 4 del texto básico.
26
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
UNIDAD 3. ALGORITMOS El propósito de la presente unidad es la de explicar en forma general el proceso de desarrollo de software con todas sus fases y lo que se realiza en cada una de ellas, para que usted tenga una referencia de lo que implica desarrollar una aplicación que cumpla con todas las expectativas del usuario. También se revisará la estructura de un algoritmo y cómo debemos implementarlos aplicándolos a la resolución de problemas de la vida real.
La temática abordada abordada en esta unidad está vinculada vinculada con el capítulo capítulo 6 del texto básico. básico.
3.1. Ciclo de desarrollo El desarrollo de aplicaciones informáticas involucra una serie de fases que se tienen que ir cumpliendo para la obtención del producto producto final. El conjunto conjunto de estas fases se conoce con con el nombre de Ciclo de Desarrollo. Existen diversos autores y metodologías que plantean sus propias fases y denominaciones para el ciclo de desarrollo, pero podemos resumirlas en las siguientes: 1. 2. 3. 4. 5.
Análisis Diseño Codificación Pruebas e implantación Mantenimiento Revisemos ahora las actividades que se realizan en cada una de las fases del ciclo de desarrollo, así como también los entregables que se deben generar en cada fase, para ello sírvase estudiar los apartados del capítulo 6 de su texto texto básico: Procedimiento de de creación de un programa e Implementación práctica del ciclo de desarrollo.
Una vez que haya concluido concluido con la revisión de los apartados del texto base, base, puede darse cuenta que el desarrollo de una aplicación informática para la automatización de procesos de negocio no es nada trivial, por lo que se requiere de un gran equipo de trabajo y de una adecuada planificación para lograr el objetivo final. En la actualidad dos de las metodologías de software más usadas para el desarrollo de sistemas informáticos de nivel empresarial son MSF (Microsoft Solution Framework) y RUP (Rational Unified Process). Estas metodologías constituyen un marco referencial que se debe ajustar para cada equipo, proyecto y empresa. A continuación se presenta las fases que proponen dichas metodologías.
27
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
Figura 3.1. Modelo de Procesos del MSF4
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
Figurar 3.2. Modelo de Procesos del RUP5
4. Microsoft. (2002): MSF Process Model v. 3.1, [En línea] Disponible en: http://www.microsoft.com/msf [Consulta 15-06-2009] 5. Jacob, I., Booch, G. y Rumbaugh, J. (2004), El Proceso Unificado de Desarrollo de Software, España, Pearson Educación.
28
E C I D N Í
Guía didáctica: Lógica de la Programación
3.2. Determinación de requerimientos Vamos a iniciar este tema definiendo lo que es un requerimiento. La definición que aparece en [IEEE, 1990] es la siguiente: Una condición o capacidad que un usuario necesita para resolver un problema o lograr un objetivo.
Para poder determinar de forma clara los requerimientos del cliente, usted debe revisar el apartado “ Analizar el caso real” del capítulo 6 de su texto básico, en donde se explica en forma detallada y ordenada las actividades que debe realizar para poder completar de forma acertada la etapa de obtención o determinación de requerimientos. Es importante señalar también que la gran cantidad de calificativos que se aplican al término requerimiento muestran distintos aspectos ortogonales que a menudo se consideran aisladamente. Para intentar clarificar la situación, se puede identificar tres dimensiones en las que se pueden clasificar los requerimientos; estas tres dimensiones son: •
Ámbito: Indica en qué ámbito se debe entender el requerimiento. En general, y siguiendo entre otras las propuestas de [IEEE, 1997], [DOD, 1994] y [DAV, 1993], un ámbito de sistema indica que el requerimiento debe cumplirse a nivel de sistema, entendiendo por sistema un conjunto de hardware y software.
•
Característica que define: Clasifica los requerimientos en función de la naturaleza de la característica del sistema deseada que se especifica. La clasificación más habitual suele ser la de requerimientos funcionales (qué funciones debe realizar el sistema) y no funcionales (otras características del sistema).
•
Audiencia: Indica la audiencia a la que está dirigido el requerimiento, es decir, las personas que deben ser capaces de entenderlo. En general, se pueden distinguir dos tipos de audiencia, los clientes y usuarios, que no tienen por que tener formación en ingeniería del software, y los desarrolladores de software. Cuando la audiencia está formada por clientes y usuarios, la forma más habitual de definir los requerimientos es mediante lenguaje natural. En el caso de que la audiencia prevista esté formada por desarrolladores de software, los requerimientos suelen expresarse mediante un modelo, normalmente utilizando técnicas estructuradas, orientadas a objetos o formales.
29
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
Figura 3.3. Dimensiones de los requerimientos6
3.3. Estructuración de pasos del algoritmo Estimado estudiante, para este tema, estudie el apartado “ Algoritmos” del capítulo 6 de su texto básico, incluidos los ejercicios. Antes de desarrollar nuestro primer algoritmo, es preciso dar una definición: Un algoritmo es un conjunto de pasos ordenados lógicamente que permiten realizar un tarea.
En base a esta definición podemos determinar el siguiente proceso al momento de construir nuestros algoritmos: 1. 2. 3.
Identificar los datos de entrada. Determinar el procesamiento al que deben someterse los datos de entrada. Identificar los resultados que se esperan.
Por ejemplo: Se requiere calcular el área de un terreno rectangular cuyas dimensiones son:
Largo: Ancho:
10 metros 20 metros
En base a estos datos elaborar un algoritmo que permita presentar el área de dicho terreno. 1.
Identificamos los datos de entrada: Dimensiones del terreno (largo y ancho)
2.
Identificamos el proceso que debemos seguir para calcular el área, en este caso, será: Área = largo * ancho
6. Monografías. (2004): Dimensiones de la Ingeniería de Requerimientos , [En línea] Disponible en: http://www.monografias. com/trabajos26/sistema-documentacion/sistema-documentacion2.shtml [Consulta 15-06-2009]
30
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
3.
Presentamos el resultado (Área) al usuario
Note que el algoritmo está compuesto de esos 3 pasos principales, aún no se ha utilizado los tipos de datos ni la creación de variables, este tema será cubierto en la siguiente sección de la guía, aquí nos limitamos a ver únicamente la estructuración general del algoritmo. Bien, realicemos el siguiente ejercicio.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
Ejercicio 3.1
Elaborar un algoritmo que permita determinar el área de un triángulo equilátero cuyo lado es 5 cm. O E D R N T S U E G M E I S B
3.4. Resolución de problemas mediante algoritmos Revise los ejercicios resueltos en su texto básico, los mismos que se encuentran en el apartado “Analizando los casos y diseñando sus algoritmos” del capítulo 6, para que complete la resolución de los problemas que se plantean a continuación:
Ejercicio 3.2 El programa debe mostrar el factorial de un número ingresado por el usuario. El factorial de un número entero positivo se define como el producto de todos los números naturales anteriores o iguales a él. Por ejemplo:
O I R A N O I C U L O S O I R A S O L G
5! = 5 * 4 * 3 * 2 * 1 = 120 S A I O D S E R M U I C T E L R U M
El símbolo ! indica factorial. Utilice los espacios siguientes para el desarrollo. Análisis del caso
Área del conocimiento Matemática elemental Análisis de los elementos del todo
31
E C I D N Í
Guía didáctica: Lógica de la Programación
Unidades de funcionalidad ID 1
Unidad de funcionalidad
Prioridad
S E R A N I M I L E R P
Obligatoriedad
E R R E T S M I E R M P I B
Interfaz
O E D R N T S U E G M E I S B O I R A N O I C U L O S
Algoritmo 1 2
Inicio
3 4
O I R A S O L G
5 6
S A I O D S E R M U I C T E L R U M
Simulación Supongamos que ingresamos el número 4, el programa debería mostrar lo siguiente:
Ingrese el número para obtener su factorial: 4
El factorial de 4 es 24
32
E C I D N Í
Guía didáctica: Lógica de la Programación
EJERCICIOS
Una vez que usted ha profundizado en los temas de la unidad, es el momento que desarrolle su primer ejercicio de algoritmos. 1.
Desarrolle el caso 6: Regla de tres simple, del apartado Ejercicio 06.01 del texto básico.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
Autoevaluación 3
¡Felicitaciones¡ ¡Ha concluido el primer bimestre ¡ sólo le falta revisar su nivel de comprensión de los algoritmos resolviendo el examen rápido del capítulo 6 del texto básico.
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
33
E C I D N Í
Guía didáctica: Lógica de la Programación
N Ó I C A U L A V E
a s l e n n e o s a i c c e i a d t c u a á l a d d i v i d e n u o a t r í u o u A p g •
S S O O I o S C c R T i s U C á C Á b E D o t R I D x e T •
a s e n o i a i c c a n u a l t a i v s E d •
E R T S E M I B O D N U G E S
o n m u l a l e d o j a b a r t l e a r a p n ó i c a c i f i n a l P . 4 . 7
S E R A N I M I L E R P
s s e e n l a o i i c c a n u e l s a e v r E p • •
E R R E T S M I E R M P I B
, s e : l e d a a j a . c u a d i z i s t t i r c i v o t i á V d t n o n d c e i o e n r a D n , o r p s m f u a o í t A o c é l r u n e o o e G E d f d T •
•
a l E n e D E s S J a a e d E A c a d i Z v s I a t D i c e s o d A D l d n á n l N D d a e o e i I E a r r r r d d V i m p I R u a v a i o í T P t m s c t c C A e o e c e u L c D a r g A • • o 1 A O d 1 a y M V m 0 A I i 1 e e t R T o n s , G A d T e 9 d i d O N o a s u s ó i a a N E r t r c c s I p n O R m a o e o a h r R O e m h o e C i e 4 t 2 t T S 2 u n a 1 i
.
s o l n e n ó i c a p i . c s i t r o a r o P f
e d s s a s e S a r u l c t O m e c u D T B I / u r y N s t E e s n T d E : ó i N a 4 s i d O i c C n d a e d U d i n U
o c i n ó r t c e l e o e r r o C • • o l l l a e o r n r ó n a i o s c e c a n d l u . ó l i a e a i c c d v c e a o a n r a i e c l t i t A s e i V n E I n d d I • •
s l o o r a t i r a i v n o t m c t o i a r c e r l c e g e s s d E o r s s p a s e a r a d e r s u d u t t d a a c s c s b d e u i l o u j r c r n e t t u r l s u s a u F E B E P 1 5 . 2 . 3 . 4 . . 4 4 4 4 4 s . l n o o ó s a i r r E E m t s a c o t J i n D a u m r n s e b p c t o a n a d o S A c e i o Z e r j g i t ó s y u i O I l r m e o i a r a D o V e o c l r n p t a l g I N r m d l i u u r T E a e l b n t ó r r a r i r E o a c c a c a s J R o p o s r i z s d c i z u o p e r l i B P b e e e l i l t l t e l a u r e i e t s O A l a e a d u e s U d v d E q l • • r a o s r l l S o o u A l S a s I A r a r , , r y . s s a C v s , a N C o s s o p r I e o , r s o s c o c e E Í F d t o r s a a e i n i c e i c i o t n d g n T C r e t i i o á m t c r e o y ó i E E e m s n a r i c l í P P n m c ó s o o a o a a e p d c r c s n M S p d e i a n c e l i u n s n t t a o c l t e O E i f e c s l p u m e e y n i n e C D f s e e t a •
a l n e s a a e d c a d i v s a t i c s l o e d á n l d n d a e o e i a r r r r d d i m p u a v t a i o í c m s t c e o e c e u L c D a r g • • s a c i t 2 c 1 á r a o p n e i e a d d d u m s t s e a s e a r S r o o o h t h u 8 a 4
e d s a m a r g o a j i u D l . f 5 d a d i n U
e n d a o o n c l ó i r l c a a o r a i u r u c a l n i a n t s a e t n d v s o l e i a C e l d •
l e l n e e d o t n s ó i e c u a p p o r i c p i t A r o a r o V P f E •
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
s a m a r o g j o a n j i u l u e f d u l e f d e n d e n d o s d ó s c i o t a c a s o o i n m a r m c j a e a i r o r l u r f m g b g c a a e e a l i l i j e E d E d E d 1 2 3 . . . 5 5 5
S A I O D S E R M U I C T E L R U M
. e o o d j s j o u u l l l n f f ó e e e i d d s d c . u s a s o s l a í l l a a o a g r o r e l m a m s e m e c o a e a l l r r o b r a b p g g l n a a n o m o i i m i r C s d E d e p • • r e v e a l r d o a , s l r o s s t o e a . e e l s e n p r n . s s e a u a d y a o d y í a d i l a a i a m r i r d d s r m n r r e o m e a i i a e e r a e n d c i z n c s s v l l z a p i l i l e o e b e n l b i c o e t i a c n c o m a o l é o s g n e o e e r o n r p c a n A n c n r p C a p a m l i • •
34
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
E R R E T S M I E R M P I B
a l n e s a a e d c d s a i t c e o d l á l d n d a o e i r r d d i m a v a o í s i t c e c e u D a r g •
l e l n e e d o t n s ó i e c u a p p o r i c p i t A r o a r o V P f E •
l e . a d l l e a a i a r t e n r a c s e l d ó i . p n e l c o a n e m s i r l a i ó e b r a o u c i l z r a n c p o i l r a a a a r a d t s v e i s a b n n e i a d p e u F d l e r g r u • P p e s
4 1 y 3 o n 1 e i e a d d i d ó u n s a s c a r t c s o e a r a m h r o o e e h S 6 t u t n 1 a 8 i o l l e o d n r r s ó a a i c s e m a e D l m . a 6 b o r d r g a p o r d e p i d n U
O E D R N T S U E G M E I S B
s e a n n o u i c e a d c i e l s n e d ó p e i t n d c n a ó o i s a e n l c o m n ó s i l c i a o c o r a c a l r l i r p a r i t a c c i s r g m l s c e o b j r o p e n A e p C a D e s 1 2 3 . . . 6 6 6
O I R A N O I C U L O S
6 1 y 5 1 a n a m e S
O I R A S O L G
6 a l a 4 a l e d d a d i n U
S A I O D S E R M U I C T E L R U M
o d n e . a d n z s i l ó s t i t a r e i a n u n c l e a l i o s i m o a r l m a l r c r a i a a c c r g s i l r e p n e o r D a e s h p • , o l s l l o a , , i t o a n n n u , r r . c e ó i e e d i ó s n a c i r d o g a c c i i ó s e s a ó c c d m l i c o a t c t t e i a t x c u y e i a á l r d m y p e o n s o r i r a o e a m t m g r s i c e n l l g i i o C o p ñ e l t á c s C n i o a p a l o s r n e a a A m e l l c d p a d •
35
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
7.5. Orientaciones específicas para el aprendizaje por competencias
UNIDAD 4. ESTRUCTURAS DE DECISIÓN Y BUCLES El propósito de la presente unidad es dar a conocer el funcionamiento y utilidad de las estructuras de decisión y control, así como también su uso en el desarrollo de algoritmos para la resolución de problemas. Se revisará también mecanismos que le permitan comprobar si el algoritmo desarrollado funciona o no correctamente.
O E D R N T S U E G M E I S B
La temática abordada en esta unidad está vinculada con el capítulo 7 del texto básico.
4.1. Flujos de programa Es preciso iniciar dando una definición de lo que es un programa: Secuencia lógica de instrucciones que manipulan o procesan un conjunto de datos para obtener resultados que corresponden a la solución del problema.
En base a esta definición podemos indicar que la ejecución o flujo de un programa consiste en la realización secuencial del conjunto de instrucciones desde la primera a la última y de una en una. Este orden de realización únicamente será alterado mediante las estructuras de decisión y control (bucles). Los procesos que se pueden llevar a cabo en un programa pueden ser de tipo aritmético o lógico, incluyéndose algunas operaciones de manejo de caracteres y operaciones de entrada y salida. Una vez que tenemos clara la definición de Programa y cómo es su flujo o ejecución, ahora pasaremos a revisar los componentes o partes principales que lo conforma, en el siguiente cuadro podemos observar que básicamente un programa está compuesto por dos bloques, uno de declaraciones y otro de instrucciones. Declaraciones Declaraciones
Entrada de datos
PROGRAMA Proceso Instrucciones
E R R E T S M I E R M P I B
Salida de resultados
Figura 4.1 Estructura de un programa
36
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Bloque de declaraciones En él se especifican todas las variables que serán usadas por nuestro programa o algoritmo. Se debe indicar el nombre de la variable, el tipo de dato y su dominio. Por ejemplo, si queremos declarar la variable base, debemos hacerlo de la siguiente manera: (Nombre variable, Símbolo Tipo de dato [Dominio]) (base, i[1-n])
En donde, base corresponde al nombre de la variable, i al tipo de dato entero y 1-n al dominio, es decir en este caso, números mayores o iguales a 1. Para conocer los símbolos de los tipos de datos, sírvase revisar el apartado “Representación abstracta de tipos base” del capítulo 4 de su texto base.
Bloque de instrucciones Está formado por el conjunto de operaciones que se han de realizar para la obtención de los resultados deseados. Según lo indicado en la Figura 4.1, tenemos los siguientes tipos de operaciones: a.
Entrada de datos.- 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.
b.
Procesamiento de datos.- Está formado por las instrucciones que modifican los datos a partir de su estado inicial (datos de entrada) hasta el estado final (resultados).
c.
Salida de resultados.- Conjunto de instrucciones que toman los datos finales (resultados) de la memoria central y los envía a los dispositivos externos.
Ahora bien, procederemos a adoptar un estándar al momento de escribir nuestras instrucciones que formarán parte del programa o algoritmo. De acuerdo al tipo de instrucción u operación que vayamos a emplear, tenemos lo siguiente: a.
Declaración (Nombre variable, Símbolo tipo de dato [Dominio])
(lado, i[1-n]) b.
Cambio de estado (Asignación) Nombre de variable ←Expresión
lado ← 10
c.
Lectura de datos (Petición) >> Nombre de variable
>> lado
37
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
d.
Muestra de datos << Expresión
<< lado
Estimado estudiante, usted debe revisar el apartado “Operaciones a nivel dato” del capítulo 7 de su texto básico.
4.2. Estructuras selectivas Las estructuras selectivas permiten realizar la evaluación de expresiones lógicas, para controlar la ejecución de una o más instrucciones. Existen principalmente dos tipos de estructuras selectivas o condicionales que son: a.
Condicional simple
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S
Si Expresión lógica entonces
Instrucciones a ejecutar si la expresión lógica es True (verdadera) Fin si
Ejemplo:
O I R A S O L G
Si edad >= 18 entonces
>> “Usted es mayor de edad” Fin si
b.
S E R A N I M I L E R P
Condicional compuesto S A I O D S E R M U I C T E L R U M
Si Expresión lógica entonces
Instrucciones a ejecutar si la expresión lógica es True (verdadera) De lo contrario
Instrucciones a ejecutar si la expresión lógica es False (falsa) Fin si
Ejemplo: Si edad >= 18 entonces
>> “Usted es mayor de edad” De lo contrario
>> “Usted es menor de edad” Fin si
38
E C I D N Í
Guía didáctica: Lógica de la Programación
Para aclarar estos conceptos, por favor proceda a realizar la lectura del apartado “Estructuras de decisión” del capítulo 7 de su texto básico.
4.3. Bucles Los bucles también conocidos como ciclos repetitivos o estructuras de control, permiten realizar la ejecución de un conjunto de instrucciones de manera repetitiva mediante la evaluación de una o más condiciones lógicas o por medio de un contador asociado. Antes de proceder a revisar los bucles que usaremos en el desarrollo de nuestros algoritmos, es preciso aclarar dos conceptos clave al trabajar con ciclos repetitivos, estos conceptos son: contadores y acumuladores. a.
Contadores Un contador es una variable que se utiliza para contar cualquier evento que pueda ocurrir dentro de un programa. Generalmente se suele contar desde 0 y con incrementos de uno en uno. Para utilizar correctamente un contador primero de lo debe inicializar y luego incrementar; así tenemos:
b.
contador ← 0
Inicialización
contador ← contador + 1
Incremento de 1 en 1
Acumuladores
Un acumulador es una variable que se utiliza para acumular elementos sucesivos con una misma operación. Generalmente se usan para calcular sumas o productos. Al igual que los contadores primero se los debe inicializar y luego realizar la operación de acumulación; así tenemos:
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
suma ← 0 suma ← suma + expresión Una vez que hemos revisado lo que es un contador y un acumulador, podemos empezar a estudiar los bucles (loop), para ello lo invito a realizar la lectura del apartado “Estructuras de Control” del capítulo 7 de su texto básico. Cabe señalar que dependiendo del lenguaje de programación que se use, existen varios ciclos repetitivos que podemos emplear, sin embargo son derivaciones de los dos tipos de bucles que explicaremos a continuación. a.
S E R A N I M I L E R P
Bucles de comparación al inicio Inicialización del contador
Mientras Expresión lógica Entonces Uso del contador Instrucciones a ejecutar si la Expresión lógica es True (verdadera)
39
E C I D N Í
Guía didáctica: Lógica de la Programación
Fin Mientras Ejemplo: Escribir los números dígitos.
S E R A N I M I L E R P
numero ← 0 Mientras numero < 10 Entonces << numero numero ←numero +1
Fin Mientras
E R R E T S M I E R M P I B
El resultado del ejemplo es: 0 1 b.
2
3
4
5
6
7
8
9 O E D R N T S U E G M E I S B
Bucles de comparación al final Inicialización del contador
Inicio Instrucciones a ejecutar si la Expresión lógica es True (verdadera) Uso del contador Hasta que Expresión lógica
O I R A N O I C U L O S
Ejemplo: Escribir los números dígitos. numero ← 0 Inicio
O I R A S O L G
<< numero numero ←numero +1 Hasta que numero >= 10
El resultado del ejemplo es: 0
1
2
3
4
5
6
7
8
9
Como puede darse cuenta el resultado en los dos ejemplos es el mismo, por lo que podemos usar en este caso particular cualquiera de los dos bucles, ahora bien, lo invito a contestar la siguiente interrogante una vez que haya realizado la lectura del apartado Estructuras de Control de su texto básico, ¿Cuál es la diferencia entre un bucle de comparación al inicio y un bucle de comparación al final?
4.4. Estructuras de control anidadas Se conoce como estructuras de control anidadas a la combinación o uso de las estructuras de decisión y/o ciclos repetitivos (bucles) en la elaboración de un algoritmo. En otras palabras, cuando una estructura de control se coloca dentro de otra, se dice que está anidada. Las estructuras de control pueden anidarse en tantos niveles como se desee. A fin de que las estructuras anidadas sean más fáciles de leer, utilizaremos como una práctica habitual el aplicar sangría al cuerpo de cada una de las instrucciones anidadas.
40
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
Ejemplo 4.1 Determinar si la edad de una persona es la correcta para sufragar. Si edad >= 18 entonces Si edad < 65 entonces
E R R E T S M I E R M P I B
<< “Usted debe sufragar obligatoriamente” Caso Contrario
<< “Usted puede sufragar opcionalmente” Fin Si Caso Contrario << “Usted no puede sufragar”
O E D R N T S U E G M E I S B
Fin Si
Como usted puede apreciar en el ejemplo 4.1, se ha utilizado anidamiento en la estructura de decisión (condicional) para resolver el problema en mención. Cabe indicar también que existen varias soluciones a dicho problema, las mismas que están relacionadas con la capacidad de cada persona para comprender, encontrar y plasmar dichas soluciones en un algoritmo. Esta capacidad se desarrolla mediante la práctica continua, por lo que lo invito desde ya a plasmar los conocimientos aquí aprendidos, mediante la realización de ejercicios que permitan potenciar su habilidad para la resolución de problemas computacionales. Ahora bien, una vez que hemos estudiado las estructuras de decisión y bucles, estamos en la capacidad de desarrollar algoritmos que nos permitan resolver diferentes tipos de problemas, para ello vamos a hacer uso de las Miniespecificaciones, que también son conocidas como Pseudocódigo, es decir un lenguaje neutral, que sin llegar a la rigidez de la sintaxis de un lenguaje de programación ni a la fluidez del lenguaje coloquial, permite codificar un programa o algoritmo con mayor agilidad. Estimado estudiante, lo invito a realizar la lectura del Apartado “Miniespecificaciones” del capítulo 7 de su texto básico. Una vez que usted ha realizado la lectura indicada es posible que hayan surgido algunas dudas, mismas que intentaremos aclarar con el ejemplo siguiente.
Ejemplo 4.2 Traducir a miniespecificación el ejemplo 4.1 sobre la edad de una persona para sufragar.
41
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Observe el siguiente planteamiento. 1 2 3 4 5 6
S E R A N I M I L E R P
INICIO: (edad, i[1..160]) << “Ingrese su edad en años: ” >> edad Si edad >= 18 entonces
E R R E T S M I E R M P I B
Si edad < 65 entonces
7 << “Usted debe sufragar obligatoriamente” 8
O E D R N T S U E G M E I S B
Caso Contrario
9 << “Usted puede sufragar opcionalmente” 10 11 12 13 14
Fin Si Caso Contrario << “Usted no puede sufragar”
O I R A N O I C U L O S
Fin Si
:FIN
En la miniespecificación podemos observar las siguientes instrucciones: -
(edad, i[1..160]) << “Ingrese su edad en años: >> edad
Declaración de la variable edad Presentación de un mensaje Lectura de datos sobre la variable edad
4.5. Pruebas de escritorio En la sección anterior usted aprendió a desarrollar algoritmos utilizando las miniespecificaciones, ahora bien lo que necesitamos saber es si nuestro algoritmo funciona correctamente, en decir si hace lo que tiene que hacer ¿cómo podemos verificar este cometido?, para poder comprobar esto, nos valemos de las pruebas de escritorio que no son más que pruebas manuales que permiten visualizar el estado de las variables durante la ejecución del programa, lo que nos permitirá saber en donde se encuentra el error, para proceder a su corrección. Estimado estudiante, para comprender el ejercicio que a continuación está resuelto, usted debe revisar primero los ejercicios de su texto básico en el capítulo 7, en el apartado “Miniespecificaciones de los casos prácticos”. Para llevar a cabo las pruebas de escritorio, vamos a resolver el siguiente ejemplo:
42
O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Ejemplo 4.3
Elaborar un algoritmo utilizando miniespecificaciones, que permita leer el nombre y el sueldo mensual de 4 empleados, se debe presentar el nombre y el sueldo del empleado que más gana así como también del que menos gana. Si se repite el mayor o menor sueldo se presenta el primero que se encuentre . Para resolver este problema, primero debemos identificar claramente cuáles van a ser las salidas, el proceso y las entradas, para poder desarrollar con éxito la miniespecificación; así tenemos:
S E R A N I M I L E R P
E R R E T S M I E R M P I B
Enunciados de las Salidas • • •
O E D R N T S U E G M E I S B
Se debe presentar el nombre y el sueldo mensual del empleado que más gana. Se debe presentar el nombre y el sueldo mensual del empleado que menos gana. Si se repite el mayor o menor sueldo se debe presentar el primero que se encuentre.
Enunciados del proceso •
Se debe hacer uso de un bucle para solicitar el ingrese de los 4 empleados.
•
Para obtener el empleado que más gana, se debe comparar los datos ingresados mediante un condicional y dependiendo si el sueldo ingresado es mayor al anterior, se lo almacena en una variable, que finalmente será la que se presente como resultado final, al terminar la ejecución del bucle.
•
Para obtener el empleado que menos gana, se debe comparar los datos ingresados mediante un condicional y dependiendo si el sueldo ingresado es menor al anterior, se lo almacena en una variable, que finalmente será la que se presente como resultado final, al terminar la ejecución del bucle.
Enunciados de la entrada •
Se debe ingresar el nombre de 4 empleados junto con su sueldo mensual.
Una vez que tenemos claro lo antes mencionado, necesitamos declarar variables para almacenar el nombre del empleado y su sueldo mensual, también necesitamos variables para almacenar el nombre de la persona que más gana y su sueldo, así como también el nombre de la persona que menos gana y su sueldo. Luego tenemos que ir comparando el sueldo de cada empleado que se ingresa para poder determinar el mayor y menor valor, para ello emplearemos la estructura de decisión, y para controlar que nos ingrese 4 empleados nos valdremos del bucle de comparación al inicio (Mientras). En base a todo esto procedemos a escribir nuestra miniespecificación.
43
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
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 34
INICIO:
S E R A N I M I L E R P
(nombre,x(50)) (sueldo,d[0-n]) (nombreMaySueldo,x(50)) (sueldoMayor,d[0-n]) (nombreMenSuedo,x(50)) (sueldoMenor,d[0-n]) (num, i[0-n]) << “Ingrese el nombre y el sueldo” >> nombre >> sueldo nombreMaySueldo ← nombre sueldoMayor ← sueldo nombreMenSuedo ← nombre sueldoMenor ← sueldo num ← 2 Mientras num <= 4 entonces
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
num ← num +1 << “Ingrese el nombre y el sueldo” >> nombre >> sueldo Si sueldo > sueldoMayor entonces sueldoMayor ← sueldo nombreMaySueldo ← nombre Caso Contrario Si sueldo < sueldoMenor entonces sueldoMenor ← sueldo nombreMenSueldo ← nombre Fin Si Fin Si Fin Mientras << “El empleado que más gana es: ” + nombreMaySueldo + “con un sueldo de: $ ” + sueldoMayor << “El empleado que menos gana es: ” + nombreMenSueldo + “con un sueldo de: $” + sueldoMayor :FIN
Una vez que hemos escrito la miniespecificación, realizamos la prueba de escritorio, para verificar si nuestro algoritmo es o no correcto. Para ello indicaremos mediante el uso de tablas el estado (valor) de las variables durante la ejecución del programa. Supongamos que ingresamos los datos de los siguientes 4 empleados: Nombre : Luis Sueldo mensual : $ 700 Nombre : María
Sueldo mensual : $ 800
Nombre : José
Sueldo mensual : $ 400
Nombre : Jorge
Sueldo mensual : $ 1000
44
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
A la línea 16, la tabla luciría así: Variable nombre sueldo nombreMaySueldo sueldoMayor nombreMenSueldo sueldoMenor num
S E R A N I M I L E R P
Valor Luis 700 Luis 700 Luis 700 2
E R R E T S M I E R M P I B
En la primera repetición dentro del bucle Mientras entre la línea 17 y 31, el resultado ser ía el siguiente: Variable nombre sueldo nombreMaySueldo sueldoMayor nombreMenSueldo sueldoMenor num
Valor María 800 María 800 Luis 700 3
O I R A N O I C U L O S
En la segunda repetición dentro del bucle Mientras entre la línea 17 y 31, el resultado ser ía el siguiente: Variable nombre sueldo nombreMaySueldo sueldoMayor nombreMenSueldo sueldoMenor num
Valor José 400 María 800 José 400 4
O I R A S O L G
S A I O D S E R M U I C T E L R U M
En la tercera repetición dentro del bucle Mientras entre la línea 17 y 31, el resultado sería el siguiente: Variable nombre sueldo nombreMaySueldo sueldoMayor nombreMenSueldo sueldoMenor num
O E D R N T S U E G M E I S B
Valor Jorge 1000 Jorge 1000 José 400 5
45
E C I D N Í
Guía didáctica: Lógica de la Programación
A la línea 32, tendremos:
S E R A N I M I L E R P
“El empleado que más gana es: Jorge con un sueldo de: $ 1000” A la línea 33, tendremos: “El empleado que menos gana es: José con un sueldo de: $ 400” Con lo que podemos concluir que el algoritmo es correcto gracias a la prueba de escritorio que hemos ejecutado.
E R R E T S M I E R M P I B
EJERCICIOS 4.1
En base al ejercicio del cálculo de la edad de una persona explicado en la Unidad 1 de la presente guía didáctica, realice las pruebas de escritorio, siguiendo la miniespecificación propuesta para dicho problema. Utilizar los siguientes datos de prueba: Fecha de nacimiento: Fecha actual: 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
01/10/1985 03/07/2009
O E D R N T S U E G M E I S B O I R A N O I C U L O S
INICIO: (anio_n, i[1900-2009]) (mes_n, i[1-12]) (dia_n, i[1-31]) (anio_a, i[1900-2009]) (mes_a, i[1-12]) (dia_a, i[1-31]) (edad_a, i[0-150]) (edad_m, i[0-12]) (edad_d, i[0-31]) <<”Ingrese la fecha de nacimiento en años, meses y días” >> anio_n >> mes_n >> dia_n <<”Ingrese la fecha actual en años, meses y días” >> anio_a >> mes_a >> dia_a Si dia_n > dia_a entonces dia_a ← dia_a + 30 mes_a ← mes_a -1 Fin Si edad_d ← dia_a – dia_n Si mes_n > mes_a entonces mes_a ← mes_a + 12 anio_a ← anio_a – 1 Fin Si
O I R A S O L G
S A I O D S E R M U I C T E L R U M
46
E C I D N Í
Guía didáctica: Lógica de la Programación
28 29 30 31 32 33 34 35
edad_m ← mes_a – mes_n Si anio_n > anio_a entonces << “Error: la fecha de nacimiento es mayor a la actual” Caso Contrario edad_a ← anio_a – anio_n << “Edad: ” + edad_a + edad_m + edad_d Fin Si
S E R A N I M I L E R P
E R R E T S M I E R M P I B
:FIN
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
EJERCICIOS
Le recuerdo que la asignatura es práctica, por ello lo invito a desarrollar el siguiente ejercicio. 1.
Desarrolle el caso 6: Regla de tres simple, en el apartado Ejercicio 07.01 del texto básico.
Autoevaluación 4
¿Qué tanto logró comprender de este tema? Mida su avance resolviendo el examen rápido del capítulo 7 del texto básico.
47
E C I D N Í
Guía didáctica: Lógica de la Programación
UNIDAD 5. DIAGRAMAS DE FLUJO Una vez que ha aprendido cómo resolver problemas utilizando las diferentes herramientas de la lógica de programación, vamos a continuar nuestro estudio con una técnica visual de programación conocida como Diagramas de flujo de programa, la cual le ayudará a comprender mejor la manera de resolver problemas de programación.
El propósito de este capítulo es enseñarle a utilizar los diagramas de flujo de programas utilizando el estándar ANSI/ISO 5887-1985 para diagramas de flujo, por lo que usaremos como referencia el capítulo 8 del texto básico. Comencemos estudiando algunos preliminares sobre este tema en al apartado “Diagramas de flujo” del capítulo 8, solamente hasta las “Reglas para la elaboración de un diagrama de flujo “. Como habrá notado, los diagramas de flujo de programa son una poderosa herramienta para expresar la lógica de la programación, pero se debe tener en cuenta algunos principios que se plantean efectivamente en el texto, otro aspecto es que los símbolos a usarse deben corresponder a una notación estándar para que todos entiendan lo que se quiere expresar con el mismo. En este punto podría ser útil plantearse la interrogante ¿Si ya puedo escribir miniespecificaciones, para qué me sirven los diagramas de flujo? El texto menciona que para hacer los diagramas de flujo, no es necesario tener la miniespecificación, y esto es verdad, pero ¿cuál de los dos debo usar?, ¿es necesario desarrollar ambos?
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
La respuesta a estas preguntas las podemos encontrar en los siguientes planteamientos: 1.
La notación visual ayuda a tener una apreciación completa de la solución que difiere de la obtenida en las miniespecificaciones, esto gracias a una mejor visualización lograda con el uso de los símbolos gráficos.
2.
La notación estándar permite una comunicación más efectiva, lo cual convierte a los diagramas de flujo en una excelente herramienta para documentar los programas.
3.
La lógica de programación debe expresarse en un lenguaje independiente de cualquier lenguaje de programación, las mini especificaciones tienden a inclinarse a uno u otro lenguaje lo cual incide en el código de la miniespecificación, en tanto que los diagramas de flujo son totalmente independientes de cualquier lenguaje de programación.
En base a estas premisas, obtenga sus propias conclusiones.
5.1. Elementos de un diagrama de flujo Un diagrama de flujo básicamente está conformado por símbolos y reglas. Si usted recapitula un poco, se dará cuenta de que hay correspondencia entre estos símbolos y las sentencias válidas de un programa, por lo que se puede dibujar un diagrama de flujo a partir de una miniespecificación o hacerlo sin ella.
48
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
En cuanto a los símbolos, los Diagramas de Flujo de Programa tienen 4 categorías que son: • • • •
S E R A N I M I L E R P
De datos (entrada/salida), ingresar o mostrar datos. De preparación de datos. De proceso. Especiales.
ENTRADA/SALIDA DE DATOS Para entrada o salida de datos se usa el símbolo al cual se le debe indicar si se trata de un ingreso de datos (GET) o una presentación de datos (PUT), aunque esto en realidad no corresponde al estándar, tal como lo menciona el autor del libro, por lo que se puede usar otro tipo de notación para indicar si se trata de una entrada o una salida. Otro aspecto que no se menciona en el libro es la posibilidad de combinar un mensaje de solicitud de datos con una entrada de datos, en realidad sería una entrada de datos acompañada de un mensaje de petición para el usuario como lo podemos apreciar en la figura 5.1, en la cual se ha colocado dos posibilidades para el ingreso de los datos. En la práctica muchos programadores que se enfocan en la solución de un problema consideran que no es necesario colocar mensajes de entrada de datos, puesto que esos son detalles de implementación, en tal virtud podría ser suficiente utilizar PUT para mostrar resultados y GET para obtener valores en cuyo caso se colocará únicamente el nombre de las variables en las que se almacenarán los datos.
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
s
“Ingrese u n número”
E R R E T S M I E R M P I B
E
“Ingrese u n núm ero”, num
S A I O D S E R M U I C T E L R U M
E
num
Figura 5.1 Formas de utilizar le símbolo de entrada/salida de datos SIMBOLO DE PROCESOS En esta categoría tenemos varios símbolos de proceso que tal como se encuentra explicado en el texto básico, son usados en la mayoría de notaciones, en este punto simplemente comentaremos algunos aspectos. Si lo piensa un poco, la preparación de datos definida en símbolo , podría bien realizarse con el , no habría problema en hacerlo, pero la preparación de datos normalmente símbolo de proceso no forma parte del problema, es por ello que al tratarse de programación visual se tiene una visión más clara del problema si se diferencian este tipo de procesos.
49
E C I D N Í
Guía didáctica: Lógica de la Programación
Con relación al símbolo vale realizar una aclaración importante, puesto que en la descripción se habla de un proceso nominado, que en términos un poco más cercanos a nuestra jerga, serían invocaciones a subrutinas las cuales son partes de programa que cumplen una tarea y concluyen devolviendo el control al programa desde el que fueron llamadas. El símbolo se usa para representar procesos que se ejecutan al mismo tiempo, en la mayoría de programas de procesamiento de datos no es tan usual que esto suceda puesto que la mayoría de situaciones se procesan de manera secuencial, en otros contextos el uso de procesos paralelos es indispensable, quizá uno de los campos donde mayor aplicación tienen este tipo de procesamiento son los juegos en donde cada elemento tiene su comportamiento independiente de las acciones del usuario, es decir no esperan una orden del usuario para actuar sino, que funcionan principalmente controlados por eventos que normalmente pueden estar relacionados con el tiempo o alguna acción proveniente del exterior que les obliga a cambiar de comportamiento. Con relación a los símbolos se usan para establecer los límites y las condiciones de ejecución de un bucle o también denominados ciclos repetitivos que estudió en el capítulo anterior. Las líneas de flujo se usan para unir símbolos y nos ayudan a establecer el orden de ejecución de las instrucciones contenidos en los símbolos, estas líneas deben terminar en una punta de flecha para indicar de a dónde va el flujo, además se debe considerar que el orden de lectura normalmente suele ser de izquierda a derecha y de arriba hacia abajo, además estas líneas siempre deben dibujar se en ángulos rectos. SIMBOLOS ESPECIALES Se llaman especiales porque si bien no representan ningún proceso, nos ayudan a identificar el inicio o el final , o la continuación de una sección de diagrama debido a que es muy grande para colocarlo todo junto. Otro símbolo que se puede usar en la categoría de especial es el símbolo de anotación cuyo uso es importante para clarificar varias secciones del programa con comentarios respecto de la lógica utilizada o alguna consideración importante, este símbolo es particularmente importante en secciones del diagrama cuyo nivel de complejidad es alto. El uso de la notación estándar como mencionábamos anteriormente tiene radical importancia, por lo tanto consideraremos como mala práctica el no usar los símbolos definidos o inventar otro tipo de notación.
5.2. Elaboración de diagramas de flujo El desarrollo de diagramas de flujo puede realizarse de dos maneras, la primera es partir de una miniespecificación y la segunda es hacerlo directamente sin ella, en cualquiera de los dos casos debemos tener en cuenta la necesidad de realizar el análisis correspondiente del problema, tal como apreciábamos en el capítulo 1 de la presente guía didáctica, sin este análisis resultará muy complicado tratar de resolver cualquier problema. Vale acotar además que cualquier instrucción dada en miniespecificación tiene su contraparte en los diagramas de flujo, por lo que la traducción podría realizarse de manera directa y viceversa. Una diferencia fundamental es que tanto en las miniespecificaciones conocidas también como pseudocódigo y el código
50
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
de un programa en un lenguaje cualquiera es preciso realizar pasos previos como la declaración de variables donde se especifica el tipo de dato y tamaño de las variables que se van a usar, en los diagramas de flujo esto no es necesario, puesto que como mencionamos antes son detalles de implementación. Para aprender cómo escribir diagramas de flujo, remítase a la sección “Cómo elaborar un diagrama de flujo de programa”del capítulo 8, y estudie detenidamente los primeros diagramas que le van indicando cada una de las estructuras básicas de un diagrama de flujo. En la sección del libro indicada, se ha mostrado como construir un diagrama de flujo para un programa que lea números del 1 al 10 hasta que se ingrese el número 7, y además se lo ha hecho a partir de una miniespecificación. Ahora es posible que se esté preguntando ¿si ya tengo la miniespecificación, para qué hago el diagrama?, para responder a esta pregunta le voy a proponer un ejemplo para que lo analice y luego veamos lo que piensa. Se desea desarrollar un diagrama de flujo para un programa que sea capaz de decir si un número es perfecto. Se considera que un número es perfecto cuando la sumatoria de todos sus divisores exactos es igual al mismo número.
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S
La miniespecificación para este algoritmo sería la siguiente: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
S E R A N I M I L E R P
INICIO: (num, i[0-n]) (cnt, i[0-n]) (sum, i[0-n]) << “Ingrese el número” >> num cnt 1 sum 0 Mientras cnt <= num entonces Si num % cnt =0 entonces << cnt sum sum + cnt Fin si Cnt = cnt + 1 Fin mientras Si sum = num entonces << “El número es perfecto” Fin si
O I R A S O L G
S A I O D S E R M U I C T E L R U M
:FIN
Si traducimos esta miniespecificación a diagrama de flujo obtendríamos el diagrama de la figura 5.2, en el cual se puede apreciar con mayor claridad cuál es la lógica de programación utilizada, esto a pesar de que el código de la miniespecificación es bastante corto, el seguimiento del programa se facilita considerablemente en el diagrama. El programa seleccionado para este ejercicio es relativamente sencillo, sin embargo se presta para mostrar las diferencias entre una y otra técnica de representar la lógica de la programación.
51
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
Inicio
nu m
cnt
E R R E T S M I E R M P I B
1
sum
0 Ver ifica si cnt es divisor d e num, m ediante la busqueda del residuo d e la d ivis ión, si este es 0, es divisor exácto
O E D R N T S U E G M E I S B
cnt < num
( num % cn t) = 0
Si
cnt
sum
O I R A N O I C U L O S
sum + cnt
no
cnt = cnt + 1
O I R A S O L G
cn t
sum = num
si
S A I O D S E R M U I C T E L R U M
“El numero es perfecto”
no “El número no es perfecto”
fin
Figura 5.2 Diagrama de flujo de programa para encontrar si un número es perfecto Como seguramente se habrá dado cuenta, los diagramas de flujo permiten hacer un seguimiento más claro de la lógica utilizada para resolver el problema. ¿Qué podría responder ahora respecto de las preguntas planteadas anteriormente? Ahora, trabajemos sobre la otra estrategia para desarrollar los diagramas de flujos, que sería dibujar el diagrama sin hacer la miniespecificación.
52
E C I D N Í
Guía didáctica: Lógica de la Programación
Ejemplo 5.1
Resolver mediante un diagrama de flujo el ejemplo 1.2 del cálculo de la edad de una persona que planteamos en la unidad 1, en este caso no vamos a tener como punto de referencia la miniespecificación, sino el análisis del problema que básicamente lo desarrollamos planteando enunciados para las salidas, el proceso y las entradas requeridas. En este caso como el análisis del problema ya fue realizado, vamos a comenzar plasmando en el diagrama las entradas, luego el proceso y finalmente las salidas, esto significa que para analizar el problema, debemos partir desde las salidas, pero para ya idear la solución, debemos comenzar en sentido contrario. Comencemos desarrollando nuestro diagrama con las entradas, para ello repliquemos los enunciados de la parte de entrada, pero numerándolos para poder explicarlo mejor: Enunciados de la entrada 1.
Para el cálculo de la edad es necesario ingresar la fecha de nacimiento y la fecha actual.
2.
Las fechas actual y de nacimiento deben ingresarse en tres números cada una que representan año, mes y día.
3.
La fecha de nacimiento nunca puede ser mayor que la fecha actual.
4.
Un año tiene 12 meses.
5.
Un mes tiene 28, 30 ó 31 días.
6.
Los meses del año pueden tener valores del 1 al 12.
7.
Los días del mes pueden tener valores del 1 al 31.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
En primer lugar todo diagrama de flujo debe comenzar con el símbolo de inicio (figura 5.3), de la siguiente manera: Inicio
Figura 5.3 Inicio de un diagrama de flujo
Luego realizamos la entrada de datos recogiendo los enunciados 1,2, 4 y 5, en este caso no nos estamos preocupando por los mensajes de entrada para el usuario, ni por la validación de los valores máximos y mínimos de cada mes, sin embargo se ha colocado comentarios en el diagrama para que el programador sepa los detalles de cómo se que se debe implementar.
53
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Inicio
An io _n , mes_n, dia_n An io _a , mes_a, dia_a
E
E
S E R A N I M I L E R P
Solicitar año , mes y d ía de nacimient , validando que cumplan con sus valores máximos y m ínimos
Solicitar año , mes y d ía actuales validando que cumplan con sus valores máximos y m ínimos
E R R E T S M I E R M P I B
Figura 5.4 Diagrama de flujo parcial calculo edad, enunciados entrada En cuanto a las entradas hemos considerado todos los enunciados, excepto el número 3, el cual nos plantea que la fecha de nacimiento nunca puede ser mayor a la fecha actual, aunque se puede diseñar instrucciones para validarlo en la entrada, quizá sería más conveniente verificarlo más adelante para reducir un poco la lógica, puesto que de todos modos vamos a comparar los años, los meses y los días. Otra opción puede ser el desarrollo de subrutina que se encargue de esta validación, la cual explicaremos en el siguiente capítulo. Dicho esto vamos a proceder a trabajar con los enunciados relacionados con el proceso, igualmente los numeramos para referenciarlos mejor: Enunciados del proceso
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
1.
Para calcular la edad se debe restar la fecha de nacimiento de la fecha actual.
2.
La fecha debe descomponerse en años, meses y días.
3.
Se debe comenzar restando los días.
4.
Si el día de nacimiento es mayor al día actual debe solicitar un mes expresado en días a los meses de la fecha actual, con lo cual se suman 30 días al día actual y se resta un mes al mes actual.
5.
En segunda instancia debe restarse los meses.
6.
Si el mes de nacimiento es mayor que el mes de la fecha actual, debe solicitar un año expresado en meses a la fecha actual, con lo cual se suman 12 meses al mes actual y se resta un año a año actual.
7.
Finalmente se resta los años.
Para la elaboración del diagrama comencemos con los enunciados 1,2, 3 y 4, lo cual significa que debemos hacer una resta comenzando por los días y necesitamos tres variables para guardar años, meses y días que corresponden a la edad. Acogiendo el enunciado 4 planteamos en primera instancia la pregunta respecto si el día de nacimiento es mayor al día actual, y en caso de serlo sumamos 30 días al día de nacimiento y restamos los mismos 30 días expresados en meses al mes de nacimiento para equilibrar las operaciones, con lo cual finalmente procedemos a realizar la resta.
54
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
An io_ n, mes_n, dia_n
E
An io_ a, mes_a, dia_a
E
dia_n > dia_a
S E R A N I M I L E R P
Solicitar año , m es y día de nacimiento , va lidando que cump lan con sus va lores máximos y mínimos
Inicio
Solicitar añ o , me s y día actuales validando qu e cump lan con sus va lores máximos y mínimos
SI
dia_a
dia_a + 30
mes _a
mes_a - 1
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S
NO
edad_d
dia_a – dia_n
O I R A S O L G
Figura 5.5 Diagrama de flujo parcial cálculo edad. Procesando los meses Ahora procedemos a hacer lo mismo con los meses, sólo que en lugar de sumarle 30 días, debemos sumarle 12 meses de un año, los cual nos lleva a restarle 1 al año de nacimiento para no alterar los datos, el diagrama resultante se encuentra en la figura 5.6. Para culminar con los enunciados del procesamiento, vamos a trabajar con los años, y puesto que hemos postergado hasta aquí el control del enunciado 3 de la entrada, que dice que la fecha de nacimiento, no puede ser mayor a la fecha actual, lo implementaremos con la verificación de que el año de nacimiento no sea mayor que el año actual, y en caso de serlo, notificaremos un error, además aquí consideramos los enunciados de la salida, que básicamente nos dicen que la edad se debe expresar en formato de año, mes y día, que no puede haber edades negativas, ni tampoco meses o días que superen el límite establecido. El diagrama resultante se muestra en la figura 5.7.
55
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Solicitar año , mes y d ía de nacimiento , validando que cumplan con sus valores máximos y m ínimos
Inicio
An io _n , mes_n, dia_n
E
An io _a , mes_a, dia_a
E
dia _n > dia_a
S E R A N I M I L E R P
Solicitar añ o , mes y d ía actuales validando que cumplan con sus valores máximos y m ínimos
SI
dia _a
mes_a
E R R E T S M I E R M P I B
dia_a + 30 O E D R N T S U E G M E I S B
mes_a - 1
NO
edad_d
O I R A N O I C U L O S
dia_a – dia_n
m es _n > m es_a
SI
m es_a
anio_a
O I R A S O L G
m es_a + 12
_anio_a - 1
NO
edad_m
S A I O D S E R M U I C T E L R U M
mes_a – mes_n
Figura 5.6 Diagrama de flujo parcial cálculo edad. Procesando los meses
56
E C I D N Í
Guía didáctica: Lógica de la Programación
Solicitar año , mes y día de nacimiento, validando que cumplan con sus valores máximos y mínimo s
Inicio
An io _n , mes_n, dia_n
E
An io _a , mes_a, dia_a
E
S E R A N I M I L E R P
Solicitar añ o , mes y día actuales validando q ue cumplan con sus valores máximos y m ínimos
dia _n > dia_a
SI
dia _a
dia_a + 30
m es_a
E R R E T S M I E R M P I B
m es _a - 1
O E D R N T S U E G M E I S B
NO
edad_d
dia_a – dia_n
m es _n > m es_a
SI
m es_a
m es_a + 12
anio_a
O I R A N O I C U L O S
_anio_a - 1
NO
edad_m
O I R A S O L G
mes_a – mes_n
S
anio_n > anio_a
SI
“Err or: La f echa de n acimiento es mayor a la actual”
S A I O D S E R M U I C T E L R U M
NO
edad_a
anio_a – anio_n
“Edad: “, edad_a, edad_m, edad_d
S
F in
Figura 5.7 Diagrama de flujo cálculo edad
57
E C I D N Í
Guía didáctica: Lógica de la Programación
Una vez que hemos completado el diagrama de la figura 5.7, le invito a que ejecute algunas corridas del diagrama utilizando algunos casos de prueba para ver si el comportamiento de la solución es correcto, es decir funciona bien para todos los casos y se ajusta a las condiciones del problema, como sugerencia para seleccionar las fechas de ingreso, considere a las siguientes: • • •
La fecha de nacimiento menor a la fecha actual (caso normal) Tanto la fecha de nacimiento, como la fecha actual exactamente iguales. (Poco usual) La fecha de nacimiento mayor que la fecha actual. (Caso erróneo)
E R R E T S M I E R M P I B
Utilice las siguientes tablas para ejecutar la corrida. Caso 1: anio_n mes_n
Caso II anio_n mes_n
Caso III anio_n mes_n
dia_n
dia_n
dia_n
anio_a
anio_a
anio_a
mes_a
mes_a
mes_a
dia_a
dia_a
dia_a
edad_a edad_m edad_d Salida
O E D R N T S U E G M E I S B O I R A N O I C U L O S
edad_a edad_m edad_d Salida
O I R A S O L G
edad_a edad_m edad_d Salida
Luego de haber probado el funcionamiento del diagrama de flujo, trate de responder a las siguientes interrogantes: 1.
¿Funciona bien para todos los casos?
2.
¿Hay algún error de concepción que hace que los resultados no siempre sean exactos?
3.
¿Hay alguna manera alterna de desarrollar el diagrama de flujo?
4.
¿Se puede simplificar la solución?
5.
¿Hace falta algún tipo de validación?
S E R A N I M I L E R P
Antes de pasar al siguiente capítulo, complemente su estudio con la sección “Diagramas de flujo para casos prácticos” del texto básico.
58
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
5.3. Ejercicios con diagramas de flujo Para la mayoría de desarrolladores y profesores de programación, la única manera de aprender a programar es programando, esto significa que mientras más ejercicios resuelva mejor desarrollará las competencias requeridas, en tal virtud se ha preparado el presente apartado para ayudarle justamente a realizar ejercicios con diagramas de flujo. Podría simplemente haber colocado los ejercicios y dejar que los resuelva, pero la idea es que los desarrolle con un poco de ayuda, a manera de taller, por tanto vamos a proponer los ejercicios y a dar algunas pautas para su solución.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
EJERCICIOS 5.1
Desarrolle un diagrama de flujo para obtener el salario neto de los empleados de una empresa que ganan de acuerdo a las siguientes condiciones, la horas menores o iguales a 40 se pagan como hora normal que se introduce por teclado, las horas que exceden a las 40 se pagan como extras a 1.5 veces el valor de la hora normal. Los impuestos se deducen de acuerdo a las siguientes condiciones: si gana menos de 2000 USD, no paga impuestos, los siguiente 1500 USD pagan el 20% y el resto el 30%. Para desarrollar este ejercicio léalo detenidamente y elabore en primer lugar los enunciados correspondientes a las salidas, proceso y entradas. Enunciados para la salida 1.
El sueldo debe expresarse en dólares.
2.
Como resultado debe mostrarse el sueldo, los impuestos y el valor neto.
3.
______________________________________________________________
4.
______________________________________________________________
5.
______________________________________________________________
6.
______________________________________________________________
7.
______________________________________________________________
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
59
E C I D N Í
Guía didáctica: Lógica de la Programación
Enunciados para el proceso 1.
El costo de horas normales se obtiene multiplicando las horas hasta 40 por el costo de cada hora ingresada.
2.
______________________________________________________________
3.
______________________________________________________________
4.
______________________________________________________________
5.
______________________________________________________________
6.
______________________________________________________________
7.
______________________________________________________________
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
Enunciados para la entrada proceso
O I R A N O I C U L O S
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
O I R A S O L G
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
S A I O D S E R M U I C T E L R U M
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
60
E C I D N Í
Guía didáctica: Lógica de la Programación
Una vez que ha terminado de desarrollar los enunciados, desarrolle el diagrama de flujo empezando por los enunciados para la entrada de datos, luego para los del procesamiento y finalmente para los de la salida.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
61
E C I D N Í
Guía didáctica: Lógica de la Programación
Luego deberá realizar pruebas de escritorio, ocupe el siguiente espacio para hacerlo. Estas pruebas le permitirán determinar si el algoritmo es correcto o no, si no lo es, identifique el problema y corrija el diagrama para que arroje los resultados correctos.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
62
E C I D N Í
Guía didáctica: Lógica de la Programación
EJERCICIOS 5.2
Este ejercicio se trata de analizar un diagrama de flujo y establecer si es correcto o no con los casos de prueba planteados. Si encuentra algún problema debe corregirlo y probarlo nuevamente, de modo que se asegure de que funciona. Planteamiento del problema: Se desea desarrollar un algoritmo que permita establecer si un número es primo. Por definición “En matemáticas, un número primo es un número natural que tiene únicamente dos divisores naturales distintos: él mismo y el 1”, y además la unidad no se considera como número primo7. La estrategia usada para el desarrollo se basa en la definición y consiste en contar el número de divisores exactos comprendidos entre la unidad y el número. Inicio
ß2
d <= num
num % d = 0
SI
d E x a c to s
d E x a c to s + 1
S A I O D S E R M U I C T E L R U M
d+1
d
dExactos = 0
O E D R N T S U E G M E I S B
O I R A S O L G
NO d
E R R E T S M I E R M P I B
O I R A N O I C U L O S
nu m
d
S E R A N I M I L E R P
SI
“El numero es primo”
NO
“El número no es primo”
F in
Figura 5.8 Diagrama de flujo para determinar si un número es primo
63
E C I D N Í
Guía didáctica: Lógica de la Programación
Ahora sí, manos a la obra, verifique si el diagrama de flujo funciona con los números 1, 2, 4, 5, 9,11, 13, 33. Utilice el siguiente espacio para resolver la tarea propuesta: Pruebas de Escritorio num
d
dExactos
resultado
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
7. Wikipedia (2009): Numero Primo , [En línea] Disponible en: http://es.wikipedia.org/wiki/N%C3%BAmero_primo [Consulta 25-06-2009].
64
E C I D N Í
Guía didáctica: Lógica de la Programación
Si encontró el problema, utilice el siguiente espacio para proponer un diagrama que lo corrija.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
65
E C I D N Í
Guía didáctica: Lógica de la Programación
EJERCICIOS 5.3
El propósito de ejercicio es optimizar el diagrama de modo que se reduzcan el número de ciclos del bucle. Para darse cuenta qué opciones hay para ello ejecútelo con los mismos datos del ejercicio anterior para que analice el porqué el número de ciclos es alto. Hay al menos dos forma de optimizarlo.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
Inicio
nu m
esPrimo
D
O E D R N T S U E G M E I S B
1
O I R A N O I C U L O S
2
d <= num
num % d = 0
SI
esPrimo
O I R A S O L G
0
NO d
S A I O D S E R M U I C T E L R U M
d+1
d
esPrimo = 1
“El numero es primo”
“El número no es primo”
F in
Figura 5.9 Diagrama de flujo para verificar si un número es primo 66
E C I D N Í
Guía didáctica: Lógica de la Programación
EJERCICIOS 5.4
Se desea construir un algoritmo que le permita generar una tabla de amortización de préstamos para lo cual se requiere calcular lo que debe pagar mensualmente hasta que termine de realizar los pagos. Los intereses siempre se pagan sobre el saldo del capital prestado, por lo tanto nunca una cuota es mayor igual que la del mes anterior. Ahora intente resolver el problema en un diagrama de flujo.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
Luego de ver el problema, es probable no haya podido hacer absolutamente nada por falta de información, ahora ¿Cómo se supone que debemos resolver este problema?
67
E C I D N Í
Guía didáctica: Lógica de la Programación
De acuerdo a lo estudiado debemos comenzar haciendo el análisis del problema, esto es identificando y elaborando enunciados para las salidas, proceso y finalmente para las entradas. Luego podemos optar por desarrollar la miniespecificación o directamente el diagrama de flujo.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
68
E C I D N Í
Guía didáctica: Lógica de la Programación
Autoevaluación 5
Ánimo, ya ha concluido la Unidad 5, sólo le falta medir cuánto aprendió en ella, para ello lo invito a desarrollar el examen rápido del capítulo 8 del texto básico.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
69
E C I D N Í
Guía didáctica: Lógica de la Programación
UNIDAD 6. DESARROLLO DE PROBLEMAS DE PROGRAMACIÓN La práctica de la programación es un arte y una ciencia muy interesante para nosotros como seres humanos, el hecho de poder diseñar algo que es capaz de procesar la información es de por sí una creación en la que plasmamos nuestra forma de resolver los problemas. A lo largo de la presente guía didáctica, nuestro principal interés ha sido el de inducir el pensamiento lógico aplicado a la solución de problemas de programación, en este capítulo vamos a usar todo lo aprendido para diseñar un pequeño programa, considerando cada uno de los componentes. Puesto que hasta ahora no ha tenido la oportunidad de ver funcionando nada en la computadora, vamos a usar una herramienta de programación visual conocida como RAPTOR, desarrollada por La Academia Pilotos de las Fuerzas Armadas de los Estados Unidos, en la cual tendrá la oportunidad de diseñar sus diagramas de flujo y ejecutarlos para ver los resultados, vale aclarar, que el uso de esta herramienta sirve únicamente para ayudarle a visualizar cómo funciona la lógica de un programa.
Para el desarrollo de los contenidos de esta unidad, utilizaremos el capítulo 9 del texto básico. Los capítulos 10,11,12 y 13 le enseñan a traducir los algoritmos o las miniespecificaciones a un lenguaje como Visual Basic.Net, Java, C# o C++, cuyo estudio está fuera del alcance de esta asignatura y por lo tanto queda a su criterio el estudiarlos.
6.1. Abstracción de problemas de programación El esquema básico de funcionamiento del computador, como mencionamos en la Unidad 1, es de entradas, proceso, almacenamiento y salida, por tanto una aplicación de software debe corresponder con estas funciones, a cada una de éstas le vamos a llamar capas. En la siguiente tabla vamos establecer la correspondencia entre las funciones y las capas. Función Entrada Proceso
Almacenamiento
Salida
Capa Interfaz de usuario Lógica de proceso
Descripción Corresponde a los elementos en pantalla u otro dispositivo que permite que el usuario ingrese información. Código de programa que ejecuta las tareas de procesamiento de una aplicación. Toma los datos de entrada y los procesa para almacenarlo o para enviarlos a un dispositivo de salida. Esta capa incluye los datos y estructuras de datos que se guardan en la memoria principal del computador (RAM) que son requeridos para realizar el procesamiento. Datos Estructura de datos o archivos que guardan la información, aunque se dice que el almacenamiento es lógico, muchas de las veces se lo conoce como almacenamiento físico porque se guarda en un disco u otro dispositivo ocupando espacio físico en disco. Interfaz de Nos referimos nuevamente a la interfaz de usuario en razón de que la interfaz usuario sirve para interactuar, esto es ingresar o visualizar información. Muchas de las veces la salida puede ser un sonido, una impresión o un mensaje.
70
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Sin importar el tamaño de la aplicación, siempre debemos pensar en estas capas, aunque puede haber programas que no las requieran, por ejemplo un programa podría no requerir la capa de almacenamiento, porque no guarda información. Es posible también que existan programas con muchas más capas debido a la complejidad de los mismos, normalmente esto se da en aplicaciones corporativas, las cuales tienen en su diseño varias capas, el mismo que se conoce como la arquitectura de la aplicación. Ahora, vamos tomar una de las aplicaciones que hemos desarrollado para identificar en ellas las diferentes capas, por supuesto que no van a estar muy elaboradas, puesto que no hemos centrado nuestro interés en el desarrollo de interfaces sofisticadas, sin embargo vamos a ver que si tiene al menos 3 de las 4 capas, puesto que en ninguna de ellas hemos guardado información en disco, eso significa que no tendrá la capa de datos.
Cálculo de la edad de una persona En el ejemplo del cálculo de la edad de una persona identificamos las siguientes capas. Si no recuerda revise nuevamente el ejercicio del diagrama correspondiente a la unidad 5. Capa de interfaz de usuario Puesto que hemos dicho que la interfaz de usuario corresponde a las entradas o salidas de la información, en nuestro diagrama la interfaz de usuario estaría dada por los símbolos de la figura 6.1:
E
A nio _a , mes_a, dia_a
E
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
EJERCICIOS 6.1
A nio _n , mes_n, dia_n
S E R A N I M I L E R P
O I R A N O I C U L O S O I R A S O L G
“Eda d: “, edad_a, edad_m, edad_d
S
S
S A I O D S E R M U I C T E L R U M
“Erro r: La fecha de n acimiento es mayor a la actual”
Figura 6.1 Instrucciones del diagrama para interfaz de usuario Si analiza un poco los diagramas, estos corresponde al símbolo de datos, es decir a las instrucciones de ingreso ó salida de información. Puesto que en un diagrama no es necesario incluir elementos gráficos de interfaz, esto se ha omitido acá, pero en los programas es necesario implementar ciertos diseños de pantallas que resulten más agradables al usuario y le permitan comprender de manera intuitiva el funcionamiento de la aplicación, a los programas que cumplen con esta característica se los conoce como amigables. En la figura 6.2 colocamos un ejemplo de cómo podría ser una pantalla para esta misma aplicación.
71
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
E R R E T S M I E R M P I B
Figura 6.2 Modelos de interfaz de usuario El ejemplo de la figura 6.2 muestra una interfaz básica en la que las ventanas aparecen conforme se va ejecutando la aplicación, pero las aplicaciones de software normalmente utilizan modelos de interfaz que integran tanto componentes de entrada como componentes de salida, tal como se aprecia en la figura 6.3, la cual ha sido desarrollada en java con el IDE netbeans.
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
Figura 6.3 Modelo de interfaz de usuario avanzado
72
E C I D N Í
Guía didáctica: Lógica de la Programación
Capa de lógica de proceso A la lógica de procesamiento corresponden los siguientes símbolos, si se analizan con cuidado estos procesos se ejecutan luego de que se completó el proceso de ingreso de datos y el usuario no tiene idea de lo que está pasando internamente. Las instrucciones del diagrama correspondientes a esta capa son las que se muestran en la figura 6.4 dia _n > dia_a
SI
dia _a
dia_a + 30
m es_a
E R R E T S M I E R M P I B
m es _a - 1
NO
edad_d
O E D R N T S U E G M E I S B
dia_a – dia_n
m es _n > m es_a
SI
m es_a
m es_a + 12
anio_a
_anio_a - 1 O I R A N O I C U L O S
NO
edad_m
S E R A N I M I L E R P
mes_a – mes_n
O I R A S O L G
anio_n > anio_a
NO
edad_a
S A I O D S E R M U I C T E L R U M
anio_a – anio_n
Figura 6.4 Instrucciones del diagrama para capa de proceso Capa de datos En este problema, no se usa una capa de datos, puesto que no hay almacenamiento secundario, todos los datos de entrada se procesan para producir la salida y termina sin almacenamiento.
Ejercicios Pongamos en práctica lo visto en esta sección, realizando los siguientes ejercicios: •
Desarrolle un análisis de capas similar al aplicado al cada uno de los problemas desarrollados en la sección 5.3 de la guía.
•
Diseñe posibles interfaces de usuario para cada uno de los ejercicios de la sección 5.3. Puede usar Microsoft Visio u otro diagramador para hacerlo. 73
E C I D N Í
Guía didáctica: Lógica de la Programación
6.2. Componentes de una aplicación Al igual que cualquier producto, el software se compone de una serie de elementos que son fabricados de código, por tanto los componentes son lógicos. En el apartado anterior abstraíamos las capas que forman parte de una aplicación en la que hacíamos mención a diferentes instrucciones del diagrama de flujo, pero estas instrucciones se organizan de manera lógica en diferentes tipos de componentes, los cuales vamos a listar a continuación. Capa
Interfaz de usuario
Lógica de proceso
Datos
Nombre del componente Ventanas Formularios Botones Cuadros de texto Listas combinadas Listas Funciones Procedimientos Clases Módulos Variables Constantes Archivos Tablas
S E R A N I M I L E R P
E R R E T S M I E R M P I B
Descripción Son objetos propios de interfaz de usuario que normalmente se los encuentra como librerías de los lenguajes de programación, o se pueden crear y definir como componentes reutilizables en bibliotecas de componentes.
Elementos de código que construye el programador a los cuales les asigna la responsabilidad de procesar y validar la información.
Elementos que poseen una estructura que se guarda físicamente en el disco duro con información relacionada a la aplicación.
Estos son los componentes que por lo general se encuentra en las aplicaciones de software, y si usted ha tenido oportunidad de desarrollar alguna aplicación, habrá reconocido algunos de ellos. Suele ocurrir con mucha frecuencia que en el código de muchas aplicaciones no se distingue las capas que indicamos, y esto es un problema sobre todo cuando surgen cosas que hay que corregir, por ello es importante desde el inicio tener en cuenta esta estructura para diseñar las aplicaciones adecuadamente, de todos modos en el alcance de la asignatura no revisamos este tipo de aplicaciones, sin embargo usted puede estudiar por su cuenta el tema en los capítulos posteriores del texto para programación en alguno de los lenguajes establecidos. Ahora bien, si piensa un poco en la capa de interfaz, lenguajes como Visual Basic, traen una interfaz de desarrollo que permite colocar estos elemento en la ventana donde se ejecutarán, de modo que los programadores no pierdan mucho tiempo dándoles forma y se puedan centrar en la capa de procesamiento. En la capa de lógica de programación, los componentes tales como las funciones y procedimientos pueden ser provistos por el lenguaje de programación o desarrollados como parte de la aplicación, por ello es importante conocer las prestaciones que ofrece un lenguaje determinado para simplificar nuestra tarea de programación. Funciones y Procedimientos Conocemos como funciones y procedimientos a ciertas partes de código que se diseñan para cumplir una tarea específica y devolver el control a la sección de código que la llamó, en términos generales
74
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
se las conoce como subrutinas y si recuerda el capítulo 5, la llamada a las mismas se representa con el símbolo . Las subrutinas hacen que los programas sean mucho más eficientes. Las subrutinas que caen en la denominación de funciones se caracterizan porque siempre devuelven un valor que es almacenado en una variable o se usan como parte de una expresión, por ejemplo la función pi() puede devolver el valor de π, en este caso no necesita recibir ningún parámetro de entrada. Por otro lado las que caen en categoría de procedimientos se caracterizan porque al ser llamadas ejecutan una acción, pero no retornan ningún valor y por tanto no pueden colocarse como parte de una expresión. En la tabla 6.1 nos permitimos listar algunas de las funciones comunes que la mayoría de lenguajes de programación suelen traer.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
Tabla 6.1 Tabla de funciones comunes en lenguajes de programación Función abs(n) sqrt(n) sqr (n) random(n) log(n) exp (n) ln()
O E D R N T S U E G M E I S B
Descripción Devuelve el valor absoluto de n, es decir ignora el signo de positivo o negativo. Obtiene la raíz cuadrada de n. Obtiene el cuadrado de n. Obtiene un número aleatorio comprendido entre 0 y n. Devuelve el logaritmo de n. Devuelve el antilogaritmo de n. Devuelve el logaritmo natural de n.
O I R A N O I C U L O S
Tal como lo imagina el contar con estas funciones hacen que se simplifique considerablemente el esfuerzo de programación, todos los lenguajes de programación entre ellos java, c++, c#, Visual Basic, ofrecen un rico conjunto de funciones que se pueden usar en la fase de codificación. Librerías Para sacar el máximo provecho a estas funciones y procedimientos, lo que se suele hacer es crear bibliotecas de código, de forma tal que puedan ser utilizadas en más de un programa. Archivos de datos Cuando usted desarrolla un aplicación que necesita guardar información tiene dos opciones para hacerlo, la primera es crear archivos de datos tipo texto o binarios que sólo puede ser leídos por su aplicación y la segunda es utilizar un sistema gestor de base de datos tal como mysql, Access, Sqlserver entre otros, en cuyo caso se vale del lenguaje que implementa el motor de base de datos para manipularlos.
6.3. Desarrollo de aplicaciones sencillas Hasta aquí, usted ha tenido la oportunidad de conocer y aplicar algunas herramientas de diseño de programas para computadora, y quizá se haya preguntado porque no ha utilizado el computador. Pues bien llegó el momento de hacerlo, y para ello en el disco anexo a la guía didáctica encontrará el programa Raptor,
75
O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Una característica muy importante de Raptor es que le permite dibujar el diagrama de flujo y ejecutarlo, mostrando además los valores de las variables utilizadas, es decir le ahorra todo el proceso manual, además entre otras cosas le permite generar código para lenguajes como Ada, Java, C++ o puede generar un programa ejecutable que funciona como cualquier aplicación. No queremos extendernos más en el asunto y pongámonos manos a la obra, lo que sí debemos advertirle es que hay algunas variaciones en los símbolos usados para realizar los diagramas en Raptor, de todos modos deberá estudiarlo para poder hacer uso de él. Iniciemos instalando el programa Raptor que se encuentra en su disco, si tiene alguna dificultad, consulte la documentación. Una vez que ha logrado instalar Raptor, tome el capítulo 9 de su texto básico y desarrolle los ejemplos y aplicaciones que el autor propone.
Estoy seguro de que se siente muy entusiasmado con el uso de esta herramienta, en realidad se puede hacer muchas cosas, por tanto lo que queda es desarrollar más ejercicios y quizá estaría demás decir que programe en raptor todos los ejercicios desarrollados hasta ahora. Para completar este capítulo, nos hemos permitido desarrollar una aplicación completa en Raptor con el propósito de que entienda como se construye una aplicación.
Ejemplo 6.1
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
Desarrollar en Raptor un programa para jugar al ahorcado. Descripción de la aplicación: Se trata del juego del ahorcado en el cual se le pide al usuario que adivine una palabra seleccionada al azar, para lo cual debe ingresar de una en una las letras que considera que la forman, si la letra está en la palabra debe mostrarse en su posición, los demás espacios se muestran como guiones para que tenga una idea de la longitud de la palabra, si la letra no consta en la palabra del juego o está repetida se contará como error e irá dibujando poco a poco un muñeco por cada error cometido, hasta que el muñeco se ahorca, si acierta y adivina la palabra, deberá felicitarle. En cualquiera de los dos casos termina el juego. Revisemos ahora los enunciados para este juego: Salidas: 1.
Mostrar la palabra con las letras que adivinó y guiones en aquellas que no acertó, esto por cada letra que ingresa el usuario.
2.
Si adivina la palabra en la cantidad de intentos datos, debe felicitar al usuario.
3.
Si no logra adivinar debe presentar un dibujo de un muñeco ahorcado y termina el juego.
76
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Proceso: 1.
Debe contar con una lista de palabras para seleccionar una de ellas aleatoriamente.
2.
Cada letra correcta se muestra en pantalla.
3.
Cada error cometido produce un paso hacia el ahorcamiento del muñeco.
4.
Se considera como error a una letra repetida o una letra que no consta en la palabra.
S E R A N I M I L E R P
Entrada: 1.
Se requiere que el usuario ingrese letras hasta que adivine la palabra o hasta que se le acaben las opciones.
Como podrá darse cuenta, los enunciados nos pueden llevar a detalles de implementación mucho más complejos, pero a medida que se explique la aplicación las únicas habilidades que necesita son las de poder escribir expresiones correctamente y utilizar adecuadamente los diagramas de flujo, por lo tanto le sugiero que si tuvo alguna dificultad con el seguimiento del capítulo del texto básico indicado, lo retome hasta comprenderlo debidamente. Ahora analicemos los componentes de la aplicación por capas: CAPA DE INTERFAZ A este nivel nos hemos permitido desarrollar dos componentes, el primero es una pantalla de ingreso de las letras, y el segundo es una pantalla gráfica que muestra el estado de la palabra y en caso de cometer errores el dibujo del muñeco ahorcándose. En las figuras 6.5 y 6.6 se muestran las interfaces definidas para el efecto. Recuerde que en la capa de interfaz representamos tanto las entradas como las salidas.
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
Figura 6.5 Interfaz para el ingreso de datos
77
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
Figura 6.6 Interfaz gráfica de salida de la aplicación. CAPA DE LÓGICA A nivel de lógica necesitamos datos predefinidos y varios grupos de instrucciones organizados en subrutinas, las cuales debemos ir llamando conforme las necesitemos, además debemos hacer uso de varias funciones de la biblioteca de raptor que nos permitan hacer cosas como seleccionar aleatoriamente una palabra, inicializar el modo gráfico y dibujar las figuras. A nivel de diagramas y subdiagramas necesitamos lo siguiente: 1.
Un programa principal desde donde empieza a ejecutarse la aplicación.
2.
Varios subprogramas con propósitos específicos, algunos de ellos necesitan recibir ciertos datos de entrada para poder realizar su tarea, en este caso hablamos de procedimientos. Los podemos apreciar en la Tabla 6.2
78
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
Tabla 6.2 Lista de diagramas y subdiagramas que conforman la aplicación Nombre main crear_lista inicializar_palabra ahorcar escribir
inicializar_juego crear_interfaz
Propósito Programa principal, desde aquí se ejecuta toda la aplicación. Crea la lista de palabras en una matriz. Rellena con guiones la palabra que se le muestra al usuario. Dibuja paso a paso el muñeco del juego. Dibuja la palabra donde constan las letras acertadas y guiones en las demás. Crea el entorno de datos necesario para poder comenzar el juego. Crea la interfaz gráfica.
S E R A N I M I L E R P
Llamado desde No debe tener llamadas. inicializar_juego. inicializar_juego.
E R R E T S M I E R M P I B
main. main.
O E D R N T S U E G M E I S B
main . main .
CAPA DE DATOS Aunque la aplicación no guarda la información en archivos, requiere de datos que en este caso son las palabras que debe adivinar, para ello usamos un arreglo que es una variable capaz de contener varias casillas con una palabra cada una, a ellas se puede acceder con el nombre del arreglo y un subíndice entre corchetes, esto se puede apreciar en el sub diagrama inicializar_lista. Una recomendación importante que quiero hacerle es que haga el seguimiento al programa completo, puede hacerlo manualmente o preferentemente en el entorno Raptor, puesto que va resaltando cada instrucción y muestra los valores de las variables.
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
Para visualizar y analizar la aplicación abra el archivo ahorcado.rap que se encuentra en el CD en la carpeta ejemplos raptor
EJERCICIOS 6.1
Con lo aprendido en este capítulo, desarrolle un juego en Raptor en el cual teniendo un máximo de 7 intentos la máquina adivina un número del 1 al 100 pensado por el usuario utilizando el método de la búsqueda binaria. La búsqueda binaria consiste en dividir el rango de números posible en 2 y realizar dos preguntas, la primera mostrar el número del centro del rango y preguntar si se trata de ese número, si el usuario dice que es correcto el computador a logrado adivinar el número y termina, en caso de no ser el número, realiza la segunda pregunta que sería si el número es mayor o menor, si es mayor divide el rango nuevamente cogiendo el grupo superior y repite el proceso, luego si es menor hace lo mismo con el rango inferior, de modo que cada vez va encerrando al número. Si no lo logra en 7 intentos, el usuario respondió incorrectamente las preguntas, en este caso debe alertar del particular.
79
E C I D N Í
Guía didáctica: Lógica de la Programación
Con este tema finalizamos la asignatura, y estamos seguros de que les será de gran utilidad para las asignaturas siguientes, como recomendación final le sugerimos seleccione uno de los lenguajes de programación desarrollados en el libro y trate de programar en el las soluciones dadas. En el disco adjunto a la guía hemos incluido algunos de los lenguajes de programación como java y c++ para que los use en su aprendizaje.
S E R A N I M I L E R P
E R R E T S M I E R M P I B
Autoevaluación 6
Concluya el estudio de esta materia desarrollando el examen rápido del capítulo 9 del texto básico. O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
80
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
8. Solucionario PRIMER BIMESTRE Autoevaluación 1
Pregunta
E R R E T S M I E R M P I B
Respuesta Parte 1
1.
a
2.
b
3.
a
4.
b
5.
c
O E D R N T S U E G M E I S B O I R A N O I C U L O S
Parte 2 6.
V
7.
F
8.
F
9.
V
10.
V
O I R A S O L G
S A I O D S E R M U I C T E L R U M
81
E C I D N Í
Guía didáctica: Lógica de la Programación
Autoevaluación 2
Pregunta
S E R A N I M I L E R P
Respuesta Parte 1
1.
c
2.
a
3.
c
4.
b
5.
c
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
Parte 2 6.
V
7.
F
8.
F
9.
F
10.
V
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
82
E C I D N Í
Guía didáctica: Lógica de la Programación
Autoevaluación 3
Pregunta
S E R A N I M I L E R P
Respuesta Parte 1
1.
c
2.
a
3.
c
4.
a
5.
b
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
Parte 2 6.
F
7.
F
8.
F
9.
V
10.
V
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
83
E C I D N Í
Guía didáctica: Lógica de la Programación
SEGUNDO BIMESTRE
S E R A N I M I L E R P
Autoevaluación 4
Pregunta
Respuesta Parte 1
1.
b
2.
c
3.
a
4.
a
5.
c
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
Parte 2 6.
F
7.
F
8.
F
9.
V
10.
F
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
84
E C I D N Í
Guía didáctica: Lógica de la Programación
Autoevaluación 5
Pregunta
S E R A N I M I L E R P
Respuesta Parte 1
1.
a E R R E T S M I E R M P I B
Cam bios de estado (variables de trabajo) Estructuras de control
Estructuras de d ecisión
O E D R N T S U E G M E I S B
Cam bios de estado (variables de trabajo)
Declaraciones
O I R A N O I C U L O S
Petición de datos muestra
O I R A S O L G
S A I O D S E R M U I C T E L R U M
85
E C I D N Í
Guía didáctica: Lógica de la Programación
Autoevaluación 6
Pregunta
S E R A N I M I L E R P
Respuesta Parte 1
1.
b
2.
c
3.
b
4.
b
5.
a
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
Parte 2 6.
F
7.
V
8.
F
9.
V
10.
V
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
86
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
9. Glosario ADA.- Lenguaje de programación orientado a objetos. Algoritmo.- Secuencia ordenada de pasos que nos permiten realizar alguna actividad. Aplicación.- Conjunto de componentes de software y datos que permiten resolver problemas o realizar actividades con la ayuda del computador. Bucle.- Estructura de control que permite la repetición de una o más instrucciones, existen tres tipos de bucles, los que evalúan la condición a la entrada, los que evalúan la condición a la salida y los que se ejecutan un determinado número de veces con la ayuda de un contador. Booleano.- Se puede aplicar a una variable o a una expresión cuyo valor puede ser verdadero o falso. Deriva del Álgebra de Boole. Condición.- Expresión booleana que se usa para desviar el flujo del programa o terminar un bucle. Constante.- Espacio de memoria capaz de guardar un valor que no cambia durante la ejecución de un programa. Matemáticamente son valores fijos que se utilizan para realizar diferentes cálculos. Conclusión.- Resultado al que se llega partiendo de unas premisas y aplicando reglas de inferencia. C++.- Lenguaje de programación orientado a objetos muy utilizado en el desarrollo de aplicaciones de mediano y bajo nivel, deriva del lenguaje C. C# (si charp).- Versión de C orientado a objetos desarrollado por Microsoft he incluido en su plataforma Visual Studio .Net. Expresión.- Grupo de constantes y/o variables con operadores que de acuerdo a una sintaxis permite realizar la transformación de los datos, sus resultados se almacenan en variables. Enunciado.- En lógica de programación es una expresión lingüística que establece un pensamiento, puede ser interrogativo, imperativo o declarativo. MPAE&JSCB/ vt/ 05-08-09/83 Digitalizado/2014-07-20
87
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
E C I D N Í
Guía didáctica: Lógica de la Programación
S E R A N I M I L E R P
10. Recursos educativos multimedia
Videoconferencias Primer Bimestre
Diapositivas Primer Bimestre
1. Análisis de problemas
1. Análisis de problemas
2. Resolución de expresiones
2. Resolución de expresiones
3. Algoritmo de análisis
3. Algoritmo de análisis
Segundo Bimestre
E R R E T S M I E R M P I B
O E D R N T S U E G M E I S B
Segundo Bimestre
1. Sentencias condicionales
1. Sentencias condicionales
2. Bucles
2. Bucles
3. Pruebas de escritorio
3. Pruebas de escritorio
O I R A N O I C U L O S O I R A S O L G
S A I O D S E R M U I C T E L R U M
88